64539 lines
2.0 MiB
64539 lines
2.0 MiB
import {
|
|
arrow_down_default,
|
|
arrow_left_default,
|
|
arrow_right_default,
|
|
arrow_up_default,
|
|
back_default,
|
|
calendar_default,
|
|
caret_right_default,
|
|
caret_top_default,
|
|
check_default,
|
|
circle_check_default,
|
|
circle_check_filled_default,
|
|
circle_close_default,
|
|
circle_close_filled_default,
|
|
clock_default,
|
|
close_default,
|
|
d_arrow_left_default,
|
|
d_arrow_right_default,
|
|
delete_default,
|
|
document_default,
|
|
full_screen_default,
|
|
hide_default,
|
|
info_filled_default,
|
|
loading_default,
|
|
minus_default,
|
|
more_default,
|
|
more_filled_default,
|
|
picture_filled_default,
|
|
plus_default,
|
|
question_filled_default,
|
|
refresh_left_default,
|
|
refresh_right_default,
|
|
scale_to_original_default,
|
|
search_default,
|
|
sort_down_default,
|
|
sort_up_default,
|
|
star_default,
|
|
star_filled_default,
|
|
success_filled_default,
|
|
view_default,
|
|
warning_filled_default,
|
|
zoom_in_default,
|
|
zoom_out_default
|
|
} from "./chunk-QSNQDAYH.js";
|
|
import {
|
|
Comment,
|
|
Fragment,
|
|
NOOP,
|
|
Teleport,
|
|
Text,
|
|
Transition,
|
|
TransitionGroup,
|
|
camelize,
|
|
capitalize,
|
|
cloneVNode,
|
|
computed,
|
|
createApp,
|
|
createBaseVNode,
|
|
createBlock,
|
|
createCommentVNode,
|
|
createElementBlock,
|
|
createSlots,
|
|
createTextVNode,
|
|
createVNode,
|
|
customRef,
|
|
defineComponent,
|
|
effectScope,
|
|
getCurrentInstance,
|
|
getCurrentScope,
|
|
guardReactiveProps,
|
|
h,
|
|
hasOwn,
|
|
hyphenate,
|
|
inject,
|
|
isArray,
|
|
isDate,
|
|
isFunction,
|
|
isObject,
|
|
isPlainObject,
|
|
isPromise,
|
|
isRef,
|
|
isString,
|
|
isVNode,
|
|
markRaw,
|
|
mergeProps,
|
|
nextTick,
|
|
normalizeClass,
|
|
normalizeProps,
|
|
normalizeStyle,
|
|
onActivated,
|
|
onBeforeMount,
|
|
onBeforeUnmount,
|
|
onBeforeUpdate,
|
|
onDeactivated,
|
|
onMounted,
|
|
onScopeDispose,
|
|
onUnmounted,
|
|
onUpdated,
|
|
openBlock,
|
|
provide,
|
|
reactive,
|
|
readonly,
|
|
ref,
|
|
render,
|
|
renderList,
|
|
renderSlot,
|
|
resolveComponent,
|
|
resolveDirective,
|
|
resolveDynamicComponent,
|
|
shallowReactive,
|
|
shallowRef,
|
|
toDisplayString,
|
|
toHandlerKey,
|
|
toHandlers,
|
|
toRaw,
|
|
toRef,
|
|
toRefs,
|
|
unref,
|
|
useAttrs,
|
|
useSlots,
|
|
vModelCheckbox,
|
|
vModelRadio,
|
|
vModelText,
|
|
vShow,
|
|
warn,
|
|
watch,
|
|
watchEffect,
|
|
withCtx,
|
|
withDirectives,
|
|
withKeys,
|
|
withModifiers
|
|
} from "./chunk-MRB6VBCE.js";
|
|
import {
|
|
__commonJS,
|
|
__toModule
|
|
} from "./chunk-4YJPEX7N.js";
|
|
|
|
// node_modules/dayjs/dayjs.min.js
|
|
var require_dayjs_min = __commonJS({
|
|
"node_modules/dayjs/dayjs.min.js"(exports2, module2) {
|
|
!function(t, e) {
|
|
typeof exports2 == "object" && typeof module2 != "undefined" ? module2.exports = e() : typeof define == "function" && define.amd ? define(e) : (t = typeof globalThis != "undefined" ? globalThis : t || self).dayjs = e();
|
|
}(exports2, function() {
|
|
"use strict";
|
|
var t = 1e3, e = 6e4, n = 36e5, r = "millisecond", i = "second", s2 = "minute", u2 = "hour", a2 = "day", o2 = "week", c2 = "month", f2 = "quarter", h3 = "year", d2 = "date", l2 = "Invalid Date", $ = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, y = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, M2 = { name: "en", weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"), ordinal: function(t2) {
|
|
var e2 = ["th", "st", "nd", "rd"], n2 = t2 % 100;
|
|
return "[" + t2 + (e2[(n2 - 20) % 10] || e2[n2] || e2[0]) + "]";
|
|
} }, m2 = function(t2, e2, n2) {
|
|
var r2 = String(t2);
|
|
return !r2 || r2.length >= e2 ? t2 : "" + Array(e2 + 1 - r2.length).join(n2) + t2;
|
|
}, v2 = { s: m2, z: function(t2) {
|
|
var e2 = -t2.utcOffset(), n2 = Math.abs(e2), r2 = Math.floor(n2 / 60), i2 = n2 % 60;
|
|
return (e2 <= 0 ? "+" : "-") + m2(r2, 2, "0") + ":" + m2(i2, 2, "0");
|
|
}, m: function t2(e2, n2) {
|
|
if (e2.date() < n2.date())
|
|
return -t2(n2, e2);
|
|
var r2 = 12 * (n2.year() - e2.year()) + (n2.month() - e2.month()), i2 = e2.clone().add(r2, c2), s3 = n2 - i2 < 0, u3 = e2.clone().add(r2 + (s3 ? -1 : 1), c2);
|
|
return +(-(r2 + (n2 - i2) / (s3 ? i2 - u3 : u3 - i2)) || 0);
|
|
}, a: function(t2) {
|
|
return t2 < 0 ? Math.ceil(t2) || 0 : Math.floor(t2);
|
|
}, p: function(t2) {
|
|
return { M: c2, y: h3, w: o2, d: a2, D: d2, h: u2, m: s2, s: i, ms: r, Q: f2 }[t2] || String(t2 || "").toLowerCase().replace(/s$/, "");
|
|
}, u: function(t2) {
|
|
return t2 === void 0;
|
|
} }, g = "en", D2 = {};
|
|
D2[g] = M2;
|
|
var p2 = "$isDayjsObject", S2 = function(t2) {
|
|
return t2 instanceof _2 || !(!t2 || !t2[p2]);
|
|
}, w2 = function t2(e2, n2, r2) {
|
|
var i2;
|
|
if (!e2)
|
|
return g;
|
|
if (typeof e2 == "string") {
|
|
var s3 = e2.toLowerCase();
|
|
D2[s3] && (i2 = s3), n2 && (D2[s3] = n2, i2 = s3);
|
|
var u3 = e2.split("-");
|
|
if (!i2 && u3.length > 1)
|
|
return t2(u3[0]);
|
|
} else {
|
|
var a3 = e2.name;
|
|
D2[a3] = e2, i2 = a3;
|
|
}
|
|
return !r2 && i2 && (g = i2), i2 || !r2 && g;
|
|
}, O2 = function(t2, e2) {
|
|
if (S2(t2))
|
|
return t2.clone();
|
|
var n2 = typeof e2 == "object" ? e2 : {};
|
|
return n2.date = t2, n2.args = arguments, new _2(n2);
|
|
}, b2 = v2;
|
|
b2.l = w2, b2.i = S2, b2.w = function(t2, e2) {
|
|
return O2(t2, { locale: e2.$L, utc: e2.$u, x: e2.$x, $offset: e2.$offset });
|
|
};
|
|
var _2 = function() {
|
|
function M3(t2) {
|
|
this.$L = w2(t2.locale, null, true), this.parse(t2), this.$x = this.$x || t2.x || {}, this[p2] = true;
|
|
}
|
|
var m3 = M3.prototype;
|
|
return m3.parse = function(t2) {
|
|
this.$d = function(t3) {
|
|
var e2 = t3.date, n2 = t3.utc;
|
|
if (e2 === null)
|
|
return new Date(NaN);
|
|
if (b2.u(e2))
|
|
return new Date();
|
|
if (e2 instanceof Date)
|
|
return new Date(e2);
|
|
if (typeof e2 == "string" && !/Z$/i.test(e2)) {
|
|
var r2 = e2.match($);
|
|
if (r2) {
|
|
var i2 = r2[2] - 1 || 0, s3 = (r2[7] || "0").substring(0, 3);
|
|
return n2 ? new Date(Date.UTC(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s3)) : new Date(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s3);
|
|
}
|
|
}
|
|
return new Date(e2);
|
|
}(t2), this.init();
|
|
}, m3.init = function() {
|
|
var t2 = this.$d;
|
|
this.$y = t2.getFullYear(), this.$M = t2.getMonth(), this.$D = t2.getDate(), this.$W = t2.getDay(), this.$H = t2.getHours(), this.$m = t2.getMinutes(), this.$s = t2.getSeconds(), this.$ms = t2.getMilliseconds();
|
|
}, m3.$utils = function() {
|
|
return b2;
|
|
}, m3.isValid = function() {
|
|
return !(this.$d.toString() === l2);
|
|
}, m3.isSame = function(t2, e2) {
|
|
var n2 = O2(t2);
|
|
return this.startOf(e2) <= n2 && n2 <= this.endOf(e2);
|
|
}, m3.isAfter = function(t2, e2) {
|
|
return O2(t2) < this.startOf(e2);
|
|
}, m3.isBefore = function(t2, e2) {
|
|
return this.endOf(e2) < O2(t2);
|
|
}, m3.$g = function(t2, e2, n2) {
|
|
return b2.u(t2) ? this[e2] : this.set(n2, t2);
|
|
}, m3.unix = function() {
|
|
return Math.floor(this.valueOf() / 1e3);
|
|
}, m3.valueOf = function() {
|
|
return this.$d.getTime();
|
|
}, m3.startOf = function(t2, e2) {
|
|
var n2 = this, r2 = !!b2.u(e2) || e2, f3 = b2.p(t2), l3 = function(t3, e3) {
|
|
var i2 = b2.w(n2.$u ? Date.UTC(n2.$y, e3, t3) : new Date(n2.$y, e3, t3), n2);
|
|
return r2 ? i2 : i2.endOf(a2);
|
|
}, $2 = function(t3, e3) {
|
|
return b2.w(n2.toDate()[t3].apply(n2.toDate("s"), (r2 ? [0, 0, 0, 0] : [23, 59, 59, 999]).slice(e3)), n2);
|
|
}, y2 = this.$W, M4 = this.$M, m4 = this.$D, v3 = "set" + (this.$u ? "UTC" : "");
|
|
switch (f3) {
|
|
case h3:
|
|
return r2 ? l3(1, 0) : l3(31, 11);
|
|
case c2:
|
|
return r2 ? l3(1, M4) : l3(0, M4 + 1);
|
|
case o2:
|
|
var g2 = this.$locale().weekStart || 0, D3 = (y2 < g2 ? y2 + 7 : y2) - g2;
|
|
return l3(r2 ? m4 - D3 : m4 + (6 - D3), M4);
|
|
case a2:
|
|
case d2:
|
|
return $2(v3 + "Hours", 0);
|
|
case u2:
|
|
return $2(v3 + "Minutes", 1);
|
|
case s2:
|
|
return $2(v3 + "Seconds", 2);
|
|
case i:
|
|
return $2(v3 + "Milliseconds", 3);
|
|
default:
|
|
return this.clone();
|
|
}
|
|
}, m3.endOf = function(t2) {
|
|
return this.startOf(t2, false);
|
|
}, m3.$set = function(t2, e2) {
|
|
var n2, o3 = b2.p(t2), f3 = "set" + (this.$u ? "UTC" : ""), l3 = (n2 = {}, n2[a2] = f3 + "Date", n2[d2] = f3 + "Date", n2[c2] = f3 + "Month", n2[h3] = f3 + "FullYear", n2[u2] = f3 + "Hours", n2[s2] = f3 + "Minutes", n2[i] = f3 + "Seconds", n2[r] = f3 + "Milliseconds", n2)[o3], $2 = o3 === a2 ? this.$D + (e2 - this.$W) : e2;
|
|
if (o3 === c2 || o3 === h3) {
|
|
var y2 = this.clone().set(d2, 1);
|
|
y2.$d[l3]($2), y2.init(), this.$d = y2.set(d2, Math.min(this.$D, y2.daysInMonth())).$d;
|
|
} else
|
|
l3 && this.$d[l3]($2);
|
|
return this.init(), this;
|
|
}, m3.set = function(t2, e2) {
|
|
return this.clone().$set(t2, e2);
|
|
}, m3.get = function(t2) {
|
|
return this[b2.p(t2)]();
|
|
}, m3.add = function(r2, f3) {
|
|
var d3, l3 = this;
|
|
r2 = Number(r2);
|
|
var $2 = b2.p(f3), y2 = function(t2) {
|
|
var e2 = O2(l3);
|
|
return b2.w(e2.date(e2.date() + Math.round(t2 * r2)), l3);
|
|
};
|
|
if ($2 === c2)
|
|
return this.set(c2, this.$M + r2);
|
|
if ($2 === h3)
|
|
return this.set(h3, this.$y + r2);
|
|
if ($2 === a2)
|
|
return y2(1);
|
|
if ($2 === o2)
|
|
return y2(7);
|
|
var M4 = (d3 = {}, d3[s2] = e, d3[u2] = n, d3[i] = t, d3)[$2] || 1, m4 = this.$d.getTime() + r2 * M4;
|
|
return b2.w(m4, this);
|
|
}, m3.subtract = function(t2, e2) {
|
|
return this.add(-1 * t2, e2);
|
|
}, m3.format = function(t2) {
|
|
var e2 = this, n2 = this.$locale();
|
|
if (!this.isValid())
|
|
return n2.invalidDate || l2;
|
|
var r2 = t2 || "YYYY-MM-DDTHH:mm:ssZ", i2 = b2.z(this), s3 = this.$H, u3 = this.$m, a3 = this.$M, o3 = n2.weekdays, c3 = n2.months, f3 = n2.meridiem, h4 = function(t3, n3, i3, s4) {
|
|
return t3 && (t3[n3] || t3(e2, r2)) || i3[n3].slice(0, s4);
|
|
}, d3 = function(t3) {
|
|
return b2.s(s3 % 12 || 12, t3, "0");
|
|
}, $2 = f3 || function(t3, e3, n3) {
|
|
var r3 = t3 < 12 ? "AM" : "PM";
|
|
return n3 ? r3.toLowerCase() : r3;
|
|
};
|
|
return r2.replace(y, function(t3, r3) {
|
|
return r3 || function(t4) {
|
|
switch (t4) {
|
|
case "YY":
|
|
return String(e2.$y).slice(-2);
|
|
case "YYYY":
|
|
return b2.s(e2.$y, 4, "0");
|
|
case "M":
|
|
return a3 + 1;
|
|
case "MM":
|
|
return b2.s(a3 + 1, 2, "0");
|
|
case "MMM":
|
|
return h4(n2.monthsShort, a3, c3, 3);
|
|
case "MMMM":
|
|
return h4(c3, a3);
|
|
case "D":
|
|
return e2.$D;
|
|
case "DD":
|
|
return b2.s(e2.$D, 2, "0");
|
|
case "d":
|
|
return String(e2.$W);
|
|
case "dd":
|
|
return h4(n2.weekdaysMin, e2.$W, o3, 2);
|
|
case "ddd":
|
|
return h4(n2.weekdaysShort, e2.$W, o3, 3);
|
|
case "dddd":
|
|
return o3[e2.$W];
|
|
case "H":
|
|
return String(s3);
|
|
case "HH":
|
|
return b2.s(s3, 2, "0");
|
|
case "h":
|
|
return d3(1);
|
|
case "hh":
|
|
return d3(2);
|
|
case "a":
|
|
return $2(s3, u3, true);
|
|
case "A":
|
|
return $2(s3, u3, false);
|
|
case "m":
|
|
return String(u3);
|
|
case "mm":
|
|
return b2.s(u3, 2, "0");
|
|
case "s":
|
|
return String(e2.$s);
|
|
case "ss":
|
|
return b2.s(e2.$s, 2, "0");
|
|
case "SSS":
|
|
return b2.s(e2.$ms, 3, "0");
|
|
case "Z":
|
|
return i2;
|
|
}
|
|
return null;
|
|
}(t3) || i2.replace(":", "");
|
|
});
|
|
}, m3.utcOffset = function() {
|
|
return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
|
|
}, m3.diff = function(r2, d3, l3) {
|
|
var $2, y2 = this, M4 = b2.p(d3), m4 = O2(r2), v3 = (m4.utcOffset() - this.utcOffset()) * e, g2 = this - m4, D3 = function() {
|
|
return b2.m(y2, m4);
|
|
};
|
|
switch (M4) {
|
|
case h3:
|
|
$2 = D3() / 12;
|
|
break;
|
|
case c2:
|
|
$2 = D3();
|
|
break;
|
|
case f2:
|
|
$2 = D3() / 3;
|
|
break;
|
|
case o2:
|
|
$2 = (g2 - v3) / 6048e5;
|
|
break;
|
|
case a2:
|
|
$2 = (g2 - v3) / 864e5;
|
|
break;
|
|
case u2:
|
|
$2 = g2 / n;
|
|
break;
|
|
case s2:
|
|
$2 = g2 / e;
|
|
break;
|
|
case i:
|
|
$2 = g2 / t;
|
|
break;
|
|
default:
|
|
$2 = g2;
|
|
}
|
|
return l3 ? $2 : b2.a($2);
|
|
}, m3.daysInMonth = function() {
|
|
return this.endOf(c2).$D;
|
|
}, m3.$locale = function() {
|
|
return D2[this.$L];
|
|
}, m3.locale = function(t2, e2) {
|
|
if (!t2)
|
|
return this.$L;
|
|
var n2 = this.clone(), r2 = w2(t2, e2, true);
|
|
return r2 && (n2.$L = r2), n2;
|
|
}, m3.clone = function() {
|
|
return b2.w(this.$d, this);
|
|
}, m3.toDate = function() {
|
|
return new Date(this.valueOf());
|
|
}, m3.toJSON = function() {
|
|
return this.isValid() ? this.toISOString() : null;
|
|
}, m3.toISOString = function() {
|
|
return this.$d.toISOString();
|
|
}, m3.toString = function() {
|
|
return this.$d.toUTCString();
|
|
}, M3;
|
|
}(), k = _2.prototype;
|
|
return O2.prototype = k, [["$ms", r], ["$s", i], ["$m", s2], ["$H", u2], ["$W", a2], ["$M", c2], ["$y", h3], ["$D", d2]].forEach(function(t2) {
|
|
k[t2[1]] = function(e2) {
|
|
return this.$g(e2, t2[0], t2[1]);
|
|
};
|
|
}), O2.extend = function(t2, e2) {
|
|
return t2.$i || (t2(e2, _2, O2), t2.$i = true), O2;
|
|
}, O2.locale = w2, O2.isDayjs = S2, O2.unix = function(t2) {
|
|
return O2(1e3 * t2);
|
|
}, O2.en = D2[g], O2.Ls = D2, O2.p = {}, O2;
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/dayjs/plugin/localeData.js
|
|
var require_localeData = __commonJS({
|
|
"node_modules/dayjs/plugin/localeData.js"(exports2, module2) {
|
|
!function(n, e) {
|
|
typeof exports2 == "object" && typeof module2 != "undefined" ? module2.exports = e() : typeof define == "function" && define.amd ? define(e) : (n = typeof globalThis != "undefined" ? globalThis : n || self).dayjs_plugin_localeData = e();
|
|
}(exports2, function() {
|
|
"use strict";
|
|
return function(n, e, t) {
|
|
var r = e.prototype, o2 = function(n2) {
|
|
return n2 && (n2.indexOf ? n2 : n2.s);
|
|
}, u2 = function(n2, e2, t2, r2, u3) {
|
|
var i2 = n2.name ? n2 : n2.$locale(), a3 = o2(i2[e2]), s3 = o2(i2[t2]), f2 = a3 || s3.map(function(n3) {
|
|
return n3.slice(0, r2);
|
|
});
|
|
if (!u3)
|
|
return f2;
|
|
var d2 = i2.weekStart;
|
|
return f2.map(function(n3, e3) {
|
|
return f2[(e3 + (d2 || 0)) % 7];
|
|
});
|
|
}, i = function() {
|
|
return t.Ls[t.locale()];
|
|
}, a2 = function(n2, e2) {
|
|
return n2.formats[e2] || function(n3) {
|
|
return n3.replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, function(n4, e3, t2) {
|
|
return e3 || t2.slice(1);
|
|
});
|
|
}(n2.formats[e2.toUpperCase()]);
|
|
}, s2 = function() {
|
|
var n2 = this;
|
|
return { months: function(e2) {
|
|
return e2 ? e2.format("MMMM") : u2(n2, "months");
|
|
}, monthsShort: function(e2) {
|
|
return e2 ? e2.format("MMM") : u2(n2, "monthsShort", "months", 3);
|
|
}, firstDayOfWeek: function() {
|
|
return n2.$locale().weekStart || 0;
|
|
}, weekdays: function(e2) {
|
|
return e2 ? e2.format("dddd") : u2(n2, "weekdays");
|
|
}, weekdaysMin: function(e2) {
|
|
return e2 ? e2.format("dd") : u2(n2, "weekdaysMin", "weekdays", 2);
|
|
}, weekdaysShort: function(e2) {
|
|
return e2 ? e2.format("ddd") : u2(n2, "weekdaysShort", "weekdays", 3);
|
|
}, longDateFormat: function(e2) {
|
|
return a2(n2.$locale(), e2);
|
|
}, meridiem: this.$locale().meridiem, ordinal: this.$locale().ordinal };
|
|
};
|
|
r.localeData = function() {
|
|
return s2.bind(this)();
|
|
}, t.localeData = function() {
|
|
var n2 = i();
|
|
return { firstDayOfWeek: function() {
|
|
return n2.weekStart || 0;
|
|
}, weekdays: function() {
|
|
return t.weekdays();
|
|
}, weekdaysShort: function() {
|
|
return t.weekdaysShort();
|
|
}, weekdaysMin: function() {
|
|
return t.weekdaysMin();
|
|
}, months: function() {
|
|
return t.months();
|
|
}, monthsShort: function() {
|
|
return t.monthsShort();
|
|
}, longDateFormat: function(e2) {
|
|
return a2(n2, e2);
|
|
}, meridiem: n2.meridiem, ordinal: n2.ordinal };
|
|
}, t.months = function() {
|
|
return u2(i(), "months");
|
|
}, t.monthsShort = function() {
|
|
return u2(i(), "monthsShort", "months", 3);
|
|
}, t.weekdays = function(n2) {
|
|
return u2(i(), "weekdays", null, null, n2);
|
|
}, t.weekdaysShort = function(n2) {
|
|
return u2(i(), "weekdaysShort", "weekdays", 3, n2);
|
|
}, t.weekdaysMin = function(n2) {
|
|
return u2(i(), "weekdaysMin", "weekdays", 2, n2);
|
|
};
|
|
};
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/dayjs/plugin/customParseFormat.js
|
|
var require_customParseFormat = __commonJS({
|
|
"node_modules/dayjs/plugin/customParseFormat.js"(exports2, module2) {
|
|
!function(e, t) {
|
|
typeof exports2 == "object" && typeof module2 != "undefined" ? module2.exports = t() : typeof define == "function" && define.amd ? define(t) : (e = typeof globalThis != "undefined" ? globalThis : e || self).dayjs_plugin_customParseFormat = t();
|
|
}(exports2, function() {
|
|
"use strict";
|
|
var e = { LTS: "h:mm:ss A", LT: "h:mm A", L: "MM/DD/YYYY", LL: "MMMM D, YYYY", LLL: "MMMM D, YYYY h:mm A", LLLL: "dddd, MMMM D, YYYY h:mm A" }, t = /(\[[^[]*\])|([-_:/.,()\s]+)|(A|a|Q|YYYY|YY?|ww?|MM?M?M?|Do|DD?|hh?|HH?|mm?|ss?|S{1,3}|z|ZZ?)/g, n = /\d/, r = /\d\d/, i = /\d\d?/, o2 = /\d*[^-_:/,()\s\d]+/, s2 = {}, a2 = function(e2) {
|
|
return (e2 = +e2) + (e2 > 68 ? 1900 : 2e3);
|
|
};
|
|
var f2 = function(e2) {
|
|
return function(t2) {
|
|
this[e2] = +t2;
|
|
};
|
|
}, h3 = [/[+-]\d\d:?(\d\d)?|Z/, function(e2) {
|
|
(this.zone || (this.zone = {})).offset = function(e3) {
|
|
if (!e3)
|
|
return 0;
|
|
if (e3 === "Z")
|
|
return 0;
|
|
var t2 = e3.match(/([+-]|\d\d)/g), n2 = 60 * t2[1] + (+t2[2] || 0);
|
|
return n2 === 0 ? 0 : t2[0] === "+" ? -n2 : n2;
|
|
}(e2);
|
|
}], u2 = function(e2) {
|
|
var t2 = s2[e2];
|
|
return t2 && (t2.indexOf ? t2 : t2.s.concat(t2.f));
|
|
}, d2 = function(e2, t2) {
|
|
var n2, r2 = s2.meridiem;
|
|
if (r2) {
|
|
for (var i2 = 1; i2 <= 24; i2 += 1)
|
|
if (e2.indexOf(r2(i2, 0, t2)) > -1) {
|
|
n2 = i2 > 12;
|
|
break;
|
|
}
|
|
} else
|
|
n2 = e2 === (t2 ? "pm" : "PM");
|
|
return n2;
|
|
}, c2 = { A: [o2, function(e2) {
|
|
this.afternoon = d2(e2, false);
|
|
}], a: [o2, function(e2) {
|
|
this.afternoon = d2(e2, true);
|
|
}], Q: [n, function(e2) {
|
|
this.month = 3 * (e2 - 1) + 1;
|
|
}], S: [n, function(e2) {
|
|
this.milliseconds = 100 * +e2;
|
|
}], SS: [r, function(e2) {
|
|
this.milliseconds = 10 * +e2;
|
|
}], SSS: [/\d{3}/, function(e2) {
|
|
this.milliseconds = +e2;
|
|
}], s: [i, f2("seconds")], ss: [i, f2("seconds")], m: [i, f2("minutes")], mm: [i, f2("minutes")], H: [i, f2("hours")], h: [i, f2("hours")], HH: [i, f2("hours")], hh: [i, f2("hours")], D: [i, f2("day")], DD: [r, f2("day")], Do: [o2, function(e2) {
|
|
var t2 = s2.ordinal, n2 = e2.match(/\d+/);
|
|
if (this.day = n2[0], t2)
|
|
for (var r2 = 1; r2 <= 31; r2 += 1)
|
|
t2(r2).replace(/\[|\]/g, "") === e2 && (this.day = r2);
|
|
}], w: [i, f2("week")], ww: [r, f2("week")], M: [i, f2("month")], MM: [r, f2("month")], MMM: [o2, function(e2) {
|
|
var t2 = u2("months"), n2 = (u2("monthsShort") || t2.map(function(e3) {
|
|
return e3.slice(0, 3);
|
|
})).indexOf(e2) + 1;
|
|
if (n2 < 1)
|
|
throw new Error();
|
|
this.month = n2 % 12 || n2;
|
|
}], MMMM: [o2, function(e2) {
|
|
var t2 = u2("months").indexOf(e2) + 1;
|
|
if (t2 < 1)
|
|
throw new Error();
|
|
this.month = t2 % 12 || t2;
|
|
}], Y: [/[+-]?\d+/, f2("year")], YY: [r, function(e2) {
|
|
this.year = a2(e2);
|
|
}], YYYY: [/\d{4}/, f2("year")], Z: h3, ZZ: h3 };
|
|
function l2(n2) {
|
|
var r2, i2;
|
|
r2 = n2, i2 = s2 && s2.formats;
|
|
for (var o3 = (n2 = r2.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g, function(t2, n3, r3) {
|
|
var o4 = r3 && r3.toUpperCase();
|
|
return n3 || i2[r3] || e[r3] || i2[o4].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, function(e2, t3, n4) {
|
|
return t3 || n4.slice(1);
|
|
});
|
|
})).match(t), a3 = o3.length, f3 = 0; f3 < a3; f3 += 1) {
|
|
var h4 = o3[f3], u3 = c2[h4], d3 = u3 && u3[0], l3 = u3 && u3[1];
|
|
o3[f3] = l3 ? { regex: d3, parser: l3 } : h4.replace(/^\[|\]$/g, "");
|
|
}
|
|
return function(e2) {
|
|
for (var t2 = {}, n3 = 0, r3 = 0; n3 < a3; n3 += 1) {
|
|
var i3 = o3[n3];
|
|
if (typeof i3 == "string")
|
|
r3 += i3.length;
|
|
else {
|
|
var s3 = i3.regex, f4 = i3.parser, h5 = e2.slice(r3), u4 = s3.exec(h5)[0];
|
|
f4.call(t2, u4), e2 = e2.replace(u4, "");
|
|
}
|
|
}
|
|
return function(e3) {
|
|
var t3 = e3.afternoon;
|
|
if (t3 !== void 0) {
|
|
var n4 = e3.hours;
|
|
t3 ? n4 < 12 && (e3.hours += 12) : n4 === 12 && (e3.hours = 0), delete e3.afternoon;
|
|
}
|
|
}(t2), t2;
|
|
};
|
|
}
|
|
return function(e2, t2, n2) {
|
|
n2.p.customParseFormat = true, e2 && e2.parseTwoDigitYear && (a2 = e2.parseTwoDigitYear);
|
|
var r2 = t2.prototype, i2 = r2.parse;
|
|
r2.parse = function(e3) {
|
|
var t3 = e3.date, r3 = e3.utc, o3 = e3.args;
|
|
this.$u = r3;
|
|
var a3 = o3[1];
|
|
if (typeof a3 == "string") {
|
|
var f3 = o3[2] === true, h4 = o3[3] === true, u3 = f3 || h4, d3 = o3[2];
|
|
h4 && (d3 = o3[2]), s2 = this.$locale(), !f3 && d3 && (s2 = n2.Ls[d3]), this.$d = function(e4, t4, n3, r4) {
|
|
try {
|
|
if (["x", "X"].indexOf(t4) > -1)
|
|
return new Date((t4 === "X" ? 1e3 : 1) * e4);
|
|
var i3 = l2(t4)(e4), o4 = i3.year, s3 = i3.month, a4 = i3.day, f4 = i3.hours, h5 = i3.minutes, u4 = i3.seconds, d4 = i3.milliseconds, c4 = i3.zone, m3 = i3.week, M3 = new Date(), Y2 = a4 || (o4 || s3 ? 1 : M3.getDate()), p2 = o4 || M3.getFullYear(), v2 = 0;
|
|
o4 && !s3 || (v2 = s3 > 0 ? s3 - 1 : M3.getMonth());
|
|
var D2, w2 = f4 || 0, g = h5 || 0, y = u4 || 0, L = d4 || 0;
|
|
return c4 ? new Date(Date.UTC(p2, v2, Y2, w2, g, y, L + 60 * c4.offset * 1e3)) : n3 ? new Date(Date.UTC(p2, v2, Y2, w2, g, y, L)) : (D2 = new Date(p2, v2, Y2, w2, g, y, L), m3 && (D2 = r4(D2).week(m3).toDate()), D2);
|
|
} catch (e5) {
|
|
return new Date("");
|
|
}
|
|
}(t3, a3, r3, n2), this.init(), d3 && d3 !== true && (this.$L = this.locale(d3).$L), u3 && t3 != this.format(a3) && (this.$d = new Date("")), s2 = {};
|
|
} else if (a3 instanceof Array)
|
|
for (var c3 = a3.length, m2 = 1; m2 <= c3; m2 += 1) {
|
|
o3[1] = a3[m2 - 1];
|
|
var M2 = n2.apply(this, o3);
|
|
if (M2.isValid()) {
|
|
this.$d = M2.$d, this.$L = M2.$L, this.init();
|
|
break;
|
|
}
|
|
m2 === c3 && (this.$d = new Date(""));
|
|
}
|
|
else
|
|
i2.call(this, e3);
|
|
};
|
|
};
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/dayjs/plugin/advancedFormat.js
|
|
var require_advancedFormat = __commonJS({
|
|
"node_modules/dayjs/plugin/advancedFormat.js"(exports2, module2) {
|
|
!function(e, t) {
|
|
typeof exports2 == "object" && typeof module2 != "undefined" ? module2.exports = t() : typeof define == "function" && define.amd ? define(t) : (e = typeof globalThis != "undefined" ? globalThis : e || self).dayjs_plugin_advancedFormat = t();
|
|
}(exports2, function() {
|
|
"use strict";
|
|
return function(e, t) {
|
|
var r = t.prototype, n = r.format;
|
|
r.format = function(e2) {
|
|
var t2 = this, r2 = this.$locale();
|
|
if (!this.isValid())
|
|
return n.bind(this)(e2);
|
|
var s2 = this.$utils(), a2 = (e2 || "YYYY-MM-DDTHH:mm:ssZ").replace(/\[([^\]]+)]|Q|wo|ww|w|WW|W|zzz|z|gggg|GGGG|Do|X|x|k{1,2}|S/g, function(e3) {
|
|
switch (e3) {
|
|
case "Q":
|
|
return Math.ceil((t2.$M + 1) / 3);
|
|
case "Do":
|
|
return r2.ordinal(t2.$D);
|
|
case "gggg":
|
|
return t2.weekYear();
|
|
case "GGGG":
|
|
return t2.isoWeekYear();
|
|
case "wo":
|
|
return r2.ordinal(t2.week(), "W");
|
|
case "w":
|
|
case "ww":
|
|
return s2.s(t2.week(), e3 === "w" ? 1 : 2, "0");
|
|
case "W":
|
|
case "WW":
|
|
return s2.s(t2.isoWeek(), e3 === "W" ? 1 : 2, "0");
|
|
case "k":
|
|
case "kk":
|
|
return s2.s(String(t2.$H === 0 ? 24 : t2.$H), e3 === "k" ? 1 : 2, "0");
|
|
case "X":
|
|
return Math.floor(t2.$d.getTime() / 1e3);
|
|
case "x":
|
|
return t2.$d.getTime();
|
|
case "z":
|
|
return "[" + t2.offsetName() + "]";
|
|
case "zzz":
|
|
return "[" + t2.offsetName("long") + "]";
|
|
default:
|
|
return e3;
|
|
}
|
|
});
|
|
return n.bind(this)(a2);
|
|
};
|
|
};
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/dayjs/plugin/weekOfYear.js
|
|
var require_weekOfYear = __commonJS({
|
|
"node_modules/dayjs/plugin/weekOfYear.js"(exports2, module2) {
|
|
!function(e, t) {
|
|
typeof exports2 == "object" && typeof module2 != "undefined" ? module2.exports = t() : typeof define == "function" && define.amd ? define(t) : (e = typeof globalThis != "undefined" ? globalThis : e || self).dayjs_plugin_weekOfYear = t();
|
|
}(exports2, function() {
|
|
"use strict";
|
|
var e = "week", t = "year";
|
|
return function(i, n, r) {
|
|
var f2 = n.prototype;
|
|
f2.week = function(i2) {
|
|
if (i2 === void 0 && (i2 = null), i2 !== null)
|
|
return this.add(7 * (i2 - this.week()), "day");
|
|
var n2 = this.$locale().yearStart || 1;
|
|
if (this.month() === 11 && this.date() > 25) {
|
|
var f3 = r(this).startOf(t).add(1, t).date(n2), s2 = r(this).endOf(e);
|
|
if (f3.isBefore(s2))
|
|
return 1;
|
|
}
|
|
var a2 = r(this).startOf(t).date(n2).startOf(e).subtract(1, "millisecond"), o2 = this.diff(a2, e, true);
|
|
return o2 < 0 ? r(this).startOf("week").week() : Math.ceil(o2);
|
|
}, f2.weeks = function(e2) {
|
|
return e2 === void 0 && (e2 = null), this.week(e2);
|
|
};
|
|
};
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/dayjs/plugin/weekYear.js
|
|
var require_weekYear = __commonJS({
|
|
"node_modules/dayjs/plugin/weekYear.js"(exports2, module2) {
|
|
!function(e, t) {
|
|
typeof exports2 == "object" && typeof module2 != "undefined" ? module2.exports = t() : typeof define == "function" && define.amd ? define(t) : (e = typeof globalThis != "undefined" ? globalThis : e || self).dayjs_plugin_weekYear = t();
|
|
}(exports2, function() {
|
|
"use strict";
|
|
return function(e, t) {
|
|
t.prototype.weekYear = function() {
|
|
var e2 = this.month(), t2 = this.week(), n = this.year();
|
|
return t2 === 1 && e2 === 11 ? n + 1 : e2 === 0 && t2 >= 52 ? n - 1 : n;
|
|
};
|
|
};
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/dayjs/plugin/dayOfYear.js
|
|
var require_dayOfYear = __commonJS({
|
|
"node_modules/dayjs/plugin/dayOfYear.js"(exports2, module2) {
|
|
!function(e, t) {
|
|
typeof exports2 == "object" && typeof module2 != "undefined" ? module2.exports = t() : typeof define == "function" && define.amd ? define(t) : (e = typeof globalThis != "undefined" ? globalThis : e || self).dayjs_plugin_dayOfYear = t();
|
|
}(exports2, function() {
|
|
"use strict";
|
|
return function(e, t, n) {
|
|
t.prototype.dayOfYear = function(e2) {
|
|
var t2 = Math.round((n(this).startOf("day") - n(this).startOf("year")) / 864e5) + 1;
|
|
return e2 == null ? t2 : this.add(e2 - t2, "day");
|
|
};
|
|
};
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/dayjs/plugin/isSameOrAfter.js
|
|
var require_isSameOrAfter = __commonJS({
|
|
"node_modules/dayjs/plugin/isSameOrAfter.js"(exports2, module2) {
|
|
!function(e, t) {
|
|
typeof exports2 == "object" && typeof module2 != "undefined" ? module2.exports = t() : typeof define == "function" && define.amd ? define(t) : (e = typeof globalThis != "undefined" ? globalThis : e || self).dayjs_plugin_isSameOrAfter = t();
|
|
}(exports2, function() {
|
|
"use strict";
|
|
return function(e, t) {
|
|
t.prototype.isSameOrAfter = function(e2, t2) {
|
|
return this.isSame(e2, t2) || this.isAfter(e2, t2);
|
|
};
|
|
};
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/dayjs/plugin/isSameOrBefore.js
|
|
var require_isSameOrBefore = __commonJS({
|
|
"node_modules/dayjs/plugin/isSameOrBefore.js"(exports2, module2) {
|
|
!function(e, i) {
|
|
typeof exports2 == "object" && typeof module2 != "undefined" ? module2.exports = i() : typeof define == "function" && define.amd ? define(i) : (e = typeof globalThis != "undefined" ? globalThis : e || self).dayjs_plugin_isSameOrBefore = i();
|
|
}(exports2, function() {
|
|
"use strict";
|
|
return function(e, i) {
|
|
i.prototype.isSameOrBefore = function(e2, i2) {
|
|
return this.isSame(e2, i2) || this.isBefore(e2, i2);
|
|
};
|
|
};
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/constants/key.mjs
|
|
var INSTALLED_KEY = Symbol("INSTALLED_KEY");
|
|
|
|
// node_modules/element-plus/es/components/config-provider/src/constants.mjs
|
|
var configProviderContextKey = Symbol();
|
|
|
|
// node_modules/element-plus/es/hooks/use-namespace/index.mjs
|
|
var defaultNamespace = "el";
|
|
var statePrefix = "is-";
|
|
var _bem = (namespace, block, blockSuffix, element, modifier) => {
|
|
let cls = `${namespace}-${block}`;
|
|
if (blockSuffix) {
|
|
cls += `-${blockSuffix}`;
|
|
}
|
|
if (element) {
|
|
cls += `__${element}`;
|
|
}
|
|
if (modifier) {
|
|
cls += `--${modifier}`;
|
|
}
|
|
return cls;
|
|
};
|
|
var namespaceContextKey = Symbol("namespaceContextKey");
|
|
var useGetDerivedNamespace = (namespaceOverrides) => {
|
|
const derivedNamespace = namespaceOverrides || (getCurrentInstance() ? inject(namespaceContextKey, ref(defaultNamespace)) : ref(defaultNamespace));
|
|
const namespace = computed(() => {
|
|
return unref(derivedNamespace) || defaultNamespace;
|
|
});
|
|
return namespace;
|
|
};
|
|
var useNamespace = (block, namespaceOverrides) => {
|
|
const namespace = useGetDerivedNamespace(namespaceOverrides);
|
|
const b2 = (blockSuffix = "") => _bem(namespace.value, block, blockSuffix, "", "");
|
|
const e = (element) => element ? _bem(namespace.value, block, "", element, "") : "";
|
|
const m2 = (modifier) => modifier ? _bem(namespace.value, block, "", "", modifier) : "";
|
|
const be2 = (blockSuffix, element) => blockSuffix && element ? _bem(namespace.value, block, blockSuffix, element, "") : "";
|
|
const em = (element, modifier) => element && modifier ? _bem(namespace.value, block, "", element, modifier) : "";
|
|
const bm = (blockSuffix, modifier) => blockSuffix && modifier ? _bem(namespace.value, block, blockSuffix, "", modifier) : "";
|
|
const bem = (blockSuffix, element, modifier) => blockSuffix && element && modifier ? _bem(namespace.value, block, blockSuffix, element, modifier) : "";
|
|
const is = (name, ...args) => {
|
|
const state = args.length >= 1 ? args[0] : true;
|
|
return name && state ? `${statePrefix}${name}` : "";
|
|
};
|
|
const cssVar = (object4) => {
|
|
const styles = {};
|
|
for (const key in object4) {
|
|
if (object4[key]) {
|
|
styles[`--${namespace.value}-${key}`] = object4[key];
|
|
}
|
|
}
|
|
return styles;
|
|
};
|
|
const cssVarBlock = (object4) => {
|
|
const styles = {};
|
|
for (const key in object4) {
|
|
if (object4[key]) {
|
|
styles[`--${namespace.value}-${block}-${key}`] = object4[key];
|
|
}
|
|
}
|
|
return styles;
|
|
};
|
|
const cssVarName = (name) => `--${namespace.value}-${name}`;
|
|
const cssVarBlockName = (name) => `--${namespace.value}-${block}-${name}`;
|
|
return {
|
|
namespace,
|
|
b: b2,
|
|
e,
|
|
m: m2,
|
|
be: be2,
|
|
em,
|
|
bm,
|
|
bem,
|
|
is,
|
|
cssVar,
|
|
cssVarName,
|
|
cssVarBlock,
|
|
cssVarBlockName
|
|
};
|
|
};
|
|
|
|
// node_modules/lodash-es/_freeGlobal.js
|
|
var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
|
|
var freeGlobal_default = freeGlobal;
|
|
|
|
// node_modules/lodash-es/_root.js
|
|
var freeSelf = typeof self == "object" && self && self.Object === Object && self;
|
|
var root = freeGlobal_default || freeSelf || Function("return this")();
|
|
var root_default = root;
|
|
|
|
// node_modules/lodash-es/_Symbol.js
|
|
var Symbol2 = root_default.Symbol;
|
|
var Symbol_default = Symbol2;
|
|
|
|
// node_modules/lodash-es/_getRawTag.js
|
|
var objectProto = Object.prototype;
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
var nativeObjectToString = objectProto.toString;
|
|
var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
|
|
function getRawTag(value) {
|
|
var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
|
|
try {
|
|
value[symToStringTag] = void 0;
|
|
var unmasked = true;
|
|
} catch (e) {
|
|
}
|
|
var result2 = nativeObjectToString.call(value);
|
|
if (unmasked) {
|
|
if (isOwn) {
|
|
value[symToStringTag] = tag;
|
|
} else {
|
|
delete value[symToStringTag];
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var getRawTag_default = getRawTag;
|
|
|
|
// node_modules/lodash-es/_objectToString.js
|
|
var objectProto2 = Object.prototype;
|
|
var nativeObjectToString2 = objectProto2.toString;
|
|
function objectToString(value) {
|
|
return nativeObjectToString2.call(value);
|
|
}
|
|
var objectToString_default = objectToString;
|
|
|
|
// node_modules/lodash-es/_baseGetTag.js
|
|
var nullTag = "[object Null]";
|
|
var undefinedTag = "[object Undefined]";
|
|
var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
|
|
function baseGetTag(value) {
|
|
if (value == null) {
|
|
return value === void 0 ? undefinedTag : nullTag;
|
|
}
|
|
return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
|
|
}
|
|
var baseGetTag_default = baseGetTag;
|
|
|
|
// node_modules/lodash-es/isObjectLike.js
|
|
function isObjectLike(value) {
|
|
return value != null && typeof value == "object";
|
|
}
|
|
var isObjectLike_default = isObjectLike;
|
|
|
|
// node_modules/lodash-es/isSymbol.js
|
|
var symbolTag = "[object Symbol]";
|
|
function isSymbol(value) {
|
|
return typeof value == "symbol" || isObjectLike_default(value) && baseGetTag_default(value) == symbolTag;
|
|
}
|
|
var isSymbol_default = isSymbol;
|
|
|
|
// node_modules/lodash-es/_baseToNumber.js
|
|
var NAN = 0 / 0;
|
|
function baseToNumber(value) {
|
|
if (typeof value == "number") {
|
|
return value;
|
|
}
|
|
if (isSymbol_default(value)) {
|
|
return NAN;
|
|
}
|
|
return +value;
|
|
}
|
|
var baseToNumber_default = baseToNumber;
|
|
|
|
// node_modules/lodash-es/_arrayMap.js
|
|
function arrayMap(array4, iteratee2) {
|
|
var index = -1, length = array4 == null ? 0 : array4.length, result2 = Array(length);
|
|
while (++index < length) {
|
|
result2[index] = iteratee2(array4[index], index, array4);
|
|
}
|
|
return result2;
|
|
}
|
|
var arrayMap_default = arrayMap;
|
|
|
|
// node_modules/lodash-es/isArray.js
|
|
var isArray2 = Array.isArray;
|
|
var isArray_default = isArray2;
|
|
|
|
// node_modules/lodash-es/_baseToString.js
|
|
var INFINITY = 1 / 0;
|
|
var symbolProto = Symbol_default ? Symbol_default.prototype : void 0;
|
|
var symbolToString = symbolProto ? symbolProto.toString : void 0;
|
|
function baseToString(value) {
|
|
if (typeof value == "string") {
|
|
return value;
|
|
}
|
|
if (isArray_default(value)) {
|
|
return arrayMap_default(value, baseToString) + "";
|
|
}
|
|
if (isSymbol_default(value)) {
|
|
return symbolToString ? symbolToString.call(value) : "";
|
|
}
|
|
var result2 = value + "";
|
|
return result2 == "0" && 1 / value == -INFINITY ? "-0" : result2;
|
|
}
|
|
var baseToString_default = baseToString;
|
|
|
|
// node_modules/lodash-es/_createMathOperation.js
|
|
function createMathOperation(operator, defaultValue) {
|
|
return function(value, other) {
|
|
var result2;
|
|
if (value === void 0 && other === void 0) {
|
|
return defaultValue;
|
|
}
|
|
if (value !== void 0) {
|
|
result2 = value;
|
|
}
|
|
if (other !== void 0) {
|
|
if (result2 === void 0) {
|
|
return other;
|
|
}
|
|
if (typeof value == "string" || typeof other == "string") {
|
|
value = baseToString_default(value);
|
|
other = baseToString_default(other);
|
|
} else {
|
|
value = baseToNumber_default(value);
|
|
other = baseToNumber_default(other);
|
|
}
|
|
result2 = operator(value, other);
|
|
}
|
|
return result2;
|
|
};
|
|
}
|
|
var createMathOperation_default = createMathOperation;
|
|
|
|
// node_modules/lodash-es/add.js
|
|
var add = createMathOperation_default(function(augend, addend) {
|
|
return augend + addend;
|
|
}, 0);
|
|
var add_default = add;
|
|
|
|
// node_modules/lodash-es/_trimmedEndIndex.js
|
|
var reWhitespace = /\s/;
|
|
function trimmedEndIndex(string3) {
|
|
var index = string3.length;
|
|
while (index-- && reWhitespace.test(string3.charAt(index))) {
|
|
}
|
|
return index;
|
|
}
|
|
var trimmedEndIndex_default = trimmedEndIndex;
|
|
|
|
// node_modules/lodash-es/_baseTrim.js
|
|
var reTrimStart = /^\s+/;
|
|
function baseTrim(string3) {
|
|
return string3 ? string3.slice(0, trimmedEndIndex_default(string3) + 1).replace(reTrimStart, "") : string3;
|
|
}
|
|
var baseTrim_default = baseTrim;
|
|
|
|
// node_modules/lodash-es/isObject.js
|
|
function isObject2(value) {
|
|
var type4 = typeof value;
|
|
return value != null && (type4 == "object" || type4 == "function");
|
|
}
|
|
var isObject_default = isObject2;
|
|
|
|
// node_modules/lodash-es/toNumber.js
|
|
var NAN2 = 0 / 0;
|
|
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
|
|
var reIsBinary = /^0b[01]+$/i;
|
|
var reIsOctal = /^0o[0-7]+$/i;
|
|
var freeParseInt = parseInt;
|
|
function toNumber(value) {
|
|
if (typeof value == "number") {
|
|
return value;
|
|
}
|
|
if (isSymbol_default(value)) {
|
|
return NAN2;
|
|
}
|
|
if (isObject_default(value)) {
|
|
var other = typeof value.valueOf == "function" ? value.valueOf() : value;
|
|
value = isObject_default(other) ? other + "" : other;
|
|
}
|
|
if (typeof value != "string") {
|
|
return value === 0 ? value : +value;
|
|
}
|
|
value = baseTrim_default(value);
|
|
var isBinary = reIsBinary.test(value);
|
|
return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN2 : +value;
|
|
}
|
|
var toNumber_default = toNumber;
|
|
|
|
// node_modules/lodash-es/toFinite.js
|
|
var INFINITY2 = 1 / 0;
|
|
var MAX_INTEGER = 17976931348623157e292;
|
|
function toFinite(value) {
|
|
if (!value) {
|
|
return value === 0 ? value : 0;
|
|
}
|
|
value = toNumber_default(value);
|
|
if (value === INFINITY2 || value === -INFINITY2) {
|
|
var sign = value < 0 ? -1 : 1;
|
|
return sign * MAX_INTEGER;
|
|
}
|
|
return value === value ? value : 0;
|
|
}
|
|
var toFinite_default = toFinite;
|
|
|
|
// node_modules/lodash-es/toInteger.js
|
|
function toInteger(value) {
|
|
var result2 = toFinite_default(value), remainder = result2 % 1;
|
|
return result2 === result2 ? remainder ? result2 - remainder : result2 : 0;
|
|
}
|
|
var toInteger_default = toInteger;
|
|
|
|
// node_modules/lodash-es/after.js
|
|
var FUNC_ERROR_TEXT = "Expected a function";
|
|
function after(n, func) {
|
|
if (typeof func != "function") {
|
|
throw new TypeError(FUNC_ERROR_TEXT);
|
|
}
|
|
n = toInteger_default(n);
|
|
return function() {
|
|
if (--n < 1) {
|
|
return func.apply(this, arguments);
|
|
}
|
|
};
|
|
}
|
|
var after_default = after;
|
|
|
|
// node_modules/lodash-es/identity.js
|
|
function identity(value) {
|
|
return value;
|
|
}
|
|
var identity_default = identity;
|
|
|
|
// node_modules/lodash-es/isFunction.js
|
|
var asyncTag = "[object AsyncFunction]";
|
|
var funcTag = "[object Function]";
|
|
var genTag = "[object GeneratorFunction]";
|
|
var proxyTag = "[object Proxy]";
|
|
function isFunction2(value) {
|
|
if (!isObject_default(value)) {
|
|
return false;
|
|
}
|
|
var tag = baseGetTag_default(value);
|
|
return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
|
|
}
|
|
var isFunction_default = isFunction2;
|
|
|
|
// node_modules/lodash-es/_coreJsData.js
|
|
var coreJsData = root_default["__core-js_shared__"];
|
|
var coreJsData_default = coreJsData;
|
|
|
|
// node_modules/lodash-es/_isMasked.js
|
|
var maskSrcKey = function() {
|
|
var uid2 = /[^.]+$/.exec(coreJsData_default && coreJsData_default.keys && coreJsData_default.keys.IE_PROTO || "");
|
|
return uid2 ? "Symbol(src)_1." + uid2 : "";
|
|
}();
|
|
function isMasked(func) {
|
|
return !!maskSrcKey && maskSrcKey in func;
|
|
}
|
|
var isMasked_default = isMasked;
|
|
|
|
// node_modules/lodash-es/_toSource.js
|
|
var funcProto = Function.prototype;
|
|
var funcToString = funcProto.toString;
|
|
function toSource(func) {
|
|
if (func != null) {
|
|
try {
|
|
return funcToString.call(func);
|
|
} catch (e) {
|
|
}
|
|
try {
|
|
return func + "";
|
|
} catch (e) {
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
var toSource_default = toSource;
|
|
|
|
// node_modules/lodash-es/_baseIsNative.js
|
|
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
|
|
var reIsHostCtor = /^\[object .+?Constructor\]$/;
|
|
var funcProto2 = Function.prototype;
|
|
var objectProto3 = Object.prototype;
|
|
var funcToString2 = funcProto2.toString;
|
|
var hasOwnProperty2 = objectProto3.hasOwnProperty;
|
|
var reIsNative = RegExp("^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
|
|
function baseIsNative(value) {
|
|
if (!isObject_default(value) || isMasked_default(value)) {
|
|
return false;
|
|
}
|
|
var pattern4 = isFunction_default(value) ? reIsNative : reIsHostCtor;
|
|
return pattern4.test(toSource_default(value));
|
|
}
|
|
var baseIsNative_default = baseIsNative;
|
|
|
|
// node_modules/lodash-es/_getValue.js
|
|
function getValue(object4, key) {
|
|
return object4 == null ? void 0 : object4[key];
|
|
}
|
|
var getValue_default = getValue;
|
|
|
|
// node_modules/lodash-es/_getNative.js
|
|
function getNative(object4, key) {
|
|
var value = getValue_default(object4, key);
|
|
return baseIsNative_default(value) ? value : void 0;
|
|
}
|
|
var getNative_default = getNative;
|
|
|
|
// node_modules/lodash-es/_WeakMap.js
|
|
var WeakMap = getNative_default(root_default, "WeakMap");
|
|
var WeakMap_default = WeakMap;
|
|
|
|
// node_modules/lodash-es/_metaMap.js
|
|
var metaMap = WeakMap_default && new WeakMap_default();
|
|
var metaMap_default = metaMap;
|
|
|
|
// node_modules/lodash-es/_baseSetData.js
|
|
var baseSetData = !metaMap_default ? identity_default : function(func, data) {
|
|
metaMap_default.set(func, data);
|
|
return func;
|
|
};
|
|
var baseSetData_default = baseSetData;
|
|
|
|
// node_modules/lodash-es/_baseCreate.js
|
|
var objectCreate = Object.create;
|
|
var baseCreate = function() {
|
|
function object4() {
|
|
}
|
|
return function(proto) {
|
|
if (!isObject_default(proto)) {
|
|
return {};
|
|
}
|
|
if (objectCreate) {
|
|
return objectCreate(proto);
|
|
}
|
|
object4.prototype = proto;
|
|
var result2 = new object4();
|
|
object4.prototype = void 0;
|
|
return result2;
|
|
};
|
|
}();
|
|
var baseCreate_default = baseCreate;
|
|
|
|
// node_modules/lodash-es/_createCtor.js
|
|
function createCtor(Ctor) {
|
|
return function() {
|
|
var args = arguments;
|
|
switch (args.length) {
|
|
case 0:
|
|
return new Ctor();
|
|
case 1:
|
|
return new Ctor(args[0]);
|
|
case 2:
|
|
return new Ctor(args[0], args[1]);
|
|
case 3:
|
|
return new Ctor(args[0], args[1], args[2]);
|
|
case 4:
|
|
return new Ctor(args[0], args[1], args[2], args[3]);
|
|
case 5:
|
|
return new Ctor(args[0], args[1], args[2], args[3], args[4]);
|
|
case 6:
|
|
return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
|
|
case 7:
|
|
return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
|
|
}
|
|
var thisBinding = baseCreate_default(Ctor.prototype), result2 = Ctor.apply(thisBinding, args);
|
|
return isObject_default(result2) ? result2 : thisBinding;
|
|
};
|
|
}
|
|
var createCtor_default = createCtor;
|
|
|
|
// node_modules/lodash-es/_createBind.js
|
|
var WRAP_BIND_FLAG = 1;
|
|
function createBind(func, bitmask, thisArg) {
|
|
var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor_default(func);
|
|
function wrapper() {
|
|
var fn2 = this && this !== root_default && this instanceof wrapper ? Ctor : func;
|
|
return fn2.apply(isBind ? thisArg : this, arguments);
|
|
}
|
|
return wrapper;
|
|
}
|
|
var createBind_default = createBind;
|
|
|
|
// node_modules/lodash-es/_apply.js
|
|
function apply(func, thisArg, args) {
|
|
switch (args.length) {
|
|
case 0:
|
|
return func.call(thisArg);
|
|
case 1:
|
|
return func.call(thisArg, args[0]);
|
|
case 2:
|
|
return func.call(thisArg, args[0], args[1]);
|
|
case 3:
|
|
return func.call(thisArg, args[0], args[1], args[2]);
|
|
}
|
|
return func.apply(thisArg, args);
|
|
}
|
|
var apply_default = apply;
|
|
|
|
// node_modules/lodash-es/_composeArgs.js
|
|
var nativeMax = Math.max;
|
|
function composeArgs(args, partials, holders, isCurried) {
|
|
var argsIndex = -1, argsLength = args.length, holdersLength = holders.length, leftIndex = -1, leftLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result2 = Array(leftLength + rangeLength), isUncurried = !isCurried;
|
|
while (++leftIndex < leftLength) {
|
|
result2[leftIndex] = partials[leftIndex];
|
|
}
|
|
while (++argsIndex < holdersLength) {
|
|
if (isUncurried || argsIndex < argsLength) {
|
|
result2[holders[argsIndex]] = args[argsIndex];
|
|
}
|
|
}
|
|
while (rangeLength--) {
|
|
result2[leftIndex++] = args[argsIndex++];
|
|
}
|
|
return result2;
|
|
}
|
|
var composeArgs_default = composeArgs;
|
|
|
|
// node_modules/lodash-es/_composeArgsRight.js
|
|
var nativeMax2 = Math.max;
|
|
function composeArgsRight(args, partials, holders, isCurried) {
|
|
var argsIndex = -1, argsLength = args.length, holdersIndex = -1, holdersLength = holders.length, rightIndex = -1, rightLength = partials.length, rangeLength = nativeMax2(argsLength - holdersLength, 0), result2 = Array(rangeLength + rightLength), isUncurried = !isCurried;
|
|
while (++argsIndex < rangeLength) {
|
|
result2[argsIndex] = args[argsIndex];
|
|
}
|
|
var offset3 = argsIndex;
|
|
while (++rightIndex < rightLength) {
|
|
result2[offset3 + rightIndex] = partials[rightIndex];
|
|
}
|
|
while (++holdersIndex < holdersLength) {
|
|
if (isUncurried || argsIndex < argsLength) {
|
|
result2[offset3 + holders[holdersIndex]] = args[argsIndex++];
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var composeArgsRight_default = composeArgsRight;
|
|
|
|
// node_modules/lodash-es/_countHolders.js
|
|
function countHolders(array4, placeholder) {
|
|
var length = array4.length, result2 = 0;
|
|
while (length--) {
|
|
if (array4[length] === placeholder) {
|
|
++result2;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var countHolders_default = countHolders;
|
|
|
|
// node_modules/lodash-es/_baseLodash.js
|
|
function baseLodash() {
|
|
}
|
|
var baseLodash_default = baseLodash;
|
|
|
|
// node_modules/lodash-es/_LazyWrapper.js
|
|
var MAX_ARRAY_LENGTH = 4294967295;
|
|
function LazyWrapper(value) {
|
|
this.__wrapped__ = value;
|
|
this.__actions__ = [];
|
|
this.__dir__ = 1;
|
|
this.__filtered__ = false;
|
|
this.__iteratees__ = [];
|
|
this.__takeCount__ = MAX_ARRAY_LENGTH;
|
|
this.__views__ = [];
|
|
}
|
|
LazyWrapper.prototype = baseCreate_default(baseLodash_default.prototype);
|
|
LazyWrapper.prototype.constructor = LazyWrapper;
|
|
var LazyWrapper_default = LazyWrapper;
|
|
|
|
// node_modules/lodash-es/noop.js
|
|
function noop() {
|
|
}
|
|
var noop_default = noop;
|
|
|
|
// node_modules/lodash-es/_getData.js
|
|
var getData = !metaMap_default ? noop_default : function(func) {
|
|
return metaMap_default.get(func);
|
|
};
|
|
var getData_default = getData;
|
|
|
|
// node_modules/lodash-es/_realNames.js
|
|
var realNames = {};
|
|
var realNames_default = realNames;
|
|
|
|
// node_modules/lodash-es/_getFuncName.js
|
|
var objectProto4 = Object.prototype;
|
|
var hasOwnProperty3 = objectProto4.hasOwnProperty;
|
|
function getFuncName(func) {
|
|
var result2 = func.name + "", array4 = realNames_default[result2], length = hasOwnProperty3.call(realNames_default, result2) ? array4.length : 0;
|
|
while (length--) {
|
|
var data = array4[length], otherFunc = data.func;
|
|
if (otherFunc == null || otherFunc == func) {
|
|
return data.name;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var getFuncName_default = getFuncName;
|
|
|
|
// node_modules/lodash-es/_LodashWrapper.js
|
|
function LodashWrapper(value, chainAll) {
|
|
this.__wrapped__ = value;
|
|
this.__actions__ = [];
|
|
this.__chain__ = !!chainAll;
|
|
this.__index__ = 0;
|
|
this.__values__ = void 0;
|
|
}
|
|
LodashWrapper.prototype = baseCreate_default(baseLodash_default.prototype);
|
|
LodashWrapper.prototype.constructor = LodashWrapper;
|
|
var LodashWrapper_default = LodashWrapper;
|
|
|
|
// node_modules/lodash-es/_copyArray.js
|
|
function copyArray(source, array4) {
|
|
var index = -1, length = source.length;
|
|
array4 || (array4 = Array(length));
|
|
while (++index < length) {
|
|
array4[index] = source[index];
|
|
}
|
|
return array4;
|
|
}
|
|
var copyArray_default = copyArray;
|
|
|
|
// node_modules/lodash-es/_wrapperClone.js
|
|
function wrapperClone(wrapper) {
|
|
if (wrapper instanceof LazyWrapper_default) {
|
|
return wrapper.clone();
|
|
}
|
|
var result2 = new LodashWrapper_default(wrapper.__wrapped__, wrapper.__chain__);
|
|
result2.__actions__ = copyArray_default(wrapper.__actions__);
|
|
result2.__index__ = wrapper.__index__;
|
|
result2.__values__ = wrapper.__values__;
|
|
return result2;
|
|
}
|
|
var wrapperClone_default = wrapperClone;
|
|
|
|
// node_modules/lodash-es/wrapperLodash.js
|
|
var objectProto5 = Object.prototype;
|
|
var hasOwnProperty4 = objectProto5.hasOwnProperty;
|
|
function lodash(value) {
|
|
if (isObjectLike_default(value) && !isArray_default(value) && !(value instanceof LazyWrapper_default)) {
|
|
if (value instanceof LodashWrapper_default) {
|
|
return value;
|
|
}
|
|
if (hasOwnProperty4.call(value, "__wrapped__")) {
|
|
return wrapperClone_default(value);
|
|
}
|
|
}
|
|
return new LodashWrapper_default(value);
|
|
}
|
|
lodash.prototype = baseLodash_default.prototype;
|
|
lodash.prototype.constructor = lodash;
|
|
var wrapperLodash_default = lodash;
|
|
|
|
// node_modules/lodash-es/_isLaziable.js
|
|
function isLaziable(func) {
|
|
var funcName = getFuncName_default(func), other = wrapperLodash_default[funcName];
|
|
if (typeof other != "function" || !(funcName in LazyWrapper_default.prototype)) {
|
|
return false;
|
|
}
|
|
if (func === other) {
|
|
return true;
|
|
}
|
|
var data = getData_default(other);
|
|
return !!data && func === data[0];
|
|
}
|
|
var isLaziable_default = isLaziable;
|
|
|
|
// node_modules/lodash-es/_shortOut.js
|
|
var HOT_COUNT = 800;
|
|
var HOT_SPAN = 16;
|
|
var nativeNow = Date.now;
|
|
function shortOut(func) {
|
|
var count = 0, lastCalled = 0;
|
|
return function() {
|
|
var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
|
|
lastCalled = stamp;
|
|
if (remaining > 0) {
|
|
if (++count >= HOT_COUNT) {
|
|
return arguments[0];
|
|
}
|
|
} else {
|
|
count = 0;
|
|
}
|
|
return func.apply(void 0, arguments);
|
|
};
|
|
}
|
|
var shortOut_default = shortOut;
|
|
|
|
// node_modules/lodash-es/_setData.js
|
|
var setData = shortOut_default(baseSetData_default);
|
|
var setData_default = setData;
|
|
|
|
// node_modules/lodash-es/_getWrapDetails.js
|
|
var reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/;
|
|
var reSplitDetails = /,? & /;
|
|
function getWrapDetails(source) {
|
|
var match = source.match(reWrapDetails);
|
|
return match ? match[1].split(reSplitDetails) : [];
|
|
}
|
|
var getWrapDetails_default = getWrapDetails;
|
|
|
|
// node_modules/lodash-es/_insertWrapDetails.js
|
|
var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/;
|
|
function insertWrapDetails(source, details) {
|
|
var length = details.length;
|
|
if (!length) {
|
|
return source;
|
|
}
|
|
var lastIndex = length - 1;
|
|
details[lastIndex] = (length > 1 ? "& " : "") + details[lastIndex];
|
|
details = details.join(length > 2 ? ", " : " ");
|
|
return source.replace(reWrapComment, "{\n/* [wrapped with " + details + "] */\n");
|
|
}
|
|
var insertWrapDetails_default = insertWrapDetails;
|
|
|
|
// node_modules/lodash-es/constant.js
|
|
function constant(value) {
|
|
return function() {
|
|
return value;
|
|
};
|
|
}
|
|
var constant_default = constant;
|
|
|
|
// node_modules/lodash-es/_defineProperty.js
|
|
var defineProperty = function() {
|
|
try {
|
|
var func = getNative_default(Object, "defineProperty");
|
|
func({}, "", {});
|
|
return func;
|
|
} catch (e) {
|
|
}
|
|
}();
|
|
var defineProperty_default = defineProperty;
|
|
|
|
// node_modules/lodash-es/_baseSetToString.js
|
|
var baseSetToString = !defineProperty_default ? identity_default : function(func, string3) {
|
|
return defineProperty_default(func, "toString", {
|
|
"configurable": true,
|
|
"enumerable": false,
|
|
"value": constant_default(string3),
|
|
"writable": true
|
|
});
|
|
};
|
|
var baseSetToString_default = baseSetToString;
|
|
|
|
// node_modules/lodash-es/_setToString.js
|
|
var setToString = shortOut_default(baseSetToString_default);
|
|
var setToString_default = setToString;
|
|
|
|
// node_modules/lodash-es/_arrayEach.js
|
|
function arrayEach(array4, iteratee2) {
|
|
var index = -1, length = array4 == null ? 0 : array4.length;
|
|
while (++index < length) {
|
|
if (iteratee2(array4[index], index, array4) === false) {
|
|
break;
|
|
}
|
|
}
|
|
return array4;
|
|
}
|
|
var arrayEach_default = arrayEach;
|
|
|
|
// node_modules/lodash-es/_baseFindIndex.js
|
|
function baseFindIndex(array4, predicate, fromIndex, fromRight) {
|
|
var length = array4.length, index = fromIndex + (fromRight ? 1 : -1);
|
|
while (fromRight ? index-- : ++index < length) {
|
|
if (predicate(array4[index], index, array4)) {
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
var baseFindIndex_default = baseFindIndex;
|
|
|
|
// node_modules/lodash-es/_baseIsNaN.js
|
|
function baseIsNaN(value) {
|
|
return value !== value;
|
|
}
|
|
var baseIsNaN_default = baseIsNaN;
|
|
|
|
// node_modules/lodash-es/_strictIndexOf.js
|
|
function strictIndexOf(array4, value, fromIndex) {
|
|
var index = fromIndex - 1, length = array4.length;
|
|
while (++index < length) {
|
|
if (array4[index] === value) {
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
var strictIndexOf_default = strictIndexOf;
|
|
|
|
// node_modules/lodash-es/_baseIndexOf.js
|
|
function baseIndexOf(array4, value, fromIndex) {
|
|
return value === value ? strictIndexOf_default(array4, value, fromIndex) : baseFindIndex_default(array4, baseIsNaN_default, fromIndex);
|
|
}
|
|
var baseIndexOf_default = baseIndexOf;
|
|
|
|
// node_modules/lodash-es/_arrayIncludes.js
|
|
function arrayIncludes(array4, value) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
return !!length && baseIndexOf_default(array4, value, 0) > -1;
|
|
}
|
|
var arrayIncludes_default = arrayIncludes;
|
|
|
|
// node_modules/lodash-es/_updateWrapDetails.js
|
|
var WRAP_BIND_FLAG2 = 1;
|
|
var WRAP_BIND_KEY_FLAG = 2;
|
|
var WRAP_CURRY_FLAG = 8;
|
|
var WRAP_CURRY_RIGHT_FLAG = 16;
|
|
var WRAP_PARTIAL_FLAG = 32;
|
|
var WRAP_PARTIAL_RIGHT_FLAG = 64;
|
|
var WRAP_ARY_FLAG = 128;
|
|
var WRAP_REARG_FLAG = 256;
|
|
var WRAP_FLIP_FLAG = 512;
|
|
var wrapFlags = [
|
|
["ary", WRAP_ARY_FLAG],
|
|
["bind", WRAP_BIND_FLAG2],
|
|
["bindKey", WRAP_BIND_KEY_FLAG],
|
|
["curry", WRAP_CURRY_FLAG],
|
|
["curryRight", WRAP_CURRY_RIGHT_FLAG],
|
|
["flip", WRAP_FLIP_FLAG],
|
|
["partial", WRAP_PARTIAL_FLAG],
|
|
["partialRight", WRAP_PARTIAL_RIGHT_FLAG],
|
|
["rearg", WRAP_REARG_FLAG]
|
|
];
|
|
function updateWrapDetails(details, bitmask) {
|
|
arrayEach_default(wrapFlags, function(pair) {
|
|
var value = "_." + pair[0];
|
|
if (bitmask & pair[1] && !arrayIncludes_default(details, value)) {
|
|
details.push(value);
|
|
}
|
|
});
|
|
return details.sort();
|
|
}
|
|
var updateWrapDetails_default = updateWrapDetails;
|
|
|
|
// node_modules/lodash-es/_setWrapToString.js
|
|
function setWrapToString(wrapper, reference, bitmask) {
|
|
var source = reference + "";
|
|
return setToString_default(wrapper, insertWrapDetails_default(source, updateWrapDetails_default(getWrapDetails_default(source), bitmask)));
|
|
}
|
|
var setWrapToString_default = setWrapToString;
|
|
|
|
// node_modules/lodash-es/_createRecurry.js
|
|
var WRAP_BIND_FLAG3 = 1;
|
|
var WRAP_BIND_KEY_FLAG2 = 2;
|
|
var WRAP_CURRY_BOUND_FLAG = 4;
|
|
var WRAP_CURRY_FLAG2 = 8;
|
|
var WRAP_PARTIAL_FLAG2 = 32;
|
|
var WRAP_PARTIAL_RIGHT_FLAG2 = 64;
|
|
function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary2, arity) {
|
|
var isCurry = bitmask & WRAP_CURRY_FLAG2, newHolders = isCurry ? holders : void 0, newHoldersRight = isCurry ? void 0 : holders, newPartials = isCurry ? partials : void 0, newPartialsRight = isCurry ? void 0 : partials;
|
|
bitmask |= isCurry ? WRAP_PARTIAL_FLAG2 : WRAP_PARTIAL_RIGHT_FLAG2;
|
|
bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG2 : WRAP_PARTIAL_FLAG2);
|
|
if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
|
|
bitmask &= ~(WRAP_BIND_FLAG3 | WRAP_BIND_KEY_FLAG2);
|
|
}
|
|
var newData = [
|
|
func,
|
|
bitmask,
|
|
thisArg,
|
|
newPartials,
|
|
newHolders,
|
|
newPartialsRight,
|
|
newHoldersRight,
|
|
argPos,
|
|
ary2,
|
|
arity
|
|
];
|
|
var result2 = wrapFunc.apply(void 0, newData);
|
|
if (isLaziable_default(func)) {
|
|
setData_default(result2, newData);
|
|
}
|
|
result2.placeholder = placeholder;
|
|
return setWrapToString_default(result2, func, bitmask);
|
|
}
|
|
var createRecurry_default = createRecurry;
|
|
|
|
// node_modules/lodash-es/_getHolder.js
|
|
function getHolder(func) {
|
|
var object4 = func;
|
|
return object4.placeholder;
|
|
}
|
|
var getHolder_default = getHolder;
|
|
|
|
// node_modules/lodash-es/_isIndex.js
|
|
var MAX_SAFE_INTEGER = 9007199254740991;
|
|
var reIsUint = /^(?:0|[1-9]\d*)$/;
|
|
function isIndex(value, length) {
|
|
var type4 = typeof value;
|
|
length = length == null ? MAX_SAFE_INTEGER : length;
|
|
return !!length && (type4 == "number" || type4 != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
|
|
}
|
|
var isIndex_default = isIndex;
|
|
|
|
// node_modules/lodash-es/_reorder.js
|
|
var nativeMin = Math.min;
|
|
function reorder(array4, indexes) {
|
|
var arrLength = array4.length, length = nativeMin(indexes.length, arrLength), oldArray = copyArray_default(array4);
|
|
while (length--) {
|
|
var index = indexes[length];
|
|
array4[length] = isIndex_default(index, arrLength) ? oldArray[index] : void 0;
|
|
}
|
|
return array4;
|
|
}
|
|
var reorder_default = reorder;
|
|
|
|
// node_modules/lodash-es/_replaceHolders.js
|
|
var PLACEHOLDER = "__lodash_placeholder__";
|
|
function replaceHolders(array4, placeholder) {
|
|
var index = -1, length = array4.length, resIndex = 0, result2 = [];
|
|
while (++index < length) {
|
|
var value = array4[index];
|
|
if (value === placeholder || value === PLACEHOLDER) {
|
|
array4[index] = PLACEHOLDER;
|
|
result2[resIndex++] = index;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var replaceHolders_default = replaceHolders;
|
|
|
|
// node_modules/lodash-es/_createHybrid.js
|
|
var WRAP_BIND_FLAG4 = 1;
|
|
var WRAP_BIND_KEY_FLAG3 = 2;
|
|
var WRAP_CURRY_FLAG3 = 8;
|
|
var WRAP_CURRY_RIGHT_FLAG2 = 16;
|
|
var WRAP_ARY_FLAG2 = 128;
|
|
var WRAP_FLIP_FLAG2 = 512;
|
|
function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary2, arity) {
|
|
var isAry = bitmask & WRAP_ARY_FLAG2, isBind = bitmask & WRAP_BIND_FLAG4, isBindKey = bitmask & WRAP_BIND_KEY_FLAG3, isCurried = bitmask & (WRAP_CURRY_FLAG3 | WRAP_CURRY_RIGHT_FLAG2), isFlip = bitmask & WRAP_FLIP_FLAG2, Ctor = isBindKey ? void 0 : createCtor_default(func);
|
|
function wrapper() {
|
|
var length = arguments.length, args = Array(length), index = length;
|
|
while (index--) {
|
|
args[index] = arguments[index];
|
|
}
|
|
if (isCurried) {
|
|
var placeholder = getHolder_default(wrapper), holdersCount = countHolders_default(args, placeholder);
|
|
}
|
|
if (partials) {
|
|
args = composeArgs_default(args, partials, holders, isCurried);
|
|
}
|
|
if (partialsRight) {
|
|
args = composeArgsRight_default(args, partialsRight, holdersRight, isCurried);
|
|
}
|
|
length -= holdersCount;
|
|
if (isCurried && length < arity) {
|
|
var newHolders = replaceHolders_default(args, placeholder);
|
|
return createRecurry_default(func, bitmask, createHybrid, wrapper.placeholder, thisArg, args, newHolders, argPos, ary2, arity - length);
|
|
}
|
|
var thisBinding = isBind ? thisArg : this, fn2 = isBindKey ? thisBinding[func] : func;
|
|
length = args.length;
|
|
if (argPos) {
|
|
args = reorder_default(args, argPos);
|
|
} else if (isFlip && length > 1) {
|
|
args.reverse();
|
|
}
|
|
if (isAry && ary2 < length) {
|
|
args.length = ary2;
|
|
}
|
|
if (this && this !== root_default && this instanceof wrapper) {
|
|
fn2 = Ctor || createCtor_default(fn2);
|
|
}
|
|
return fn2.apply(thisBinding, args);
|
|
}
|
|
return wrapper;
|
|
}
|
|
var createHybrid_default = createHybrid;
|
|
|
|
// node_modules/lodash-es/_createCurry.js
|
|
function createCurry(func, bitmask, arity) {
|
|
var Ctor = createCtor_default(func);
|
|
function wrapper() {
|
|
var length = arguments.length, args = Array(length), index = length, placeholder = getHolder_default(wrapper);
|
|
while (index--) {
|
|
args[index] = arguments[index];
|
|
}
|
|
var holders = length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder ? [] : replaceHolders_default(args, placeholder);
|
|
length -= holders.length;
|
|
if (length < arity) {
|
|
return createRecurry_default(func, bitmask, createHybrid_default, wrapper.placeholder, void 0, args, holders, void 0, void 0, arity - length);
|
|
}
|
|
var fn2 = this && this !== root_default && this instanceof wrapper ? Ctor : func;
|
|
return apply_default(fn2, this, args);
|
|
}
|
|
return wrapper;
|
|
}
|
|
var createCurry_default = createCurry;
|
|
|
|
// node_modules/lodash-es/_createPartial.js
|
|
var WRAP_BIND_FLAG5 = 1;
|
|
function createPartial(func, bitmask, thisArg, partials) {
|
|
var isBind = bitmask & WRAP_BIND_FLAG5, Ctor = createCtor_default(func);
|
|
function wrapper() {
|
|
var argsIndex = -1, argsLength = arguments.length, leftIndex = -1, leftLength = partials.length, args = Array(leftLength + argsLength), fn2 = this && this !== root_default && this instanceof wrapper ? Ctor : func;
|
|
while (++leftIndex < leftLength) {
|
|
args[leftIndex] = partials[leftIndex];
|
|
}
|
|
while (argsLength--) {
|
|
args[leftIndex++] = arguments[++argsIndex];
|
|
}
|
|
return apply_default(fn2, isBind ? thisArg : this, args);
|
|
}
|
|
return wrapper;
|
|
}
|
|
var createPartial_default = createPartial;
|
|
|
|
// node_modules/lodash-es/_mergeData.js
|
|
var PLACEHOLDER2 = "__lodash_placeholder__";
|
|
var WRAP_BIND_FLAG6 = 1;
|
|
var WRAP_BIND_KEY_FLAG4 = 2;
|
|
var WRAP_CURRY_BOUND_FLAG2 = 4;
|
|
var WRAP_CURRY_FLAG4 = 8;
|
|
var WRAP_ARY_FLAG3 = 128;
|
|
var WRAP_REARG_FLAG2 = 256;
|
|
var nativeMin2 = Math.min;
|
|
function mergeData(data, source) {
|
|
var bitmask = data[1], srcBitmask = source[1], newBitmask = bitmask | srcBitmask, isCommon = newBitmask < (WRAP_BIND_FLAG6 | WRAP_BIND_KEY_FLAG4 | WRAP_ARY_FLAG3);
|
|
var isCombo = srcBitmask == WRAP_ARY_FLAG3 && bitmask == WRAP_CURRY_FLAG4 || srcBitmask == WRAP_ARY_FLAG3 && bitmask == WRAP_REARG_FLAG2 && data[7].length <= source[8] || srcBitmask == (WRAP_ARY_FLAG3 | WRAP_REARG_FLAG2) && source[7].length <= source[8] && bitmask == WRAP_CURRY_FLAG4;
|
|
if (!(isCommon || isCombo)) {
|
|
return data;
|
|
}
|
|
if (srcBitmask & WRAP_BIND_FLAG6) {
|
|
data[2] = source[2];
|
|
newBitmask |= bitmask & WRAP_BIND_FLAG6 ? 0 : WRAP_CURRY_BOUND_FLAG2;
|
|
}
|
|
var value = source[3];
|
|
if (value) {
|
|
var partials = data[3];
|
|
data[3] = partials ? composeArgs_default(partials, value, source[4]) : value;
|
|
data[4] = partials ? replaceHolders_default(data[3], PLACEHOLDER2) : source[4];
|
|
}
|
|
value = source[5];
|
|
if (value) {
|
|
partials = data[5];
|
|
data[5] = partials ? composeArgsRight_default(partials, value, source[6]) : value;
|
|
data[6] = partials ? replaceHolders_default(data[5], PLACEHOLDER2) : source[6];
|
|
}
|
|
value = source[7];
|
|
if (value) {
|
|
data[7] = value;
|
|
}
|
|
if (srcBitmask & WRAP_ARY_FLAG3) {
|
|
data[8] = data[8] == null ? source[8] : nativeMin2(data[8], source[8]);
|
|
}
|
|
if (data[9] == null) {
|
|
data[9] = source[9];
|
|
}
|
|
data[0] = source[0];
|
|
data[1] = newBitmask;
|
|
return data;
|
|
}
|
|
var mergeData_default = mergeData;
|
|
|
|
// node_modules/lodash-es/_createWrap.js
|
|
var FUNC_ERROR_TEXT2 = "Expected a function";
|
|
var WRAP_BIND_FLAG7 = 1;
|
|
var WRAP_BIND_KEY_FLAG5 = 2;
|
|
var WRAP_CURRY_FLAG5 = 8;
|
|
var WRAP_CURRY_RIGHT_FLAG3 = 16;
|
|
var WRAP_PARTIAL_FLAG3 = 32;
|
|
var WRAP_PARTIAL_RIGHT_FLAG3 = 64;
|
|
var nativeMax3 = Math.max;
|
|
function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary2, arity) {
|
|
var isBindKey = bitmask & WRAP_BIND_KEY_FLAG5;
|
|
if (!isBindKey && typeof func != "function") {
|
|
throw new TypeError(FUNC_ERROR_TEXT2);
|
|
}
|
|
var length = partials ? partials.length : 0;
|
|
if (!length) {
|
|
bitmask &= ~(WRAP_PARTIAL_FLAG3 | WRAP_PARTIAL_RIGHT_FLAG3);
|
|
partials = holders = void 0;
|
|
}
|
|
ary2 = ary2 === void 0 ? ary2 : nativeMax3(toInteger_default(ary2), 0);
|
|
arity = arity === void 0 ? arity : toInteger_default(arity);
|
|
length -= holders ? holders.length : 0;
|
|
if (bitmask & WRAP_PARTIAL_RIGHT_FLAG3) {
|
|
var partialsRight = partials, holdersRight = holders;
|
|
partials = holders = void 0;
|
|
}
|
|
var data = isBindKey ? void 0 : getData_default(func);
|
|
var newData = [
|
|
func,
|
|
bitmask,
|
|
thisArg,
|
|
partials,
|
|
holders,
|
|
partialsRight,
|
|
holdersRight,
|
|
argPos,
|
|
ary2,
|
|
arity
|
|
];
|
|
if (data) {
|
|
mergeData_default(newData, data);
|
|
}
|
|
func = newData[0];
|
|
bitmask = newData[1];
|
|
thisArg = newData[2];
|
|
partials = newData[3];
|
|
holders = newData[4];
|
|
arity = newData[9] = newData[9] === void 0 ? isBindKey ? 0 : func.length : nativeMax3(newData[9] - length, 0);
|
|
if (!arity && bitmask & (WRAP_CURRY_FLAG5 | WRAP_CURRY_RIGHT_FLAG3)) {
|
|
bitmask &= ~(WRAP_CURRY_FLAG5 | WRAP_CURRY_RIGHT_FLAG3);
|
|
}
|
|
if (!bitmask || bitmask == WRAP_BIND_FLAG7) {
|
|
var result2 = createBind_default(func, bitmask, thisArg);
|
|
} else if (bitmask == WRAP_CURRY_FLAG5 || bitmask == WRAP_CURRY_RIGHT_FLAG3) {
|
|
result2 = createCurry_default(func, bitmask, arity);
|
|
} else if ((bitmask == WRAP_PARTIAL_FLAG3 || bitmask == (WRAP_BIND_FLAG7 | WRAP_PARTIAL_FLAG3)) && !holders.length) {
|
|
result2 = createPartial_default(func, bitmask, thisArg, partials);
|
|
} else {
|
|
result2 = createHybrid_default.apply(void 0, newData);
|
|
}
|
|
var setter = data ? baseSetData_default : setData_default;
|
|
return setWrapToString_default(setter(result2, newData), func, bitmask);
|
|
}
|
|
var createWrap_default = createWrap;
|
|
|
|
// node_modules/lodash-es/ary.js
|
|
var WRAP_ARY_FLAG4 = 128;
|
|
function ary(func, n, guard) {
|
|
n = guard ? void 0 : n;
|
|
n = func && n == null ? func.length : n;
|
|
return createWrap_default(func, WRAP_ARY_FLAG4, void 0, void 0, void 0, void 0, n);
|
|
}
|
|
var ary_default = ary;
|
|
|
|
// node_modules/lodash-es/_baseAssignValue.js
|
|
function baseAssignValue(object4, key, value) {
|
|
if (key == "__proto__" && defineProperty_default) {
|
|
defineProperty_default(object4, key, {
|
|
"configurable": true,
|
|
"enumerable": true,
|
|
"value": value,
|
|
"writable": true
|
|
});
|
|
} else {
|
|
object4[key] = value;
|
|
}
|
|
}
|
|
var baseAssignValue_default = baseAssignValue;
|
|
|
|
// node_modules/lodash-es/eq.js
|
|
function eq(value, other) {
|
|
return value === other || value !== value && other !== other;
|
|
}
|
|
var eq_default = eq;
|
|
|
|
// node_modules/lodash-es/_assignValue.js
|
|
var objectProto6 = Object.prototype;
|
|
var hasOwnProperty5 = objectProto6.hasOwnProperty;
|
|
function assignValue(object4, key, value) {
|
|
var objValue = object4[key];
|
|
if (!(hasOwnProperty5.call(object4, key) && eq_default(objValue, value)) || value === void 0 && !(key in object4)) {
|
|
baseAssignValue_default(object4, key, value);
|
|
}
|
|
}
|
|
var assignValue_default = assignValue;
|
|
|
|
// node_modules/lodash-es/_copyObject.js
|
|
function copyObject(source, props2, object4, customizer) {
|
|
var isNew = !object4;
|
|
object4 || (object4 = {});
|
|
var index = -1, length = props2.length;
|
|
while (++index < length) {
|
|
var key = props2[index];
|
|
var newValue = customizer ? customizer(object4[key], source[key], key, object4, source) : void 0;
|
|
if (newValue === void 0) {
|
|
newValue = source[key];
|
|
}
|
|
if (isNew) {
|
|
baseAssignValue_default(object4, key, newValue);
|
|
} else {
|
|
assignValue_default(object4, key, newValue);
|
|
}
|
|
}
|
|
return object4;
|
|
}
|
|
var copyObject_default = copyObject;
|
|
|
|
// node_modules/lodash-es/_overRest.js
|
|
var nativeMax4 = Math.max;
|
|
function overRest(func, start, transform2) {
|
|
start = nativeMax4(start === void 0 ? func.length - 1 : start, 0);
|
|
return function() {
|
|
var args = arguments, index = -1, length = nativeMax4(args.length - start, 0), array4 = Array(length);
|
|
while (++index < length) {
|
|
array4[index] = args[start + index];
|
|
}
|
|
index = -1;
|
|
var otherArgs = Array(start + 1);
|
|
while (++index < start) {
|
|
otherArgs[index] = args[index];
|
|
}
|
|
otherArgs[start] = transform2(array4);
|
|
return apply_default(func, this, otherArgs);
|
|
};
|
|
}
|
|
var overRest_default = overRest;
|
|
|
|
// node_modules/lodash-es/_baseRest.js
|
|
function baseRest(func, start) {
|
|
return setToString_default(overRest_default(func, start, identity_default), func + "");
|
|
}
|
|
var baseRest_default = baseRest;
|
|
|
|
// node_modules/lodash-es/isLength.js
|
|
var MAX_SAFE_INTEGER2 = 9007199254740991;
|
|
function isLength(value) {
|
|
return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER2;
|
|
}
|
|
var isLength_default = isLength;
|
|
|
|
// node_modules/lodash-es/isArrayLike.js
|
|
function isArrayLike(value) {
|
|
return value != null && isLength_default(value.length) && !isFunction_default(value);
|
|
}
|
|
var isArrayLike_default = isArrayLike;
|
|
|
|
// node_modules/lodash-es/_isIterateeCall.js
|
|
function isIterateeCall(value, index, object4) {
|
|
if (!isObject_default(object4)) {
|
|
return false;
|
|
}
|
|
var type4 = typeof index;
|
|
if (type4 == "number" ? isArrayLike_default(object4) && isIndex_default(index, object4.length) : type4 == "string" && index in object4) {
|
|
return eq_default(object4[index], value);
|
|
}
|
|
return false;
|
|
}
|
|
var isIterateeCall_default = isIterateeCall;
|
|
|
|
// node_modules/lodash-es/_createAssigner.js
|
|
function createAssigner(assigner) {
|
|
return baseRest_default(function(object4, sources) {
|
|
var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : void 0, guard = length > 2 ? sources[2] : void 0;
|
|
customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : void 0;
|
|
if (guard && isIterateeCall_default(sources[0], sources[1], guard)) {
|
|
customizer = length < 3 ? void 0 : customizer;
|
|
length = 1;
|
|
}
|
|
object4 = Object(object4);
|
|
while (++index < length) {
|
|
var source = sources[index];
|
|
if (source) {
|
|
assigner(object4, source, index, customizer);
|
|
}
|
|
}
|
|
return object4;
|
|
});
|
|
}
|
|
var createAssigner_default = createAssigner;
|
|
|
|
// node_modules/lodash-es/_isPrototype.js
|
|
var objectProto7 = Object.prototype;
|
|
function isPrototype(value) {
|
|
var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto7;
|
|
return value === proto;
|
|
}
|
|
var isPrototype_default = isPrototype;
|
|
|
|
// node_modules/lodash-es/_baseTimes.js
|
|
function baseTimes(n, iteratee2) {
|
|
var index = -1, result2 = Array(n);
|
|
while (++index < n) {
|
|
result2[index] = iteratee2(index);
|
|
}
|
|
return result2;
|
|
}
|
|
var baseTimes_default = baseTimes;
|
|
|
|
// node_modules/lodash-es/_baseIsArguments.js
|
|
var argsTag = "[object Arguments]";
|
|
function baseIsArguments(value) {
|
|
return isObjectLike_default(value) && baseGetTag_default(value) == argsTag;
|
|
}
|
|
var baseIsArguments_default = baseIsArguments;
|
|
|
|
// node_modules/lodash-es/isArguments.js
|
|
var objectProto8 = Object.prototype;
|
|
var hasOwnProperty6 = objectProto8.hasOwnProperty;
|
|
var propertyIsEnumerable = objectProto8.propertyIsEnumerable;
|
|
var isArguments = baseIsArguments_default(function() {
|
|
return arguments;
|
|
}()) ? baseIsArguments_default : function(value) {
|
|
return isObjectLike_default(value) && hasOwnProperty6.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
|
|
};
|
|
var isArguments_default = isArguments;
|
|
|
|
// node_modules/lodash-es/stubFalse.js
|
|
function stubFalse() {
|
|
return false;
|
|
}
|
|
var stubFalse_default = stubFalse;
|
|
|
|
// node_modules/lodash-es/isBuffer.js
|
|
var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
|
|
var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
|
|
var moduleExports = freeModule && freeModule.exports === freeExports;
|
|
var Buffer = moduleExports ? root_default.Buffer : void 0;
|
|
var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
|
|
var isBuffer = nativeIsBuffer || stubFalse_default;
|
|
var isBuffer_default = isBuffer;
|
|
|
|
// node_modules/lodash-es/_baseIsTypedArray.js
|
|
var argsTag2 = "[object Arguments]";
|
|
var arrayTag = "[object Array]";
|
|
var boolTag = "[object Boolean]";
|
|
var dateTag = "[object Date]";
|
|
var errorTag = "[object Error]";
|
|
var funcTag2 = "[object Function]";
|
|
var mapTag = "[object Map]";
|
|
var numberTag = "[object Number]";
|
|
var objectTag = "[object Object]";
|
|
var regexpTag = "[object RegExp]";
|
|
var setTag = "[object Set]";
|
|
var stringTag = "[object String]";
|
|
var weakMapTag = "[object WeakMap]";
|
|
var arrayBufferTag = "[object ArrayBuffer]";
|
|
var dataViewTag = "[object DataView]";
|
|
var float32Tag = "[object Float32Array]";
|
|
var float64Tag = "[object Float64Array]";
|
|
var int8Tag = "[object Int8Array]";
|
|
var int16Tag = "[object Int16Array]";
|
|
var int32Tag = "[object Int32Array]";
|
|
var uint8Tag = "[object Uint8Array]";
|
|
var uint8ClampedTag = "[object Uint8ClampedArray]";
|
|
var uint16Tag = "[object Uint16Array]";
|
|
var uint32Tag = "[object Uint32Array]";
|
|
var typedArrayTags = {};
|
|
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
|
|
typedArrayTags[argsTag2] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag2] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
|
|
function baseIsTypedArray(value) {
|
|
return isObjectLike_default(value) && isLength_default(value.length) && !!typedArrayTags[baseGetTag_default(value)];
|
|
}
|
|
var baseIsTypedArray_default = baseIsTypedArray;
|
|
|
|
// node_modules/lodash-es/_baseUnary.js
|
|
function baseUnary(func) {
|
|
return function(value) {
|
|
return func(value);
|
|
};
|
|
}
|
|
var baseUnary_default = baseUnary;
|
|
|
|
// node_modules/lodash-es/_nodeUtil.js
|
|
var freeExports2 = typeof exports == "object" && exports && !exports.nodeType && exports;
|
|
var freeModule2 = freeExports2 && typeof module == "object" && module && !module.nodeType && module;
|
|
var moduleExports2 = freeModule2 && freeModule2.exports === freeExports2;
|
|
var freeProcess = moduleExports2 && freeGlobal_default.process;
|
|
var nodeUtil = function() {
|
|
try {
|
|
var types2 = freeModule2 && freeModule2.require && freeModule2.require("util").types;
|
|
if (types2) {
|
|
return types2;
|
|
}
|
|
return freeProcess && freeProcess.binding && freeProcess.binding("util");
|
|
} catch (e) {
|
|
}
|
|
}();
|
|
var nodeUtil_default = nodeUtil;
|
|
|
|
// node_modules/lodash-es/isTypedArray.js
|
|
var nodeIsTypedArray = nodeUtil_default && nodeUtil_default.isTypedArray;
|
|
var isTypedArray = nodeIsTypedArray ? baseUnary_default(nodeIsTypedArray) : baseIsTypedArray_default;
|
|
var isTypedArray_default = isTypedArray;
|
|
|
|
// node_modules/lodash-es/_arrayLikeKeys.js
|
|
var objectProto9 = Object.prototype;
|
|
var hasOwnProperty7 = objectProto9.hasOwnProperty;
|
|
function arrayLikeKeys(value, inherited) {
|
|
var isArr = isArray_default(value), isArg = !isArr && isArguments_default(value), isBuff = !isArr && !isArg && isBuffer_default(value), isType = !isArr && !isArg && !isBuff && isTypedArray_default(value), skipIndexes = isArr || isArg || isBuff || isType, result2 = skipIndexes ? baseTimes_default(value.length, String) : [], length = result2.length;
|
|
for (var key in value) {
|
|
if ((inherited || hasOwnProperty7.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || isIndex_default(key, length)))) {
|
|
result2.push(key);
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var arrayLikeKeys_default = arrayLikeKeys;
|
|
|
|
// node_modules/lodash-es/_overArg.js
|
|
function overArg(func, transform2) {
|
|
return function(arg) {
|
|
return func(transform2(arg));
|
|
};
|
|
}
|
|
var overArg_default = overArg;
|
|
|
|
// node_modules/lodash-es/_nativeKeys.js
|
|
var nativeKeys = overArg_default(Object.keys, Object);
|
|
var nativeKeys_default = nativeKeys;
|
|
|
|
// node_modules/lodash-es/_baseKeys.js
|
|
var objectProto10 = Object.prototype;
|
|
var hasOwnProperty8 = objectProto10.hasOwnProperty;
|
|
function baseKeys(object4) {
|
|
if (!isPrototype_default(object4)) {
|
|
return nativeKeys_default(object4);
|
|
}
|
|
var result2 = [];
|
|
for (var key in Object(object4)) {
|
|
if (hasOwnProperty8.call(object4, key) && key != "constructor") {
|
|
result2.push(key);
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var baseKeys_default = baseKeys;
|
|
|
|
// node_modules/lodash-es/keys.js
|
|
function keys(object4) {
|
|
return isArrayLike_default(object4) ? arrayLikeKeys_default(object4) : baseKeys_default(object4);
|
|
}
|
|
var keys_default = keys;
|
|
|
|
// node_modules/lodash-es/assign.js
|
|
var objectProto11 = Object.prototype;
|
|
var hasOwnProperty9 = objectProto11.hasOwnProperty;
|
|
var assign = createAssigner_default(function(object4, source) {
|
|
if (isPrototype_default(source) || isArrayLike_default(source)) {
|
|
copyObject_default(source, keys_default(source), object4);
|
|
return;
|
|
}
|
|
for (var key in source) {
|
|
if (hasOwnProperty9.call(source, key)) {
|
|
assignValue_default(object4, key, source[key]);
|
|
}
|
|
}
|
|
});
|
|
var assign_default = assign;
|
|
|
|
// node_modules/lodash-es/_nativeKeysIn.js
|
|
function nativeKeysIn(object4) {
|
|
var result2 = [];
|
|
if (object4 != null) {
|
|
for (var key in Object(object4)) {
|
|
result2.push(key);
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var nativeKeysIn_default = nativeKeysIn;
|
|
|
|
// node_modules/lodash-es/_baseKeysIn.js
|
|
var objectProto12 = Object.prototype;
|
|
var hasOwnProperty10 = objectProto12.hasOwnProperty;
|
|
function baseKeysIn(object4) {
|
|
if (!isObject_default(object4)) {
|
|
return nativeKeysIn_default(object4);
|
|
}
|
|
var isProto = isPrototype_default(object4), result2 = [];
|
|
for (var key in object4) {
|
|
if (!(key == "constructor" && (isProto || !hasOwnProperty10.call(object4, key)))) {
|
|
result2.push(key);
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var baseKeysIn_default = baseKeysIn;
|
|
|
|
// node_modules/lodash-es/keysIn.js
|
|
function keysIn(object4) {
|
|
return isArrayLike_default(object4) ? arrayLikeKeys_default(object4, true) : baseKeysIn_default(object4);
|
|
}
|
|
var keysIn_default = keysIn;
|
|
|
|
// node_modules/lodash-es/assignIn.js
|
|
var assignIn = createAssigner_default(function(object4, source) {
|
|
copyObject_default(source, keysIn_default(source), object4);
|
|
});
|
|
var assignIn_default = assignIn;
|
|
|
|
// node_modules/lodash-es/assignInWith.js
|
|
var assignInWith = createAssigner_default(function(object4, source, srcIndex, customizer) {
|
|
copyObject_default(source, keysIn_default(source), object4, customizer);
|
|
});
|
|
var assignInWith_default = assignInWith;
|
|
|
|
// node_modules/lodash-es/assignWith.js
|
|
var assignWith = createAssigner_default(function(object4, source, srcIndex, customizer) {
|
|
copyObject_default(source, keys_default(source), object4, customizer);
|
|
});
|
|
var assignWith_default = assignWith;
|
|
|
|
// node_modules/lodash-es/_isKey.js
|
|
var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
|
|
var reIsPlainProp = /^\w*$/;
|
|
function isKey(value, object4) {
|
|
if (isArray_default(value)) {
|
|
return false;
|
|
}
|
|
var type4 = typeof value;
|
|
if (type4 == "number" || type4 == "symbol" || type4 == "boolean" || value == null || isSymbol_default(value)) {
|
|
return true;
|
|
}
|
|
return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object4 != null && value in Object(object4);
|
|
}
|
|
var isKey_default = isKey;
|
|
|
|
// node_modules/lodash-es/_nativeCreate.js
|
|
var nativeCreate = getNative_default(Object, "create");
|
|
var nativeCreate_default = nativeCreate;
|
|
|
|
// node_modules/lodash-es/_hashClear.js
|
|
function hashClear() {
|
|
this.__data__ = nativeCreate_default ? nativeCreate_default(null) : {};
|
|
this.size = 0;
|
|
}
|
|
var hashClear_default = hashClear;
|
|
|
|
// node_modules/lodash-es/_hashDelete.js
|
|
function hashDelete(key) {
|
|
var result2 = this.has(key) && delete this.__data__[key];
|
|
this.size -= result2 ? 1 : 0;
|
|
return result2;
|
|
}
|
|
var hashDelete_default = hashDelete;
|
|
|
|
// node_modules/lodash-es/_hashGet.js
|
|
var HASH_UNDEFINED = "__lodash_hash_undefined__";
|
|
var objectProto13 = Object.prototype;
|
|
var hasOwnProperty11 = objectProto13.hasOwnProperty;
|
|
function hashGet(key) {
|
|
var data = this.__data__;
|
|
if (nativeCreate_default) {
|
|
var result2 = data[key];
|
|
return result2 === HASH_UNDEFINED ? void 0 : result2;
|
|
}
|
|
return hasOwnProperty11.call(data, key) ? data[key] : void 0;
|
|
}
|
|
var hashGet_default = hashGet;
|
|
|
|
// node_modules/lodash-es/_hashHas.js
|
|
var objectProto14 = Object.prototype;
|
|
var hasOwnProperty12 = objectProto14.hasOwnProperty;
|
|
function hashHas(key) {
|
|
var data = this.__data__;
|
|
return nativeCreate_default ? data[key] !== void 0 : hasOwnProperty12.call(data, key);
|
|
}
|
|
var hashHas_default = hashHas;
|
|
|
|
// node_modules/lodash-es/_hashSet.js
|
|
var HASH_UNDEFINED2 = "__lodash_hash_undefined__";
|
|
function hashSet(key, value) {
|
|
var data = this.__data__;
|
|
this.size += this.has(key) ? 0 : 1;
|
|
data[key] = nativeCreate_default && value === void 0 ? HASH_UNDEFINED2 : value;
|
|
return this;
|
|
}
|
|
var hashSet_default = hashSet;
|
|
|
|
// node_modules/lodash-es/_Hash.js
|
|
function Hash(entries) {
|
|
var index = -1, length = entries == null ? 0 : entries.length;
|
|
this.clear();
|
|
while (++index < length) {
|
|
var entry = entries[index];
|
|
this.set(entry[0], entry[1]);
|
|
}
|
|
}
|
|
Hash.prototype.clear = hashClear_default;
|
|
Hash.prototype["delete"] = hashDelete_default;
|
|
Hash.prototype.get = hashGet_default;
|
|
Hash.prototype.has = hashHas_default;
|
|
Hash.prototype.set = hashSet_default;
|
|
var Hash_default = Hash;
|
|
|
|
// node_modules/lodash-es/_listCacheClear.js
|
|
function listCacheClear() {
|
|
this.__data__ = [];
|
|
this.size = 0;
|
|
}
|
|
var listCacheClear_default = listCacheClear;
|
|
|
|
// node_modules/lodash-es/_assocIndexOf.js
|
|
function assocIndexOf(array4, key) {
|
|
var length = array4.length;
|
|
while (length--) {
|
|
if (eq_default(array4[length][0], key)) {
|
|
return length;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
var assocIndexOf_default = assocIndexOf;
|
|
|
|
// node_modules/lodash-es/_listCacheDelete.js
|
|
var arrayProto = Array.prototype;
|
|
var splice = arrayProto.splice;
|
|
function listCacheDelete(key) {
|
|
var data = this.__data__, index = assocIndexOf_default(data, key);
|
|
if (index < 0) {
|
|
return false;
|
|
}
|
|
var lastIndex = data.length - 1;
|
|
if (index == lastIndex) {
|
|
data.pop();
|
|
} else {
|
|
splice.call(data, index, 1);
|
|
}
|
|
--this.size;
|
|
return true;
|
|
}
|
|
var listCacheDelete_default = listCacheDelete;
|
|
|
|
// node_modules/lodash-es/_listCacheGet.js
|
|
function listCacheGet(key) {
|
|
var data = this.__data__, index = assocIndexOf_default(data, key);
|
|
return index < 0 ? void 0 : data[index][1];
|
|
}
|
|
var listCacheGet_default = listCacheGet;
|
|
|
|
// node_modules/lodash-es/_listCacheHas.js
|
|
function listCacheHas(key) {
|
|
return assocIndexOf_default(this.__data__, key) > -1;
|
|
}
|
|
var listCacheHas_default = listCacheHas;
|
|
|
|
// node_modules/lodash-es/_listCacheSet.js
|
|
function listCacheSet(key, value) {
|
|
var data = this.__data__, index = assocIndexOf_default(data, key);
|
|
if (index < 0) {
|
|
++this.size;
|
|
data.push([key, value]);
|
|
} else {
|
|
data[index][1] = value;
|
|
}
|
|
return this;
|
|
}
|
|
var listCacheSet_default = listCacheSet;
|
|
|
|
// node_modules/lodash-es/_ListCache.js
|
|
function ListCache(entries) {
|
|
var index = -1, length = entries == null ? 0 : entries.length;
|
|
this.clear();
|
|
while (++index < length) {
|
|
var entry = entries[index];
|
|
this.set(entry[0], entry[1]);
|
|
}
|
|
}
|
|
ListCache.prototype.clear = listCacheClear_default;
|
|
ListCache.prototype["delete"] = listCacheDelete_default;
|
|
ListCache.prototype.get = listCacheGet_default;
|
|
ListCache.prototype.has = listCacheHas_default;
|
|
ListCache.prototype.set = listCacheSet_default;
|
|
var ListCache_default = ListCache;
|
|
|
|
// node_modules/lodash-es/_Map.js
|
|
var Map2 = getNative_default(root_default, "Map");
|
|
var Map_default = Map2;
|
|
|
|
// node_modules/lodash-es/_mapCacheClear.js
|
|
function mapCacheClear() {
|
|
this.size = 0;
|
|
this.__data__ = {
|
|
"hash": new Hash_default(),
|
|
"map": new (Map_default || ListCache_default)(),
|
|
"string": new Hash_default()
|
|
};
|
|
}
|
|
var mapCacheClear_default = mapCacheClear;
|
|
|
|
// node_modules/lodash-es/_isKeyable.js
|
|
function isKeyable(value) {
|
|
var type4 = typeof value;
|
|
return type4 == "string" || type4 == "number" || type4 == "symbol" || type4 == "boolean" ? value !== "__proto__" : value === null;
|
|
}
|
|
var isKeyable_default = isKeyable;
|
|
|
|
// node_modules/lodash-es/_getMapData.js
|
|
function getMapData(map2, key) {
|
|
var data = map2.__data__;
|
|
return isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
|
|
}
|
|
var getMapData_default = getMapData;
|
|
|
|
// node_modules/lodash-es/_mapCacheDelete.js
|
|
function mapCacheDelete(key) {
|
|
var result2 = getMapData_default(this, key)["delete"](key);
|
|
this.size -= result2 ? 1 : 0;
|
|
return result2;
|
|
}
|
|
var mapCacheDelete_default = mapCacheDelete;
|
|
|
|
// node_modules/lodash-es/_mapCacheGet.js
|
|
function mapCacheGet(key) {
|
|
return getMapData_default(this, key).get(key);
|
|
}
|
|
var mapCacheGet_default = mapCacheGet;
|
|
|
|
// node_modules/lodash-es/_mapCacheHas.js
|
|
function mapCacheHas(key) {
|
|
return getMapData_default(this, key).has(key);
|
|
}
|
|
var mapCacheHas_default = mapCacheHas;
|
|
|
|
// node_modules/lodash-es/_mapCacheSet.js
|
|
function mapCacheSet(key, value) {
|
|
var data = getMapData_default(this, key), size3 = data.size;
|
|
data.set(key, value);
|
|
this.size += data.size == size3 ? 0 : 1;
|
|
return this;
|
|
}
|
|
var mapCacheSet_default = mapCacheSet;
|
|
|
|
// node_modules/lodash-es/_MapCache.js
|
|
function MapCache(entries) {
|
|
var index = -1, length = entries == null ? 0 : entries.length;
|
|
this.clear();
|
|
while (++index < length) {
|
|
var entry = entries[index];
|
|
this.set(entry[0], entry[1]);
|
|
}
|
|
}
|
|
MapCache.prototype.clear = mapCacheClear_default;
|
|
MapCache.prototype["delete"] = mapCacheDelete_default;
|
|
MapCache.prototype.get = mapCacheGet_default;
|
|
MapCache.prototype.has = mapCacheHas_default;
|
|
MapCache.prototype.set = mapCacheSet_default;
|
|
var MapCache_default = MapCache;
|
|
|
|
// node_modules/lodash-es/memoize.js
|
|
var FUNC_ERROR_TEXT3 = "Expected a function";
|
|
function memoize(func, resolver) {
|
|
if (typeof func != "function" || resolver != null && typeof resolver != "function") {
|
|
throw new TypeError(FUNC_ERROR_TEXT3);
|
|
}
|
|
var memoized = function() {
|
|
var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache2 = memoized.cache;
|
|
if (cache2.has(key)) {
|
|
return cache2.get(key);
|
|
}
|
|
var result2 = func.apply(this, args);
|
|
memoized.cache = cache2.set(key, result2) || cache2;
|
|
return result2;
|
|
};
|
|
memoized.cache = new (memoize.Cache || MapCache_default)();
|
|
return memoized;
|
|
}
|
|
memoize.Cache = MapCache_default;
|
|
var memoize_default = memoize;
|
|
|
|
// node_modules/lodash-es/_memoizeCapped.js
|
|
var MAX_MEMOIZE_SIZE = 500;
|
|
function memoizeCapped(func) {
|
|
var result2 = memoize_default(func, function(key) {
|
|
if (cache2.size === MAX_MEMOIZE_SIZE) {
|
|
cache2.clear();
|
|
}
|
|
return key;
|
|
});
|
|
var cache2 = result2.cache;
|
|
return result2;
|
|
}
|
|
var memoizeCapped_default = memoizeCapped;
|
|
|
|
// node_modules/lodash-es/_stringToPath.js
|
|
var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
|
|
var reEscapeChar = /\\(\\)?/g;
|
|
var stringToPath = memoizeCapped_default(function(string3) {
|
|
var result2 = [];
|
|
if (string3.charCodeAt(0) === 46) {
|
|
result2.push("");
|
|
}
|
|
string3.replace(rePropName, function(match, number4, quote, subString) {
|
|
result2.push(quote ? subString.replace(reEscapeChar, "$1") : number4 || match);
|
|
});
|
|
return result2;
|
|
});
|
|
var stringToPath_default = stringToPath;
|
|
|
|
// node_modules/lodash-es/toString.js
|
|
function toString(value) {
|
|
return value == null ? "" : baseToString_default(value);
|
|
}
|
|
var toString_default = toString;
|
|
|
|
// node_modules/lodash-es/_castPath.js
|
|
function castPath(value, object4) {
|
|
if (isArray_default(value)) {
|
|
return value;
|
|
}
|
|
return isKey_default(value, object4) ? [value] : stringToPath_default(toString_default(value));
|
|
}
|
|
var castPath_default = castPath;
|
|
|
|
// node_modules/lodash-es/_toKey.js
|
|
var INFINITY3 = 1 / 0;
|
|
function toKey(value) {
|
|
if (typeof value == "string" || isSymbol_default(value)) {
|
|
return value;
|
|
}
|
|
var result2 = value + "";
|
|
return result2 == "0" && 1 / value == -INFINITY3 ? "-0" : result2;
|
|
}
|
|
var toKey_default = toKey;
|
|
|
|
// node_modules/lodash-es/_baseGet.js
|
|
function baseGet(object4, path) {
|
|
path = castPath_default(path, object4);
|
|
var index = 0, length = path.length;
|
|
while (object4 != null && index < length) {
|
|
object4 = object4[toKey_default(path[index++])];
|
|
}
|
|
return index && index == length ? object4 : void 0;
|
|
}
|
|
var baseGet_default = baseGet;
|
|
|
|
// node_modules/lodash-es/get.js
|
|
function get(object4, path, defaultValue) {
|
|
var result2 = object4 == null ? void 0 : baseGet_default(object4, path);
|
|
return result2 === void 0 ? defaultValue : result2;
|
|
}
|
|
var get_default = get;
|
|
|
|
// node_modules/lodash-es/_baseAt.js
|
|
function baseAt(object4, paths) {
|
|
var index = -1, length = paths.length, result2 = Array(length), skip = object4 == null;
|
|
while (++index < length) {
|
|
result2[index] = skip ? void 0 : get_default(object4, paths[index]);
|
|
}
|
|
return result2;
|
|
}
|
|
var baseAt_default = baseAt;
|
|
|
|
// node_modules/lodash-es/_arrayPush.js
|
|
function arrayPush(array4, values2) {
|
|
var index = -1, length = values2.length, offset3 = array4.length;
|
|
while (++index < length) {
|
|
array4[offset3 + index] = values2[index];
|
|
}
|
|
return array4;
|
|
}
|
|
var arrayPush_default = arrayPush;
|
|
|
|
// node_modules/lodash-es/_isFlattenable.js
|
|
var spreadableSymbol = Symbol_default ? Symbol_default.isConcatSpreadable : void 0;
|
|
function isFlattenable(value) {
|
|
return isArray_default(value) || isArguments_default(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
|
|
}
|
|
var isFlattenable_default = isFlattenable;
|
|
|
|
// node_modules/lodash-es/_baseFlatten.js
|
|
function baseFlatten(array4, depth, predicate, isStrict, result2) {
|
|
var index = -1, length = array4.length;
|
|
predicate || (predicate = isFlattenable_default);
|
|
result2 || (result2 = []);
|
|
while (++index < length) {
|
|
var value = array4[index];
|
|
if (depth > 0 && predicate(value)) {
|
|
if (depth > 1) {
|
|
baseFlatten(value, depth - 1, predicate, isStrict, result2);
|
|
} else {
|
|
arrayPush_default(result2, value);
|
|
}
|
|
} else if (!isStrict) {
|
|
result2[result2.length] = value;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var baseFlatten_default = baseFlatten;
|
|
|
|
// node_modules/lodash-es/flatten.js
|
|
function flatten(array4) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
return length ? baseFlatten_default(array4, 1) : [];
|
|
}
|
|
var flatten_default = flatten;
|
|
|
|
// node_modules/lodash-es/_flatRest.js
|
|
function flatRest(func) {
|
|
return setToString_default(overRest_default(func, void 0, flatten_default), func + "");
|
|
}
|
|
var flatRest_default = flatRest;
|
|
|
|
// node_modules/lodash-es/at.js
|
|
var at = flatRest_default(baseAt_default);
|
|
var at_default = at;
|
|
|
|
// node_modules/lodash-es/_getPrototype.js
|
|
var getPrototype = overArg_default(Object.getPrototypeOf, Object);
|
|
var getPrototype_default = getPrototype;
|
|
|
|
// node_modules/lodash-es/isPlainObject.js
|
|
var objectTag2 = "[object Object]";
|
|
var funcProto3 = Function.prototype;
|
|
var objectProto15 = Object.prototype;
|
|
var funcToString3 = funcProto3.toString;
|
|
var hasOwnProperty13 = objectProto15.hasOwnProperty;
|
|
var objectCtorString = funcToString3.call(Object);
|
|
function isPlainObject2(value) {
|
|
if (!isObjectLike_default(value) || baseGetTag_default(value) != objectTag2) {
|
|
return false;
|
|
}
|
|
var proto = getPrototype_default(value);
|
|
if (proto === null) {
|
|
return true;
|
|
}
|
|
var Ctor = hasOwnProperty13.call(proto, "constructor") && proto.constructor;
|
|
return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString3.call(Ctor) == objectCtorString;
|
|
}
|
|
var isPlainObject_default = isPlainObject2;
|
|
|
|
// node_modules/lodash-es/isError.js
|
|
var domExcTag = "[object DOMException]";
|
|
var errorTag2 = "[object Error]";
|
|
function isError(value) {
|
|
if (!isObjectLike_default(value)) {
|
|
return false;
|
|
}
|
|
var tag = baseGetTag_default(value);
|
|
return tag == errorTag2 || tag == domExcTag || typeof value.message == "string" && typeof value.name == "string" && !isPlainObject_default(value);
|
|
}
|
|
var isError_default = isError;
|
|
|
|
// node_modules/lodash-es/attempt.js
|
|
var attempt = baseRest_default(function(func, args) {
|
|
try {
|
|
return apply_default(func, void 0, args);
|
|
} catch (e) {
|
|
return isError_default(e) ? e : new Error(e);
|
|
}
|
|
});
|
|
var attempt_default = attempt;
|
|
|
|
// node_modules/lodash-es/before.js
|
|
var FUNC_ERROR_TEXT4 = "Expected a function";
|
|
function before(n, func) {
|
|
var result2;
|
|
if (typeof func != "function") {
|
|
throw new TypeError(FUNC_ERROR_TEXT4);
|
|
}
|
|
n = toInteger_default(n);
|
|
return function() {
|
|
if (--n > 0) {
|
|
result2 = func.apply(this, arguments);
|
|
}
|
|
if (n <= 1) {
|
|
func = void 0;
|
|
}
|
|
return result2;
|
|
};
|
|
}
|
|
var before_default = before;
|
|
|
|
// node_modules/lodash-es/bind.js
|
|
var WRAP_BIND_FLAG8 = 1;
|
|
var WRAP_PARTIAL_FLAG4 = 32;
|
|
var bind = baseRest_default(function(func, thisArg, partials) {
|
|
var bitmask = WRAP_BIND_FLAG8;
|
|
if (partials.length) {
|
|
var holders = replaceHolders_default(partials, getHolder_default(bind));
|
|
bitmask |= WRAP_PARTIAL_FLAG4;
|
|
}
|
|
return createWrap_default(func, bitmask, thisArg, partials, holders);
|
|
});
|
|
bind.placeholder = {};
|
|
var bind_default = bind;
|
|
|
|
// node_modules/lodash-es/bindAll.js
|
|
var bindAll = flatRest_default(function(object4, methodNames) {
|
|
arrayEach_default(methodNames, function(key) {
|
|
key = toKey_default(key);
|
|
baseAssignValue_default(object4, key, bind_default(object4[key], object4));
|
|
});
|
|
return object4;
|
|
});
|
|
var bindAll_default = bindAll;
|
|
|
|
// node_modules/lodash-es/bindKey.js
|
|
var WRAP_BIND_FLAG9 = 1;
|
|
var WRAP_BIND_KEY_FLAG6 = 2;
|
|
var WRAP_PARTIAL_FLAG5 = 32;
|
|
var bindKey = baseRest_default(function(object4, key, partials) {
|
|
var bitmask = WRAP_BIND_FLAG9 | WRAP_BIND_KEY_FLAG6;
|
|
if (partials.length) {
|
|
var holders = replaceHolders_default(partials, getHolder_default(bindKey));
|
|
bitmask |= WRAP_PARTIAL_FLAG5;
|
|
}
|
|
return createWrap_default(key, bitmask, object4, partials, holders);
|
|
});
|
|
bindKey.placeholder = {};
|
|
var bindKey_default = bindKey;
|
|
|
|
// node_modules/lodash-es/_baseSlice.js
|
|
function baseSlice(array4, start, end) {
|
|
var index = -1, length = array4.length;
|
|
if (start < 0) {
|
|
start = -start > length ? 0 : length + start;
|
|
}
|
|
end = end > length ? length : end;
|
|
if (end < 0) {
|
|
end += length;
|
|
}
|
|
length = start > end ? 0 : end - start >>> 0;
|
|
start >>>= 0;
|
|
var result2 = Array(length);
|
|
while (++index < length) {
|
|
result2[index] = array4[index + start];
|
|
}
|
|
return result2;
|
|
}
|
|
var baseSlice_default = baseSlice;
|
|
|
|
// node_modules/lodash-es/_castSlice.js
|
|
function castSlice(array4, start, end) {
|
|
var length = array4.length;
|
|
end = end === void 0 ? length : end;
|
|
return !start && end >= length ? array4 : baseSlice_default(array4, start, end);
|
|
}
|
|
var castSlice_default = castSlice;
|
|
|
|
// node_modules/lodash-es/_hasUnicode.js
|
|
var rsAstralRange = "\\ud800-\\udfff";
|
|
var rsComboMarksRange = "\\u0300-\\u036f";
|
|
var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
|
|
var rsComboSymbolsRange = "\\u20d0-\\u20ff";
|
|
var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
|
|
var rsVarRange = "\\ufe0e\\ufe0f";
|
|
var rsZWJ = "\\u200d";
|
|
var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]");
|
|
function hasUnicode(string3) {
|
|
return reHasUnicode.test(string3);
|
|
}
|
|
var hasUnicode_default = hasUnicode;
|
|
|
|
// node_modules/lodash-es/_asciiToArray.js
|
|
function asciiToArray(string3) {
|
|
return string3.split("");
|
|
}
|
|
var asciiToArray_default = asciiToArray;
|
|
|
|
// node_modules/lodash-es/_unicodeToArray.js
|
|
var rsAstralRange2 = "\\ud800-\\udfff";
|
|
var rsComboMarksRange2 = "\\u0300-\\u036f";
|
|
var reComboHalfMarksRange2 = "\\ufe20-\\ufe2f";
|
|
var rsComboSymbolsRange2 = "\\u20d0-\\u20ff";
|
|
var rsComboRange2 = rsComboMarksRange2 + reComboHalfMarksRange2 + rsComboSymbolsRange2;
|
|
var rsVarRange2 = "\\ufe0e\\ufe0f";
|
|
var rsAstral = "[" + rsAstralRange2 + "]";
|
|
var rsCombo = "[" + rsComboRange2 + "]";
|
|
var rsFitz = "\\ud83c[\\udffb-\\udfff]";
|
|
var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
|
|
var rsNonAstral = "[^" + rsAstralRange2 + "]";
|
|
var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
|
|
var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
|
|
var rsZWJ2 = "\\u200d";
|
|
var reOptMod = rsModifier + "?";
|
|
var rsOptVar = "[" + rsVarRange2 + "]?";
|
|
var rsOptJoin = "(?:" + rsZWJ2 + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
|
|
var rsSeq = rsOptVar + reOptMod + rsOptJoin;
|
|
var rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
|
|
var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
|
|
function unicodeToArray(string3) {
|
|
return string3.match(reUnicode) || [];
|
|
}
|
|
var unicodeToArray_default = unicodeToArray;
|
|
|
|
// node_modules/lodash-es/_stringToArray.js
|
|
function stringToArray(string3) {
|
|
return hasUnicode_default(string3) ? unicodeToArray_default(string3) : asciiToArray_default(string3);
|
|
}
|
|
var stringToArray_default = stringToArray;
|
|
|
|
// node_modules/lodash-es/_createCaseFirst.js
|
|
function createCaseFirst(methodName) {
|
|
return function(string3) {
|
|
string3 = toString_default(string3);
|
|
var strSymbols = hasUnicode_default(string3) ? stringToArray_default(string3) : void 0;
|
|
var chr = strSymbols ? strSymbols[0] : string3.charAt(0);
|
|
var trailing = strSymbols ? castSlice_default(strSymbols, 1).join("") : string3.slice(1);
|
|
return chr[methodName]() + trailing;
|
|
};
|
|
}
|
|
var createCaseFirst_default = createCaseFirst;
|
|
|
|
// node_modules/lodash-es/upperFirst.js
|
|
var upperFirst = createCaseFirst_default("toUpperCase");
|
|
var upperFirst_default = upperFirst;
|
|
|
|
// node_modules/lodash-es/capitalize.js
|
|
function capitalize2(string3) {
|
|
return upperFirst_default(toString_default(string3).toLowerCase());
|
|
}
|
|
var capitalize_default = capitalize2;
|
|
|
|
// node_modules/lodash-es/_arrayReduce.js
|
|
function arrayReduce(array4, iteratee2, accumulator, initAccum) {
|
|
var index = -1, length = array4 == null ? 0 : array4.length;
|
|
if (initAccum && length) {
|
|
accumulator = array4[++index];
|
|
}
|
|
while (++index < length) {
|
|
accumulator = iteratee2(accumulator, array4[index], index, array4);
|
|
}
|
|
return accumulator;
|
|
}
|
|
var arrayReduce_default = arrayReduce;
|
|
|
|
// node_modules/lodash-es/_basePropertyOf.js
|
|
function basePropertyOf(object4) {
|
|
return function(key) {
|
|
return object4 == null ? void 0 : object4[key];
|
|
};
|
|
}
|
|
var basePropertyOf_default = basePropertyOf;
|
|
|
|
// node_modules/lodash-es/_deburrLetter.js
|
|
var deburredLetters = {
|
|
"\xC0": "A",
|
|
"\xC1": "A",
|
|
"\xC2": "A",
|
|
"\xC3": "A",
|
|
"\xC4": "A",
|
|
"\xC5": "A",
|
|
"\xE0": "a",
|
|
"\xE1": "a",
|
|
"\xE2": "a",
|
|
"\xE3": "a",
|
|
"\xE4": "a",
|
|
"\xE5": "a",
|
|
"\xC7": "C",
|
|
"\xE7": "c",
|
|
"\xD0": "D",
|
|
"\xF0": "d",
|
|
"\xC8": "E",
|
|
"\xC9": "E",
|
|
"\xCA": "E",
|
|
"\xCB": "E",
|
|
"\xE8": "e",
|
|
"\xE9": "e",
|
|
"\xEA": "e",
|
|
"\xEB": "e",
|
|
"\xCC": "I",
|
|
"\xCD": "I",
|
|
"\xCE": "I",
|
|
"\xCF": "I",
|
|
"\xEC": "i",
|
|
"\xED": "i",
|
|
"\xEE": "i",
|
|
"\xEF": "i",
|
|
"\xD1": "N",
|
|
"\xF1": "n",
|
|
"\xD2": "O",
|
|
"\xD3": "O",
|
|
"\xD4": "O",
|
|
"\xD5": "O",
|
|
"\xD6": "O",
|
|
"\xD8": "O",
|
|
"\xF2": "o",
|
|
"\xF3": "o",
|
|
"\xF4": "o",
|
|
"\xF5": "o",
|
|
"\xF6": "o",
|
|
"\xF8": "o",
|
|
"\xD9": "U",
|
|
"\xDA": "U",
|
|
"\xDB": "U",
|
|
"\xDC": "U",
|
|
"\xF9": "u",
|
|
"\xFA": "u",
|
|
"\xFB": "u",
|
|
"\xFC": "u",
|
|
"\xDD": "Y",
|
|
"\xFD": "y",
|
|
"\xFF": "y",
|
|
"\xC6": "Ae",
|
|
"\xE6": "ae",
|
|
"\xDE": "Th",
|
|
"\xFE": "th",
|
|
"\xDF": "ss",
|
|
"\u0100": "A",
|
|
"\u0102": "A",
|
|
"\u0104": "A",
|
|
"\u0101": "a",
|
|
"\u0103": "a",
|
|
"\u0105": "a",
|
|
"\u0106": "C",
|
|
"\u0108": "C",
|
|
"\u010A": "C",
|
|
"\u010C": "C",
|
|
"\u0107": "c",
|
|
"\u0109": "c",
|
|
"\u010B": "c",
|
|
"\u010D": "c",
|
|
"\u010E": "D",
|
|
"\u0110": "D",
|
|
"\u010F": "d",
|
|
"\u0111": "d",
|
|
"\u0112": "E",
|
|
"\u0114": "E",
|
|
"\u0116": "E",
|
|
"\u0118": "E",
|
|
"\u011A": "E",
|
|
"\u0113": "e",
|
|
"\u0115": "e",
|
|
"\u0117": "e",
|
|
"\u0119": "e",
|
|
"\u011B": "e",
|
|
"\u011C": "G",
|
|
"\u011E": "G",
|
|
"\u0120": "G",
|
|
"\u0122": "G",
|
|
"\u011D": "g",
|
|
"\u011F": "g",
|
|
"\u0121": "g",
|
|
"\u0123": "g",
|
|
"\u0124": "H",
|
|
"\u0126": "H",
|
|
"\u0125": "h",
|
|
"\u0127": "h",
|
|
"\u0128": "I",
|
|
"\u012A": "I",
|
|
"\u012C": "I",
|
|
"\u012E": "I",
|
|
"\u0130": "I",
|
|
"\u0129": "i",
|
|
"\u012B": "i",
|
|
"\u012D": "i",
|
|
"\u012F": "i",
|
|
"\u0131": "i",
|
|
"\u0134": "J",
|
|
"\u0135": "j",
|
|
"\u0136": "K",
|
|
"\u0137": "k",
|
|
"\u0138": "k",
|
|
"\u0139": "L",
|
|
"\u013B": "L",
|
|
"\u013D": "L",
|
|
"\u013F": "L",
|
|
"\u0141": "L",
|
|
"\u013A": "l",
|
|
"\u013C": "l",
|
|
"\u013E": "l",
|
|
"\u0140": "l",
|
|
"\u0142": "l",
|
|
"\u0143": "N",
|
|
"\u0145": "N",
|
|
"\u0147": "N",
|
|
"\u014A": "N",
|
|
"\u0144": "n",
|
|
"\u0146": "n",
|
|
"\u0148": "n",
|
|
"\u014B": "n",
|
|
"\u014C": "O",
|
|
"\u014E": "O",
|
|
"\u0150": "O",
|
|
"\u014D": "o",
|
|
"\u014F": "o",
|
|
"\u0151": "o",
|
|
"\u0154": "R",
|
|
"\u0156": "R",
|
|
"\u0158": "R",
|
|
"\u0155": "r",
|
|
"\u0157": "r",
|
|
"\u0159": "r",
|
|
"\u015A": "S",
|
|
"\u015C": "S",
|
|
"\u015E": "S",
|
|
"\u0160": "S",
|
|
"\u015B": "s",
|
|
"\u015D": "s",
|
|
"\u015F": "s",
|
|
"\u0161": "s",
|
|
"\u0162": "T",
|
|
"\u0164": "T",
|
|
"\u0166": "T",
|
|
"\u0163": "t",
|
|
"\u0165": "t",
|
|
"\u0167": "t",
|
|
"\u0168": "U",
|
|
"\u016A": "U",
|
|
"\u016C": "U",
|
|
"\u016E": "U",
|
|
"\u0170": "U",
|
|
"\u0172": "U",
|
|
"\u0169": "u",
|
|
"\u016B": "u",
|
|
"\u016D": "u",
|
|
"\u016F": "u",
|
|
"\u0171": "u",
|
|
"\u0173": "u",
|
|
"\u0174": "W",
|
|
"\u0175": "w",
|
|
"\u0176": "Y",
|
|
"\u0177": "y",
|
|
"\u0178": "Y",
|
|
"\u0179": "Z",
|
|
"\u017B": "Z",
|
|
"\u017D": "Z",
|
|
"\u017A": "z",
|
|
"\u017C": "z",
|
|
"\u017E": "z",
|
|
"\u0132": "IJ",
|
|
"\u0133": "ij",
|
|
"\u0152": "Oe",
|
|
"\u0153": "oe",
|
|
"\u0149": "'n",
|
|
"\u017F": "s"
|
|
};
|
|
var deburrLetter = basePropertyOf_default(deburredLetters);
|
|
var deburrLetter_default = deburrLetter;
|
|
|
|
// node_modules/lodash-es/deburr.js
|
|
var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
|
|
var rsComboMarksRange3 = "\\u0300-\\u036f";
|
|
var reComboHalfMarksRange3 = "\\ufe20-\\ufe2f";
|
|
var rsComboSymbolsRange3 = "\\u20d0-\\u20ff";
|
|
var rsComboRange3 = rsComboMarksRange3 + reComboHalfMarksRange3 + rsComboSymbolsRange3;
|
|
var rsCombo2 = "[" + rsComboRange3 + "]";
|
|
var reComboMark = RegExp(rsCombo2, "g");
|
|
function deburr(string3) {
|
|
string3 = toString_default(string3);
|
|
return string3 && string3.replace(reLatin, deburrLetter_default).replace(reComboMark, "");
|
|
}
|
|
var deburr_default = deburr;
|
|
|
|
// node_modules/lodash-es/_asciiWords.js
|
|
var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
|
|
function asciiWords(string3) {
|
|
return string3.match(reAsciiWord) || [];
|
|
}
|
|
var asciiWords_default = asciiWords;
|
|
|
|
// node_modules/lodash-es/_hasUnicodeWord.js
|
|
var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
|
|
function hasUnicodeWord(string3) {
|
|
return reHasUnicodeWord.test(string3);
|
|
}
|
|
var hasUnicodeWord_default = hasUnicodeWord;
|
|
|
|
// node_modules/lodash-es/_unicodeWords.js
|
|
var rsAstralRange3 = "\\ud800-\\udfff";
|
|
var rsComboMarksRange4 = "\\u0300-\\u036f";
|
|
var reComboHalfMarksRange4 = "\\ufe20-\\ufe2f";
|
|
var rsComboSymbolsRange4 = "\\u20d0-\\u20ff";
|
|
var rsComboRange4 = rsComboMarksRange4 + reComboHalfMarksRange4 + rsComboSymbolsRange4;
|
|
var rsDingbatRange = "\\u2700-\\u27bf";
|
|
var rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff";
|
|
var rsMathOpRange = "\\xac\\xb1\\xd7\\xf7";
|
|
var rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf";
|
|
var rsPunctuationRange = "\\u2000-\\u206f";
|
|
var rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000";
|
|
var rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde";
|
|
var rsVarRange3 = "\\ufe0e\\ufe0f";
|
|
var rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
|
|
var rsApos = "['\u2019]";
|
|
var rsBreak = "[" + rsBreakRange + "]";
|
|
var rsCombo3 = "[" + rsComboRange4 + "]";
|
|
var rsDigits = "\\d+";
|
|
var rsDingbat = "[" + rsDingbatRange + "]";
|
|
var rsLower = "[" + rsLowerRange + "]";
|
|
var rsMisc = "[^" + rsAstralRange3 + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]";
|
|
var rsFitz2 = "\\ud83c[\\udffb-\\udfff]";
|
|
var rsModifier2 = "(?:" + rsCombo3 + "|" + rsFitz2 + ")";
|
|
var rsNonAstral2 = "[^" + rsAstralRange3 + "]";
|
|
var rsRegional2 = "(?:\\ud83c[\\udde6-\\uddff]){2}";
|
|
var rsSurrPair2 = "[\\ud800-\\udbff][\\udc00-\\udfff]";
|
|
var rsUpper = "[" + rsUpperRange + "]";
|
|
var rsZWJ3 = "\\u200d";
|
|
var rsMiscLower = "(?:" + rsLower + "|" + rsMisc + ")";
|
|
var rsMiscUpper = "(?:" + rsUpper + "|" + rsMisc + ")";
|
|
var rsOptContrLower = "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?";
|
|
var rsOptContrUpper = "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?";
|
|
var reOptMod2 = rsModifier2 + "?";
|
|
var rsOptVar2 = "[" + rsVarRange3 + "]?";
|
|
var rsOptJoin2 = "(?:" + rsZWJ3 + "(?:" + [rsNonAstral2, rsRegional2, rsSurrPair2].join("|") + ")" + rsOptVar2 + reOptMod2 + ")*";
|
|
var rsOrdLower = "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])";
|
|
var rsOrdUpper = "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])";
|
|
var rsSeq2 = rsOptVar2 + reOptMod2 + rsOptJoin2;
|
|
var rsEmoji = "(?:" + [rsDingbat, rsRegional2, rsSurrPair2].join("|") + ")" + rsSeq2;
|
|
var reUnicodeWord = RegExp([
|
|
rsUpper + "?" + rsLower + "+" + rsOptContrLower + "(?=" + [rsBreak, rsUpper, "$"].join("|") + ")",
|
|
rsMiscUpper + "+" + rsOptContrUpper + "(?=" + [rsBreak, rsUpper + rsMiscLower, "$"].join("|") + ")",
|
|
rsUpper + "?" + rsMiscLower + "+" + rsOptContrLower,
|
|
rsUpper + "+" + rsOptContrUpper,
|
|
rsOrdUpper,
|
|
rsOrdLower,
|
|
rsDigits,
|
|
rsEmoji
|
|
].join("|"), "g");
|
|
function unicodeWords(string3) {
|
|
return string3.match(reUnicodeWord) || [];
|
|
}
|
|
var unicodeWords_default = unicodeWords;
|
|
|
|
// node_modules/lodash-es/words.js
|
|
function words(string3, pattern4, guard) {
|
|
string3 = toString_default(string3);
|
|
pattern4 = guard ? void 0 : pattern4;
|
|
if (pattern4 === void 0) {
|
|
return hasUnicodeWord_default(string3) ? unicodeWords_default(string3) : asciiWords_default(string3);
|
|
}
|
|
return string3.match(pattern4) || [];
|
|
}
|
|
var words_default = words;
|
|
|
|
// node_modules/lodash-es/_createCompounder.js
|
|
var rsApos2 = "['\u2019]";
|
|
var reApos = RegExp(rsApos2, "g");
|
|
function createCompounder(callback) {
|
|
return function(string3) {
|
|
return arrayReduce_default(words_default(deburr_default(string3).replace(reApos, "")), callback, "");
|
|
};
|
|
}
|
|
var createCompounder_default = createCompounder;
|
|
|
|
// node_modules/lodash-es/camelCase.js
|
|
var camelCase = createCompounder_default(function(result2, word, index) {
|
|
word = word.toLowerCase();
|
|
return result2 + (index ? capitalize_default(word) : word);
|
|
});
|
|
var camelCase_default = camelCase;
|
|
|
|
// node_modules/lodash-es/castArray.js
|
|
function castArray() {
|
|
if (!arguments.length) {
|
|
return [];
|
|
}
|
|
var value = arguments[0];
|
|
return isArray_default(value) ? value : [value];
|
|
}
|
|
var castArray_default = castArray;
|
|
|
|
// node_modules/lodash-es/_createRound.js
|
|
var nativeIsFinite = root_default.isFinite;
|
|
var nativeMin3 = Math.min;
|
|
function createRound(methodName) {
|
|
var func = Math[methodName];
|
|
return function(number4, precision) {
|
|
number4 = toNumber_default(number4);
|
|
precision = precision == null ? 0 : nativeMin3(toInteger_default(precision), 292);
|
|
if (precision && nativeIsFinite(number4)) {
|
|
var pair = (toString_default(number4) + "e").split("e"), value = func(pair[0] + "e" + (+pair[1] + precision));
|
|
pair = (toString_default(value) + "e").split("e");
|
|
return +(pair[0] + "e" + (+pair[1] - precision));
|
|
}
|
|
return func(number4);
|
|
};
|
|
}
|
|
var createRound_default = createRound;
|
|
|
|
// node_modules/lodash-es/ceil.js
|
|
var ceil = createRound_default("ceil");
|
|
var ceil_default = ceil;
|
|
|
|
// node_modules/lodash-es/chain.js
|
|
function chain(value) {
|
|
var result2 = wrapperLodash_default(value);
|
|
result2.__chain__ = true;
|
|
return result2;
|
|
}
|
|
var chain_default = chain;
|
|
|
|
// node_modules/lodash-es/chunk.js
|
|
var nativeCeil = Math.ceil;
|
|
var nativeMax5 = Math.max;
|
|
function chunk(array4, size3, guard) {
|
|
if (guard ? isIterateeCall_default(array4, size3, guard) : size3 === void 0) {
|
|
size3 = 1;
|
|
} else {
|
|
size3 = nativeMax5(toInteger_default(size3), 0);
|
|
}
|
|
var length = array4 == null ? 0 : array4.length;
|
|
if (!length || size3 < 1) {
|
|
return [];
|
|
}
|
|
var index = 0, resIndex = 0, result2 = Array(nativeCeil(length / size3));
|
|
while (index < length) {
|
|
result2[resIndex++] = baseSlice_default(array4, index, index += size3);
|
|
}
|
|
return result2;
|
|
}
|
|
var chunk_default = chunk;
|
|
|
|
// node_modules/lodash-es/_baseClamp.js
|
|
function baseClamp(number4, lower, upper) {
|
|
if (number4 === number4) {
|
|
if (upper !== void 0) {
|
|
number4 = number4 <= upper ? number4 : upper;
|
|
}
|
|
if (lower !== void 0) {
|
|
number4 = number4 >= lower ? number4 : lower;
|
|
}
|
|
}
|
|
return number4;
|
|
}
|
|
var baseClamp_default = baseClamp;
|
|
|
|
// node_modules/lodash-es/clamp.js
|
|
function clamp(number4, lower, upper) {
|
|
if (upper === void 0) {
|
|
upper = lower;
|
|
lower = void 0;
|
|
}
|
|
if (upper !== void 0) {
|
|
upper = toNumber_default(upper);
|
|
upper = upper === upper ? upper : 0;
|
|
}
|
|
if (lower !== void 0) {
|
|
lower = toNumber_default(lower);
|
|
lower = lower === lower ? lower : 0;
|
|
}
|
|
return baseClamp_default(toNumber_default(number4), lower, upper);
|
|
}
|
|
var clamp_default = clamp;
|
|
|
|
// node_modules/lodash-es/_stackClear.js
|
|
function stackClear() {
|
|
this.__data__ = new ListCache_default();
|
|
this.size = 0;
|
|
}
|
|
var stackClear_default = stackClear;
|
|
|
|
// node_modules/lodash-es/_stackDelete.js
|
|
function stackDelete(key) {
|
|
var data = this.__data__, result2 = data["delete"](key);
|
|
this.size = data.size;
|
|
return result2;
|
|
}
|
|
var stackDelete_default = stackDelete;
|
|
|
|
// node_modules/lodash-es/_stackGet.js
|
|
function stackGet(key) {
|
|
return this.__data__.get(key);
|
|
}
|
|
var stackGet_default = stackGet;
|
|
|
|
// node_modules/lodash-es/_stackHas.js
|
|
function stackHas(key) {
|
|
return this.__data__.has(key);
|
|
}
|
|
var stackHas_default = stackHas;
|
|
|
|
// node_modules/lodash-es/_stackSet.js
|
|
var LARGE_ARRAY_SIZE = 200;
|
|
function stackSet(key, value) {
|
|
var data = this.__data__;
|
|
if (data instanceof ListCache_default) {
|
|
var pairs = data.__data__;
|
|
if (!Map_default || pairs.length < LARGE_ARRAY_SIZE - 1) {
|
|
pairs.push([key, value]);
|
|
this.size = ++data.size;
|
|
return this;
|
|
}
|
|
data = this.__data__ = new MapCache_default(pairs);
|
|
}
|
|
data.set(key, value);
|
|
this.size = data.size;
|
|
return this;
|
|
}
|
|
var stackSet_default = stackSet;
|
|
|
|
// node_modules/lodash-es/_Stack.js
|
|
function Stack(entries) {
|
|
var data = this.__data__ = new ListCache_default(entries);
|
|
this.size = data.size;
|
|
}
|
|
Stack.prototype.clear = stackClear_default;
|
|
Stack.prototype["delete"] = stackDelete_default;
|
|
Stack.prototype.get = stackGet_default;
|
|
Stack.prototype.has = stackHas_default;
|
|
Stack.prototype.set = stackSet_default;
|
|
var Stack_default = Stack;
|
|
|
|
// node_modules/lodash-es/_baseAssign.js
|
|
function baseAssign(object4, source) {
|
|
return object4 && copyObject_default(source, keys_default(source), object4);
|
|
}
|
|
var baseAssign_default = baseAssign;
|
|
|
|
// node_modules/lodash-es/_baseAssignIn.js
|
|
function baseAssignIn(object4, source) {
|
|
return object4 && copyObject_default(source, keysIn_default(source), object4);
|
|
}
|
|
var baseAssignIn_default = baseAssignIn;
|
|
|
|
// node_modules/lodash-es/_cloneBuffer.js
|
|
var freeExports3 = typeof exports == "object" && exports && !exports.nodeType && exports;
|
|
var freeModule3 = freeExports3 && typeof module == "object" && module && !module.nodeType && module;
|
|
var moduleExports3 = freeModule3 && freeModule3.exports === freeExports3;
|
|
var Buffer2 = moduleExports3 ? root_default.Buffer : void 0;
|
|
var allocUnsafe = Buffer2 ? Buffer2.allocUnsafe : void 0;
|
|
function cloneBuffer(buffer, isDeep) {
|
|
if (isDeep) {
|
|
return buffer.slice();
|
|
}
|
|
var length = buffer.length, result2 = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
|
|
buffer.copy(result2);
|
|
return result2;
|
|
}
|
|
var cloneBuffer_default = cloneBuffer;
|
|
|
|
// node_modules/lodash-es/_arrayFilter.js
|
|
function arrayFilter(array4, predicate) {
|
|
var index = -1, length = array4 == null ? 0 : array4.length, resIndex = 0, result2 = [];
|
|
while (++index < length) {
|
|
var value = array4[index];
|
|
if (predicate(value, index, array4)) {
|
|
result2[resIndex++] = value;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var arrayFilter_default = arrayFilter;
|
|
|
|
// node_modules/lodash-es/stubArray.js
|
|
function stubArray() {
|
|
return [];
|
|
}
|
|
var stubArray_default = stubArray;
|
|
|
|
// node_modules/lodash-es/_getSymbols.js
|
|
var objectProto16 = Object.prototype;
|
|
var propertyIsEnumerable2 = objectProto16.propertyIsEnumerable;
|
|
var nativeGetSymbols = Object.getOwnPropertySymbols;
|
|
var getSymbols = !nativeGetSymbols ? stubArray_default : function(object4) {
|
|
if (object4 == null) {
|
|
return [];
|
|
}
|
|
object4 = Object(object4);
|
|
return arrayFilter_default(nativeGetSymbols(object4), function(symbol) {
|
|
return propertyIsEnumerable2.call(object4, symbol);
|
|
});
|
|
};
|
|
var getSymbols_default = getSymbols;
|
|
|
|
// node_modules/lodash-es/_copySymbols.js
|
|
function copySymbols(source, object4) {
|
|
return copyObject_default(source, getSymbols_default(source), object4);
|
|
}
|
|
var copySymbols_default = copySymbols;
|
|
|
|
// node_modules/lodash-es/_getSymbolsIn.js
|
|
var nativeGetSymbols2 = Object.getOwnPropertySymbols;
|
|
var getSymbolsIn = !nativeGetSymbols2 ? stubArray_default : function(object4) {
|
|
var result2 = [];
|
|
while (object4) {
|
|
arrayPush_default(result2, getSymbols_default(object4));
|
|
object4 = getPrototype_default(object4);
|
|
}
|
|
return result2;
|
|
};
|
|
var getSymbolsIn_default = getSymbolsIn;
|
|
|
|
// node_modules/lodash-es/_copySymbolsIn.js
|
|
function copySymbolsIn(source, object4) {
|
|
return copyObject_default(source, getSymbolsIn_default(source), object4);
|
|
}
|
|
var copySymbolsIn_default = copySymbolsIn;
|
|
|
|
// node_modules/lodash-es/_baseGetAllKeys.js
|
|
function baseGetAllKeys(object4, keysFunc, symbolsFunc) {
|
|
var result2 = keysFunc(object4);
|
|
return isArray_default(object4) ? result2 : arrayPush_default(result2, symbolsFunc(object4));
|
|
}
|
|
var baseGetAllKeys_default = baseGetAllKeys;
|
|
|
|
// node_modules/lodash-es/_getAllKeys.js
|
|
function getAllKeys(object4) {
|
|
return baseGetAllKeys_default(object4, keys_default, getSymbols_default);
|
|
}
|
|
var getAllKeys_default = getAllKeys;
|
|
|
|
// node_modules/lodash-es/_getAllKeysIn.js
|
|
function getAllKeysIn(object4) {
|
|
return baseGetAllKeys_default(object4, keysIn_default, getSymbolsIn_default);
|
|
}
|
|
var getAllKeysIn_default = getAllKeysIn;
|
|
|
|
// node_modules/lodash-es/_DataView.js
|
|
var DataView = getNative_default(root_default, "DataView");
|
|
var DataView_default = DataView;
|
|
|
|
// node_modules/lodash-es/_Promise.js
|
|
var Promise2 = getNative_default(root_default, "Promise");
|
|
var Promise_default = Promise2;
|
|
|
|
// node_modules/lodash-es/_Set.js
|
|
var Set2 = getNative_default(root_default, "Set");
|
|
var Set_default = Set2;
|
|
|
|
// node_modules/lodash-es/_getTag.js
|
|
var mapTag2 = "[object Map]";
|
|
var objectTag3 = "[object Object]";
|
|
var promiseTag = "[object Promise]";
|
|
var setTag2 = "[object Set]";
|
|
var weakMapTag2 = "[object WeakMap]";
|
|
var dataViewTag2 = "[object DataView]";
|
|
var dataViewCtorString = toSource_default(DataView_default);
|
|
var mapCtorString = toSource_default(Map_default);
|
|
var promiseCtorString = toSource_default(Promise_default);
|
|
var setCtorString = toSource_default(Set_default);
|
|
var weakMapCtorString = toSource_default(WeakMap_default);
|
|
var getTag = baseGetTag_default;
|
|
if (DataView_default && getTag(new DataView_default(new ArrayBuffer(1))) != dataViewTag2 || Map_default && getTag(new Map_default()) != mapTag2 || Promise_default && getTag(Promise_default.resolve()) != promiseTag || Set_default && getTag(new Set_default()) != setTag2 || WeakMap_default && getTag(new WeakMap_default()) != weakMapTag2) {
|
|
getTag = function(value) {
|
|
var result2 = baseGetTag_default(value), Ctor = result2 == objectTag3 ? value.constructor : void 0, ctorString = Ctor ? toSource_default(Ctor) : "";
|
|
if (ctorString) {
|
|
switch (ctorString) {
|
|
case dataViewCtorString:
|
|
return dataViewTag2;
|
|
case mapCtorString:
|
|
return mapTag2;
|
|
case promiseCtorString:
|
|
return promiseTag;
|
|
case setCtorString:
|
|
return setTag2;
|
|
case weakMapCtorString:
|
|
return weakMapTag2;
|
|
}
|
|
}
|
|
return result2;
|
|
};
|
|
}
|
|
var getTag_default = getTag;
|
|
|
|
// node_modules/lodash-es/_initCloneArray.js
|
|
var objectProto17 = Object.prototype;
|
|
var hasOwnProperty14 = objectProto17.hasOwnProperty;
|
|
function initCloneArray(array4) {
|
|
var length = array4.length, result2 = new array4.constructor(length);
|
|
if (length && typeof array4[0] == "string" && hasOwnProperty14.call(array4, "index")) {
|
|
result2.index = array4.index;
|
|
result2.input = array4.input;
|
|
}
|
|
return result2;
|
|
}
|
|
var initCloneArray_default = initCloneArray;
|
|
|
|
// node_modules/lodash-es/_Uint8Array.js
|
|
var Uint8Array2 = root_default.Uint8Array;
|
|
var Uint8Array_default = Uint8Array2;
|
|
|
|
// node_modules/lodash-es/_cloneArrayBuffer.js
|
|
function cloneArrayBuffer(arrayBuffer) {
|
|
var result2 = new arrayBuffer.constructor(arrayBuffer.byteLength);
|
|
new Uint8Array_default(result2).set(new Uint8Array_default(arrayBuffer));
|
|
return result2;
|
|
}
|
|
var cloneArrayBuffer_default = cloneArrayBuffer;
|
|
|
|
// node_modules/lodash-es/_cloneDataView.js
|
|
function cloneDataView(dataView, isDeep) {
|
|
var buffer = isDeep ? cloneArrayBuffer_default(dataView.buffer) : dataView.buffer;
|
|
return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
|
|
}
|
|
var cloneDataView_default = cloneDataView;
|
|
|
|
// node_modules/lodash-es/_cloneRegExp.js
|
|
var reFlags = /\w*$/;
|
|
function cloneRegExp(regexp4) {
|
|
var result2 = new regexp4.constructor(regexp4.source, reFlags.exec(regexp4));
|
|
result2.lastIndex = regexp4.lastIndex;
|
|
return result2;
|
|
}
|
|
var cloneRegExp_default = cloneRegExp;
|
|
|
|
// node_modules/lodash-es/_cloneSymbol.js
|
|
var symbolProto2 = Symbol_default ? Symbol_default.prototype : void 0;
|
|
var symbolValueOf = symbolProto2 ? symbolProto2.valueOf : void 0;
|
|
function cloneSymbol(symbol) {
|
|
return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
|
|
}
|
|
var cloneSymbol_default = cloneSymbol;
|
|
|
|
// node_modules/lodash-es/_cloneTypedArray.js
|
|
function cloneTypedArray(typedArray, isDeep) {
|
|
var buffer = isDeep ? cloneArrayBuffer_default(typedArray.buffer) : typedArray.buffer;
|
|
return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
|
|
}
|
|
var cloneTypedArray_default = cloneTypedArray;
|
|
|
|
// node_modules/lodash-es/_initCloneByTag.js
|
|
var boolTag2 = "[object Boolean]";
|
|
var dateTag2 = "[object Date]";
|
|
var mapTag3 = "[object Map]";
|
|
var numberTag2 = "[object Number]";
|
|
var regexpTag2 = "[object RegExp]";
|
|
var setTag3 = "[object Set]";
|
|
var stringTag2 = "[object String]";
|
|
var symbolTag2 = "[object Symbol]";
|
|
var arrayBufferTag2 = "[object ArrayBuffer]";
|
|
var dataViewTag3 = "[object DataView]";
|
|
var float32Tag2 = "[object Float32Array]";
|
|
var float64Tag2 = "[object Float64Array]";
|
|
var int8Tag2 = "[object Int8Array]";
|
|
var int16Tag2 = "[object Int16Array]";
|
|
var int32Tag2 = "[object Int32Array]";
|
|
var uint8Tag2 = "[object Uint8Array]";
|
|
var uint8ClampedTag2 = "[object Uint8ClampedArray]";
|
|
var uint16Tag2 = "[object Uint16Array]";
|
|
var uint32Tag2 = "[object Uint32Array]";
|
|
function initCloneByTag(object4, tag, isDeep) {
|
|
var Ctor = object4.constructor;
|
|
switch (tag) {
|
|
case arrayBufferTag2:
|
|
return cloneArrayBuffer_default(object4);
|
|
case boolTag2:
|
|
case dateTag2:
|
|
return new Ctor(+object4);
|
|
case dataViewTag3:
|
|
return cloneDataView_default(object4, isDeep);
|
|
case float32Tag2:
|
|
case float64Tag2:
|
|
case int8Tag2:
|
|
case int16Tag2:
|
|
case int32Tag2:
|
|
case uint8Tag2:
|
|
case uint8ClampedTag2:
|
|
case uint16Tag2:
|
|
case uint32Tag2:
|
|
return cloneTypedArray_default(object4, isDeep);
|
|
case mapTag3:
|
|
return new Ctor();
|
|
case numberTag2:
|
|
case stringTag2:
|
|
return new Ctor(object4);
|
|
case regexpTag2:
|
|
return cloneRegExp_default(object4);
|
|
case setTag3:
|
|
return new Ctor();
|
|
case symbolTag2:
|
|
return cloneSymbol_default(object4);
|
|
}
|
|
}
|
|
var initCloneByTag_default = initCloneByTag;
|
|
|
|
// node_modules/lodash-es/_initCloneObject.js
|
|
function initCloneObject(object4) {
|
|
return typeof object4.constructor == "function" && !isPrototype_default(object4) ? baseCreate_default(getPrototype_default(object4)) : {};
|
|
}
|
|
var initCloneObject_default = initCloneObject;
|
|
|
|
// node_modules/lodash-es/_baseIsMap.js
|
|
var mapTag4 = "[object Map]";
|
|
function baseIsMap(value) {
|
|
return isObjectLike_default(value) && getTag_default(value) == mapTag4;
|
|
}
|
|
var baseIsMap_default = baseIsMap;
|
|
|
|
// node_modules/lodash-es/isMap.js
|
|
var nodeIsMap = nodeUtil_default && nodeUtil_default.isMap;
|
|
var isMap = nodeIsMap ? baseUnary_default(nodeIsMap) : baseIsMap_default;
|
|
var isMap_default = isMap;
|
|
|
|
// node_modules/lodash-es/_baseIsSet.js
|
|
var setTag4 = "[object Set]";
|
|
function baseIsSet(value) {
|
|
return isObjectLike_default(value) && getTag_default(value) == setTag4;
|
|
}
|
|
var baseIsSet_default = baseIsSet;
|
|
|
|
// node_modules/lodash-es/isSet.js
|
|
var nodeIsSet = nodeUtil_default && nodeUtil_default.isSet;
|
|
var isSet = nodeIsSet ? baseUnary_default(nodeIsSet) : baseIsSet_default;
|
|
var isSet_default = isSet;
|
|
|
|
// node_modules/lodash-es/_baseClone.js
|
|
var CLONE_DEEP_FLAG = 1;
|
|
var CLONE_FLAT_FLAG = 2;
|
|
var CLONE_SYMBOLS_FLAG = 4;
|
|
var argsTag3 = "[object Arguments]";
|
|
var arrayTag2 = "[object Array]";
|
|
var boolTag3 = "[object Boolean]";
|
|
var dateTag3 = "[object Date]";
|
|
var errorTag3 = "[object Error]";
|
|
var funcTag3 = "[object Function]";
|
|
var genTag2 = "[object GeneratorFunction]";
|
|
var mapTag5 = "[object Map]";
|
|
var numberTag3 = "[object Number]";
|
|
var objectTag4 = "[object Object]";
|
|
var regexpTag3 = "[object RegExp]";
|
|
var setTag5 = "[object Set]";
|
|
var stringTag3 = "[object String]";
|
|
var symbolTag3 = "[object Symbol]";
|
|
var weakMapTag3 = "[object WeakMap]";
|
|
var arrayBufferTag3 = "[object ArrayBuffer]";
|
|
var dataViewTag4 = "[object DataView]";
|
|
var float32Tag3 = "[object Float32Array]";
|
|
var float64Tag3 = "[object Float64Array]";
|
|
var int8Tag3 = "[object Int8Array]";
|
|
var int16Tag3 = "[object Int16Array]";
|
|
var int32Tag3 = "[object Int32Array]";
|
|
var uint8Tag3 = "[object Uint8Array]";
|
|
var uint8ClampedTag3 = "[object Uint8ClampedArray]";
|
|
var uint16Tag3 = "[object Uint16Array]";
|
|
var uint32Tag3 = "[object Uint32Array]";
|
|
var cloneableTags = {};
|
|
cloneableTags[argsTag3] = cloneableTags[arrayTag2] = cloneableTags[arrayBufferTag3] = cloneableTags[dataViewTag4] = cloneableTags[boolTag3] = cloneableTags[dateTag3] = cloneableTags[float32Tag3] = cloneableTags[float64Tag3] = cloneableTags[int8Tag3] = cloneableTags[int16Tag3] = cloneableTags[int32Tag3] = cloneableTags[mapTag5] = cloneableTags[numberTag3] = cloneableTags[objectTag4] = cloneableTags[regexpTag3] = cloneableTags[setTag5] = cloneableTags[stringTag3] = cloneableTags[symbolTag3] = cloneableTags[uint8Tag3] = cloneableTags[uint8ClampedTag3] = cloneableTags[uint16Tag3] = cloneableTags[uint32Tag3] = true;
|
|
cloneableTags[errorTag3] = cloneableTags[funcTag3] = cloneableTags[weakMapTag3] = false;
|
|
function baseClone(value, bitmask, customizer, key, object4, stack) {
|
|
var result2, isDeep = bitmask & CLONE_DEEP_FLAG, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG;
|
|
if (customizer) {
|
|
result2 = object4 ? customizer(value, key, object4, stack) : customizer(value);
|
|
}
|
|
if (result2 !== void 0) {
|
|
return result2;
|
|
}
|
|
if (!isObject_default(value)) {
|
|
return value;
|
|
}
|
|
var isArr = isArray_default(value);
|
|
if (isArr) {
|
|
result2 = initCloneArray_default(value);
|
|
if (!isDeep) {
|
|
return copyArray_default(value, result2);
|
|
}
|
|
} else {
|
|
var tag = getTag_default(value), isFunc = tag == funcTag3 || tag == genTag2;
|
|
if (isBuffer_default(value)) {
|
|
return cloneBuffer_default(value, isDeep);
|
|
}
|
|
if (tag == objectTag4 || tag == argsTag3 || isFunc && !object4) {
|
|
result2 = isFlat || isFunc ? {} : initCloneObject_default(value);
|
|
if (!isDeep) {
|
|
return isFlat ? copySymbolsIn_default(value, baseAssignIn_default(result2, value)) : copySymbols_default(value, baseAssign_default(result2, value));
|
|
}
|
|
} else {
|
|
if (!cloneableTags[tag]) {
|
|
return object4 ? value : {};
|
|
}
|
|
result2 = initCloneByTag_default(value, tag, isDeep);
|
|
}
|
|
}
|
|
stack || (stack = new Stack_default());
|
|
var stacked = stack.get(value);
|
|
if (stacked) {
|
|
return stacked;
|
|
}
|
|
stack.set(value, result2);
|
|
if (isSet_default(value)) {
|
|
value.forEach(function(subValue) {
|
|
result2.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
|
|
});
|
|
} else if (isMap_default(value)) {
|
|
value.forEach(function(subValue, key2) {
|
|
result2.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
|
|
});
|
|
}
|
|
var keysFunc = isFull ? isFlat ? getAllKeysIn_default : getAllKeys_default : isFlat ? keysIn_default : keys_default;
|
|
var props2 = isArr ? void 0 : keysFunc(value);
|
|
arrayEach_default(props2 || value, function(subValue, key2) {
|
|
if (props2) {
|
|
key2 = subValue;
|
|
subValue = value[key2];
|
|
}
|
|
assignValue_default(result2, key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
|
|
});
|
|
return result2;
|
|
}
|
|
var baseClone_default = baseClone;
|
|
|
|
// node_modules/lodash-es/clone.js
|
|
var CLONE_SYMBOLS_FLAG2 = 4;
|
|
function clone(value) {
|
|
return baseClone_default(value, CLONE_SYMBOLS_FLAG2);
|
|
}
|
|
var clone_default = clone;
|
|
|
|
// node_modules/lodash-es/cloneDeep.js
|
|
var CLONE_DEEP_FLAG2 = 1;
|
|
var CLONE_SYMBOLS_FLAG3 = 4;
|
|
function cloneDeep(value) {
|
|
return baseClone_default(value, CLONE_DEEP_FLAG2 | CLONE_SYMBOLS_FLAG3);
|
|
}
|
|
var cloneDeep_default = cloneDeep;
|
|
|
|
// node_modules/lodash-es/cloneDeepWith.js
|
|
var CLONE_DEEP_FLAG3 = 1;
|
|
var CLONE_SYMBOLS_FLAG4 = 4;
|
|
function cloneDeepWith(value, customizer) {
|
|
customizer = typeof customizer == "function" ? customizer : void 0;
|
|
return baseClone_default(value, CLONE_DEEP_FLAG3 | CLONE_SYMBOLS_FLAG4, customizer);
|
|
}
|
|
var cloneDeepWith_default = cloneDeepWith;
|
|
|
|
// node_modules/lodash-es/cloneWith.js
|
|
var CLONE_SYMBOLS_FLAG5 = 4;
|
|
function cloneWith(value, customizer) {
|
|
customizer = typeof customizer == "function" ? customizer : void 0;
|
|
return baseClone_default(value, CLONE_SYMBOLS_FLAG5, customizer);
|
|
}
|
|
var cloneWith_default = cloneWith;
|
|
|
|
// node_modules/lodash-es/commit.js
|
|
function wrapperCommit() {
|
|
return new LodashWrapper_default(this.value(), this.__chain__);
|
|
}
|
|
var commit_default = wrapperCommit;
|
|
|
|
// node_modules/lodash-es/compact.js
|
|
function compact(array4) {
|
|
var index = -1, length = array4 == null ? 0 : array4.length, resIndex = 0, result2 = [];
|
|
while (++index < length) {
|
|
var value = array4[index];
|
|
if (value) {
|
|
result2[resIndex++] = value;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var compact_default = compact;
|
|
|
|
// node_modules/lodash-es/concat.js
|
|
function concat() {
|
|
var length = arguments.length;
|
|
if (!length) {
|
|
return [];
|
|
}
|
|
var args = Array(length - 1), array4 = arguments[0], index = length;
|
|
while (index--) {
|
|
args[index - 1] = arguments[index];
|
|
}
|
|
return arrayPush_default(isArray_default(array4) ? copyArray_default(array4) : [array4], baseFlatten_default(args, 1));
|
|
}
|
|
var concat_default = concat;
|
|
|
|
// node_modules/lodash-es/_setCacheAdd.js
|
|
var HASH_UNDEFINED3 = "__lodash_hash_undefined__";
|
|
function setCacheAdd(value) {
|
|
this.__data__.set(value, HASH_UNDEFINED3);
|
|
return this;
|
|
}
|
|
var setCacheAdd_default = setCacheAdd;
|
|
|
|
// node_modules/lodash-es/_setCacheHas.js
|
|
function setCacheHas(value) {
|
|
return this.__data__.has(value);
|
|
}
|
|
var setCacheHas_default = setCacheHas;
|
|
|
|
// node_modules/lodash-es/_SetCache.js
|
|
function SetCache(values2) {
|
|
var index = -1, length = values2 == null ? 0 : values2.length;
|
|
this.__data__ = new MapCache_default();
|
|
while (++index < length) {
|
|
this.add(values2[index]);
|
|
}
|
|
}
|
|
SetCache.prototype.add = SetCache.prototype.push = setCacheAdd_default;
|
|
SetCache.prototype.has = setCacheHas_default;
|
|
var SetCache_default = SetCache;
|
|
|
|
// node_modules/lodash-es/_arraySome.js
|
|
function arraySome(array4, predicate) {
|
|
var index = -1, length = array4 == null ? 0 : array4.length;
|
|
while (++index < length) {
|
|
if (predicate(array4[index], index, array4)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
var arraySome_default = arraySome;
|
|
|
|
// node_modules/lodash-es/_cacheHas.js
|
|
function cacheHas(cache2, key) {
|
|
return cache2.has(key);
|
|
}
|
|
var cacheHas_default = cacheHas;
|
|
|
|
// node_modules/lodash-es/_equalArrays.js
|
|
var COMPARE_PARTIAL_FLAG = 1;
|
|
var COMPARE_UNORDERED_FLAG = 2;
|
|
function equalArrays(array4, other, bitmask, customizer, equalFunc, stack) {
|
|
var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array4.length, othLength = other.length;
|
|
if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
|
|
return false;
|
|
}
|
|
var arrStacked = stack.get(array4);
|
|
var othStacked = stack.get(other);
|
|
if (arrStacked && othStacked) {
|
|
return arrStacked == other && othStacked == array4;
|
|
}
|
|
var index = -1, result2 = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache_default() : void 0;
|
|
stack.set(array4, other);
|
|
stack.set(other, array4);
|
|
while (++index < arrLength) {
|
|
var arrValue = array4[index], othValue = other[index];
|
|
if (customizer) {
|
|
var compared = isPartial ? customizer(othValue, arrValue, index, other, array4, stack) : customizer(arrValue, othValue, index, array4, other, stack);
|
|
}
|
|
if (compared !== void 0) {
|
|
if (compared) {
|
|
continue;
|
|
}
|
|
result2 = false;
|
|
break;
|
|
}
|
|
if (seen) {
|
|
if (!arraySome_default(other, function(othValue2, othIndex) {
|
|
if (!cacheHas_default(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
|
|
return seen.push(othIndex);
|
|
}
|
|
})) {
|
|
result2 = false;
|
|
break;
|
|
}
|
|
} else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
|
|
result2 = false;
|
|
break;
|
|
}
|
|
}
|
|
stack["delete"](array4);
|
|
stack["delete"](other);
|
|
return result2;
|
|
}
|
|
var equalArrays_default = equalArrays;
|
|
|
|
// node_modules/lodash-es/_mapToArray.js
|
|
function mapToArray(map2) {
|
|
var index = -1, result2 = Array(map2.size);
|
|
map2.forEach(function(value, key) {
|
|
result2[++index] = [key, value];
|
|
});
|
|
return result2;
|
|
}
|
|
var mapToArray_default = mapToArray;
|
|
|
|
// node_modules/lodash-es/_setToArray.js
|
|
function setToArray(set4) {
|
|
var index = -1, result2 = Array(set4.size);
|
|
set4.forEach(function(value) {
|
|
result2[++index] = value;
|
|
});
|
|
return result2;
|
|
}
|
|
var setToArray_default = setToArray;
|
|
|
|
// node_modules/lodash-es/_equalByTag.js
|
|
var COMPARE_PARTIAL_FLAG2 = 1;
|
|
var COMPARE_UNORDERED_FLAG2 = 2;
|
|
var boolTag4 = "[object Boolean]";
|
|
var dateTag4 = "[object Date]";
|
|
var errorTag4 = "[object Error]";
|
|
var mapTag6 = "[object Map]";
|
|
var numberTag4 = "[object Number]";
|
|
var regexpTag4 = "[object RegExp]";
|
|
var setTag6 = "[object Set]";
|
|
var stringTag4 = "[object String]";
|
|
var symbolTag4 = "[object Symbol]";
|
|
var arrayBufferTag4 = "[object ArrayBuffer]";
|
|
var dataViewTag5 = "[object DataView]";
|
|
var symbolProto3 = Symbol_default ? Symbol_default.prototype : void 0;
|
|
var symbolValueOf2 = symbolProto3 ? symbolProto3.valueOf : void 0;
|
|
function equalByTag(object4, other, tag, bitmask, customizer, equalFunc, stack) {
|
|
switch (tag) {
|
|
case dataViewTag5:
|
|
if (object4.byteLength != other.byteLength || object4.byteOffset != other.byteOffset) {
|
|
return false;
|
|
}
|
|
object4 = object4.buffer;
|
|
other = other.buffer;
|
|
case arrayBufferTag4:
|
|
if (object4.byteLength != other.byteLength || !equalFunc(new Uint8Array_default(object4), new Uint8Array_default(other))) {
|
|
return false;
|
|
}
|
|
return true;
|
|
case boolTag4:
|
|
case dateTag4:
|
|
case numberTag4:
|
|
return eq_default(+object4, +other);
|
|
case errorTag4:
|
|
return object4.name == other.name && object4.message == other.message;
|
|
case regexpTag4:
|
|
case stringTag4:
|
|
return object4 == other + "";
|
|
case mapTag6:
|
|
var convert = mapToArray_default;
|
|
case setTag6:
|
|
var isPartial = bitmask & COMPARE_PARTIAL_FLAG2;
|
|
convert || (convert = setToArray_default);
|
|
if (object4.size != other.size && !isPartial) {
|
|
return false;
|
|
}
|
|
var stacked = stack.get(object4);
|
|
if (stacked) {
|
|
return stacked == other;
|
|
}
|
|
bitmask |= COMPARE_UNORDERED_FLAG2;
|
|
stack.set(object4, other);
|
|
var result2 = equalArrays_default(convert(object4), convert(other), bitmask, customizer, equalFunc, stack);
|
|
stack["delete"](object4);
|
|
return result2;
|
|
case symbolTag4:
|
|
if (symbolValueOf2) {
|
|
return symbolValueOf2.call(object4) == symbolValueOf2.call(other);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
var equalByTag_default = equalByTag;
|
|
|
|
// node_modules/lodash-es/_equalObjects.js
|
|
var COMPARE_PARTIAL_FLAG3 = 1;
|
|
var objectProto18 = Object.prototype;
|
|
var hasOwnProperty15 = objectProto18.hasOwnProperty;
|
|
function equalObjects(object4, other, bitmask, customizer, equalFunc, stack) {
|
|
var isPartial = bitmask & COMPARE_PARTIAL_FLAG3, objProps = getAllKeys_default(object4), objLength = objProps.length, othProps = getAllKeys_default(other), othLength = othProps.length;
|
|
if (objLength != othLength && !isPartial) {
|
|
return false;
|
|
}
|
|
var index = objLength;
|
|
while (index--) {
|
|
var key = objProps[index];
|
|
if (!(isPartial ? key in other : hasOwnProperty15.call(other, key))) {
|
|
return false;
|
|
}
|
|
}
|
|
var objStacked = stack.get(object4);
|
|
var othStacked = stack.get(other);
|
|
if (objStacked && othStacked) {
|
|
return objStacked == other && othStacked == object4;
|
|
}
|
|
var result2 = true;
|
|
stack.set(object4, other);
|
|
stack.set(other, object4);
|
|
var skipCtor = isPartial;
|
|
while (++index < objLength) {
|
|
key = objProps[index];
|
|
var objValue = object4[key], othValue = other[key];
|
|
if (customizer) {
|
|
var compared = isPartial ? customizer(othValue, objValue, key, other, object4, stack) : customizer(objValue, othValue, key, object4, other, stack);
|
|
}
|
|
if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
|
|
result2 = false;
|
|
break;
|
|
}
|
|
skipCtor || (skipCtor = key == "constructor");
|
|
}
|
|
if (result2 && !skipCtor) {
|
|
var objCtor = object4.constructor, othCtor = other.constructor;
|
|
if (objCtor != othCtor && ("constructor" in object4 && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
|
|
result2 = false;
|
|
}
|
|
}
|
|
stack["delete"](object4);
|
|
stack["delete"](other);
|
|
return result2;
|
|
}
|
|
var equalObjects_default = equalObjects;
|
|
|
|
// node_modules/lodash-es/_baseIsEqualDeep.js
|
|
var COMPARE_PARTIAL_FLAG4 = 1;
|
|
var argsTag4 = "[object Arguments]";
|
|
var arrayTag3 = "[object Array]";
|
|
var objectTag5 = "[object Object]";
|
|
var objectProto19 = Object.prototype;
|
|
var hasOwnProperty16 = objectProto19.hasOwnProperty;
|
|
function baseIsEqualDeep(object4, other, bitmask, customizer, equalFunc, stack) {
|
|
var objIsArr = isArray_default(object4), othIsArr = isArray_default(other), objTag = objIsArr ? arrayTag3 : getTag_default(object4), othTag = othIsArr ? arrayTag3 : getTag_default(other);
|
|
objTag = objTag == argsTag4 ? objectTag5 : objTag;
|
|
othTag = othTag == argsTag4 ? objectTag5 : othTag;
|
|
var objIsObj = objTag == objectTag5, othIsObj = othTag == objectTag5, isSameTag = objTag == othTag;
|
|
if (isSameTag && isBuffer_default(object4)) {
|
|
if (!isBuffer_default(other)) {
|
|
return false;
|
|
}
|
|
objIsArr = true;
|
|
objIsObj = false;
|
|
}
|
|
if (isSameTag && !objIsObj) {
|
|
stack || (stack = new Stack_default());
|
|
return objIsArr || isTypedArray_default(object4) ? equalArrays_default(object4, other, bitmask, customizer, equalFunc, stack) : equalByTag_default(object4, other, objTag, bitmask, customizer, equalFunc, stack);
|
|
}
|
|
if (!(bitmask & COMPARE_PARTIAL_FLAG4)) {
|
|
var objIsWrapped = objIsObj && hasOwnProperty16.call(object4, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty16.call(other, "__wrapped__");
|
|
if (objIsWrapped || othIsWrapped) {
|
|
var objUnwrapped = objIsWrapped ? object4.value() : object4, othUnwrapped = othIsWrapped ? other.value() : other;
|
|
stack || (stack = new Stack_default());
|
|
return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
|
|
}
|
|
}
|
|
if (!isSameTag) {
|
|
return false;
|
|
}
|
|
stack || (stack = new Stack_default());
|
|
return equalObjects_default(object4, other, bitmask, customizer, equalFunc, stack);
|
|
}
|
|
var baseIsEqualDeep_default = baseIsEqualDeep;
|
|
|
|
// node_modules/lodash-es/_baseIsEqual.js
|
|
function baseIsEqual(value, other, bitmask, customizer, stack) {
|
|
if (value === other) {
|
|
return true;
|
|
}
|
|
if (value == null || other == null || !isObjectLike_default(value) && !isObjectLike_default(other)) {
|
|
return value !== value && other !== other;
|
|
}
|
|
return baseIsEqualDeep_default(value, other, bitmask, customizer, baseIsEqual, stack);
|
|
}
|
|
var baseIsEqual_default = baseIsEqual;
|
|
|
|
// node_modules/lodash-es/_baseIsMatch.js
|
|
var COMPARE_PARTIAL_FLAG5 = 1;
|
|
var COMPARE_UNORDERED_FLAG3 = 2;
|
|
function baseIsMatch(object4, source, matchData, customizer) {
|
|
var index = matchData.length, length = index, noCustomizer = !customizer;
|
|
if (object4 == null) {
|
|
return !length;
|
|
}
|
|
object4 = Object(object4);
|
|
while (index--) {
|
|
var data = matchData[index];
|
|
if (noCustomizer && data[2] ? data[1] !== object4[data[0]] : !(data[0] in object4)) {
|
|
return false;
|
|
}
|
|
}
|
|
while (++index < length) {
|
|
data = matchData[index];
|
|
var key = data[0], objValue = object4[key], srcValue = data[1];
|
|
if (noCustomizer && data[2]) {
|
|
if (objValue === void 0 && !(key in object4)) {
|
|
return false;
|
|
}
|
|
} else {
|
|
var stack = new Stack_default();
|
|
if (customizer) {
|
|
var result2 = customizer(objValue, srcValue, key, object4, source, stack);
|
|
}
|
|
if (!(result2 === void 0 ? baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG5 | COMPARE_UNORDERED_FLAG3, customizer, stack) : result2)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
var baseIsMatch_default = baseIsMatch;
|
|
|
|
// node_modules/lodash-es/_isStrictComparable.js
|
|
function isStrictComparable(value) {
|
|
return value === value && !isObject_default(value);
|
|
}
|
|
var isStrictComparable_default = isStrictComparable;
|
|
|
|
// node_modules/lodash-es/_getMatchData.js
|
|
function getMatchData(object4) {
|
|
var result2 = keys_default(object4), length = result2.length;
|
|
while (length--) {
|
|
var key = result2[length], value = object4[key];
|
|
result2[length] = [key, value, isStrictComparable_default(value)];
|
|
}
|
|
return result2;
|
|
}
|
|
var getMatchData_default = getMatchData;
|
|
|
|
// node_modules/lodash-es/_matchesStrictComparable.js
|
|
function matchesStrictComparable(key, srcValue) {
|
|
return function(object4) {
|
|
if (object4 == null) {
|
|
return false;
|
|
}
|
|
return object4[key] === srcValue && (srcValue !== void 0 || key in Object(object4));
|
|
};
|
|
}
|
|
var matchesStrictComparable_default = matchesStrictComparable;
|
|
|
|
// node_modules/lodash-es/_baseMatches.js
|
|
function baseMatches(source) {
|
|
var matchData = getMatchData_default(source);
|
|
if (matchData.length == 1 && matchData[0][2]) {
|
|
return matchesStrictComparable_default(matchData[0][0], matchData[0][1]);
|
|
}
|
|
return function(object4) {
|
|
return object4 === source || baseIsMatch_default(object4, source, matchData);
|
|
};
|
|
}
|
|
var baseMatches_default = baseMatches;
|
|
|
|
// node_modules/lodash-es/_baseHasIn.js
|
|
function baseHasIn(object4, key) {
|
|
return object4 != null && key in Object(object4);
|
|
}
|
|
var baseHasIn_default = baseHasIn;
|
|
|
|
// node_modules/lodash-es/_hasPath.js
|
|
function hasPath(object4, path, hasFunc) {
|
|
path = castPath_default(path, object4);
|
|
var index = -1, length = path.length, result2 = false;
|
|
while (++index < length) {
|
|
var key = toKey_default(path[index]);
|
|
if (!(result2 = object4 != null && hasFunc(object4, key))) {
|
|
break;
|
|
}
|
|
object4 = object4[key];
|
|
}
|
|
if (result2 || ++index != length) {
|
|
return result2;
|
|
}
|
|
length = object4 == null ? 0 : object4.length;
|
|
return !!length && isLength_default(length) && isIndex_default(key, length) && (isArray_default(object4) || isArguments_default(object4));
|
|
}
|
|
var hasPath_default = hasPath;
|
|
|
|
// node_modules/lodash-es/hasIn.js
|
|
function hasIn(object4, path) {
|
|
return object4 != null && hasPath_default(object4, path, baseHasIn_default);
|
|
}
|
|
var hasIn_default = hasIn;
|
|
|
|
// node_modules/lodash-es/_baseMatchesProperty.js
|
|
var COMPARE_PARTIAL_FLAG6 = 1;
|
|
var COMPARE_UNORDERED_FLAG4 = 2;
|
|
function baseMatchesProperty(path, srcValue) {
|
|
if (isKey_default(path) && isStrictComparable_default(srcValue)) {
|
|
return matchesStrictComparable_default(toKey_default(path), srcValue);
|
|
}
|
|
return function(object4) {
|
|
var objValue = get_default(object4, path);
|
|
return objValue === void 0 && objValue === srcValue ? hasIn_default(object4, path) : baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG6 | COMPARE_UNORDERED_FLAG4);
|
|
};
|
|
}
|
|
var baseMatchesProperty_default = baseMatchesProperty;
|
|
|
|
// node_modules/lodash-es/_baseProperty.js
|
|
function baseProperty(key) {
|
|
return function(object4) {
|
|
return object4 == null ? void 0 : object4[key];
|
|
};
|
|
}
|
|
var baseProperty_default = baseProperty;
|
|
|
|
// node_modules/lodash-es/_basePropertyDeep.js
|
|
function basePropertyDeep(path) {
|
|
return function(object4) {
|
|
return baseGet_default(object4, path);
|
|
};
|
|
}
|
|
var basePropertyDeep_default = basePropertyDeep;
|
|
|
|
// node_modules/lodash-es/property.js
|
|
function property(path) {
|
|
return isKey_default(path) ? baseProperty_default(toKey_default(path)) : basePropertyDeep_default(path);
|
|
}
|
|
var property_default = property;
|
|
|
|
// node_modules/lodash-es/_baseIteratee.js
|
|
function baseIteratee(value) {
|
|
if (typeof value == "function") {
|
|
return value;
|
|
}
|
|
if (value == null) {
|
|
return identity_default;
|
|
}
|
|
if (typeof value == "object") {
|
|
return isArray_default(value) ? baseMatchesProperty_default(value[0], value[1]) : baseMatches_default(value);
|
|
}
|
|
return property_default(value);
|
|
}
|
|
var baseIteratee_default = baseIteratee;
|
|
|
|
// node_modules/lodash-es/cond.js
|
|
var FUNC_ERROR_TEXT5 = "Expected a function";
|
|
function cond(pairs) {
|
|
var length = pairs == null ? 0 : pairs.length, toIteratee = baseIteratee_default;
|
|
pairs = !length ? [] : arrayMap_default(pairs, function(pair) {
|
|
if (typeof pair[1] != "function") {
|
|
throw new TypeError(FUNC_ERROR_TEXT5);
|
|
}
|
|
return [toIteratee(pair[0]), pair[1]];
|
|
});
|
|
return baseRest_default(function(args) {
|
|
var index = -1;
|
|
while (++index < length) {
|
|
var pair = pairs[index];
|
|
if (apply_default(pair[0], this, args)) {
|
|
return apply_default(pair[1], this, args);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
var cond_default = cond;
|
|
|
|
// node_modules/lodash-es/_baseConformsTo.js
|
|
function baseConformsTo(object4, source, props2) {
|
|
var length = props2.length;
|
|
if (object4 == null) {
|
|
return !length;
|
|
}
|
|
object4 = Object(object4);
|
|
while (length--) {
|
|
var key = props2[length], predicate = source[key], value = object4[key];
|
|
if (value === void 0 && !(key in object4) || !predicate(value)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
var baseConformsTo_default = baseConformsTo;
|
|
|
|
// node_modules/lodash-es/_baseConforms.js
|
|
function baseConforms(source) {
|
|
var props2 = keys_default(source);
|
|
return function(object4) {
|
|
return baseConformsTo_default(object4, source, props2);
|
|
};
|
|
}
|
|
var baseConforms_default = baseConforms;
|
|
|
|
// node_modules/lodash-es/conforms.js
|
|
var CLONE_DEEP_FLAG4 = 1;
|
|
function conforms(source) {
|
|
return baseConforms_default(baseClone_default(source, CLONE_DEEP_FLAG4));
|
|
}
|
|
var conforms_default = conforms;
|
|
|
|
// node_modules/lodash-es/conformsTo.js
|
|
function conformsTo(object4, source) {
|
|
return source == null || baseConformsTo_default(object4, source, keys_default(source));
|
|
}
|
|
var conformsTo_default = conformsTo;
|
|
|
|
// node_modules/lodash-es/_arrayAggregator.js
|
|
function arrayAggregator(array4, setter, iteratee2, accumulator) {
|
|
var index = -1, length = array4 == null ? 0 : array4.length;
|
|
while (++index < length) {
|
|
var value = array4[index];
|
|
setter(accumulator, value, iteratee2(value), array4);
|
|
}
|
|
return accumulator;
|
|
}
|
|
var arrayAggregator_default = arrayAggregator;
|
|
|
|
// node_modules/lodash-es/_createBaseFor.js
|
|
function createBaseFor(fromRight) {
|
|
return function(object4, iteratee2, keysFunc) {
|
|
var index = -1, iterable = Object(object4), props2 = keysFunc(object4), length = props2.length;
|
|
while (length--) {
|
|
var key = props2[fromRight ? length : ++index];
|
|
if (iteratee2(iterable[key], key, iterable) === false) {
|
|
break;
|
|
}
|
|
}
|
|
return object4;
|
|
};
|
|
}
|
|
var createBaseFor_default = createBaseFor;
|
|
|
|
// node_modules/lodash-es/_baseFor.js
|
|
var baseFor = createBaseFor_default();
|
|
var baseFor_default = baseFor;
|
|
|
|
// node_modules/lodash-es/_baseForOwn.js
|
|
function baseForOwn(object4, iteratee2) {
|
|
return object4 && baseFor_default(object4, iteratee2, keys_default);
|
|
}
|
|
var baseForOwn_default = baseForOwn;
|
|
|
|
// node_modules/lodash-es/_createBaseEach.js
|
|
function createBaseEach(eachFunc, fromRight) {
|
|
return function(collection, iteratee2) {
|
|
if (collection == null) {
|
|
return collection;
|
|
}
|
|
if (!isArrayLike_default(collection)) {
|
|
return eachFunc(collection, iteratee2);
|
|
}
|
|
var length = collection.length, index = fromRight ? length : -1, iterable = Object(collection);
|
|
while (fromRight ? index-- : ++index < length) {
|
|
if (iteratee2(iterable[index], index, iterable) === false) {
|
|
break;
|
|
}
|
|
}
|
|
return collection;
|
|
};
|
|
}
|
|
var createBaseEach_default = createBaseEach;
|
|
|
|
// node_modules/lodash-es/_baseEach.js
|
|
var baseEach = createBaseEach_default(baseForOwn_default);
|
|
var baseEach_default = baseEach;
|
|
|
|
// node_modules/lodash-es/_baseAggregator.js
|
|
function baseAggregator(collection, setter, iteratee2, accumulator) {
|
|
baseEach_default(collection, function(value, key, collection2) {
|
|
setter(accumulator, value, iteratee2(value), collection2);
|
|
});
|
|
return accumulator;
|
|
}
|
|
var baseAggregator_default = baseAggregator;
|
|
|
|
// node_modules/lodash-es/_createAggregator.js
|
|
function createAggregator(setter, initializer) {
|
|
return function(collection, iteratee2) {
|
|
var func = isArray_default(collection) ? arrayAggregator_default : baseAggregator_default, accumulator = initializer ? initializer() : {};
|
|
return func(collection, setter, baseIteratee_default(iteratee2, 2), accumulator);
|
|
};
|
|
}
|
|
var createAggregator_default = createAggregator;
|
|
|
|
// node_modules/lodash-es/countBy.js
|
|
var objectProto20 = Object.prototype;
|
|
var hasOwnProperty17 = objectProto20.hasOwnProperty;
|
|
var countBy = createAggregator_default(function(result2, value, key) {
|
|
if (hasOwnProperty17.call(result2, key)) {
|
|
++result2[key];
|
|
} else {
|
|
baseAssignValue_default(result2, key, 1);
|
|
}
|
|
});
|
|
var countBy_default = countBy;
|
|
|
|
// node_modules/lodash-es/create.js
|
|
function create(prototype, properties) {
|
|
var result2 = baseCreate_default(prototype);
|
|
return properties == null ? result2 : baseAssign_default(result2, properties);
|
|
}
|
|
var create_default = create;
|
|
|
|
// node_modules/lodash-es/curry.js
|
|
var WRAP_CURRY_FLAG6 = 8;
|
|
function curry(func, arity, guard) {
|
|
arity = guard ? void 0 : arity;
|
|
var result2 = createWrap_default(func, WRAP_CURRY_FLAG6, void 0, void 0, void 0, void 0, void 0, arity);
|
|
result2.placeholder = curry.placeholder;
|
|
return result2;
|
|
}
|
|
curry.placeholder = {};
|
|
var curry_default = curry;
|
|
|
|
// node_modules/lodash-es/curryRight.js
|
|
var WRAP_CURRY_RIGHT_FLAG4 = 16;
|
|
function curryRight(func, arity, guard) {
|
|
arity = guard ? void 0 : arity;
|
|
var result2 = createWrap_default(func, WRAP_CURRY_RIGHT_FLAG4, void 0, void 0, void 0, void 0, void 0, arity);
|
|
result2.placeholder = curryRight.placeholder;
|
|
return result2;
|
|
}
|
|
curryRight.placeholder = {};
|
|
var curryRight_default = curryRight;
|
|
|
|
// node_modules/lodash-es/now.js
|
|
var now = function() {
|
|
return root_default.Date.now();
|
|
};
|
|
var now_default = now;
|
|
|
|
// node_modules/lodash-es/debounce.js
|
|
var FUNC_ERROR_TEXT6 = "Expected a function";
|
|
var nativeMax6 = Math.max;
|
|
var nativeMin4 = Math.min;
|
|
function debounce(func, wait, options) {
|
|
var lastArgs, lastThis, maxWait, result2, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
|
|
if (typeof func != "function") {
|
|
throw new TypeError(FUNC_ERROR_TEXT6);
|
|
}
|
|
wait = toNumber_default(wait) || 0;
|
|
if (isObject_default(options)) {
|
|
leading = !!options.leading;
|
|
maxing = "maxWait" in options;
|
|
maxWait = maxing ? nativeMax6(toNumber_default(options.maxWait) || 0, wait) : maxWait;
|
|
trailing = "trailing" in options ? !!options.trailing : trailing;
|
|
}
|
|
function invokeFunc(time) {
|
|
var args = lastArgs, thisArg = lastThis;
|
|
lastArgs = lastThis = void 0;
|
|
lastInvokeTime = time;
|
|
result2 = func.apply(thisArg, args);
|
|
return result2;
|
|
}
|
|
function leadingEdge(time) {
|
|
lastInvokeTime = time;
|
|
timerId = setTimeout(timerExpired, wait);
|
|
return leading ? invokeFunc(time) : result2;
|
|
}
|
|
function remainingWait(time) {
|
|
var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
|
|
return maxing ? nativeMin4(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
|
|
}
|
|
function shouldInvoke(time) {
|
|
var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
|
|
return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
|
|
}
|
|
function timerExpired() {
|
|
var time = now_default();
|
|
if (shouldInvoke(time)) {
|
|
return trailingEdge(time);
|
|
}
|
|
timerId = setTimeout(timerExpired, remainingWait(time));
|
|
}
|
|
function trailingEdge(time) {
|
|
timerId = void 0;
|
|
if (trailing && lastArgs) {
|
|
return invokeFunc(time);
|
|
}
|
|
lastArgs = lastThis = void 0;
|
|
return result2;
|
|
}
|
|
function cancel() {
|
|
if (timerId !== void 0) {
|
|
clearTimeout(timerId);
|
|
}
|
|
lastInvokeTime = 0;
|
|
lastArgs = lastCallTime = lastThis = timerId = void 0;
|
|
}
|
|
function flush() {
|
|
return timerId === void 0 ? result2 : trailingEdge(now_default());
|
|
}
|
|
function debounced() {
|
|
var time = now_default(), isInvoking = shouldInvoke(time);
|
|
lastArgs = arguments;
|
|
lastThis = this;
|
|
lastCallTime = time;
|
|
if (isInvoking) {
|
|
if (timerId === void 0) {
|
|
return leadingEdge(lastCallTime);
|
|
}
|
|
if (maxing) {
|
|
clearTimeout(timerId);
|
|
timerId = setTimeout(timerExpired, wait);
|
|
return invokeFunc(lastCallTime);
|
|
}
|
|
}
|
|
if (timerId === void 0) {
|
|
timerId = setTimeout(timerExpired, wait);
|
|
}
|
|
return result2;
|
|
}
|
|
debounced.cancel = cancel;
|
|
debounced.flush = flush;
|
|
return debounced;
|
|
}
|
|
var debounce_default = debounce;
|
|
|
|
// node_modules/lodash-es/defaultTo.js
|
|
function defaultTo(value, defaultValue) {
|
|
return value == null || value !== value ? defaultValue : value;
|
|
}
|
|
var defaultTo_default = defaultTo;
|
|
|
|
// node_modules/lodash-es/defaults.js
|
|
var objectProto21 = Object.prototype;
|
|
var hasOwnProperty18 = objectProto21.hasOwnProperty;
|
|
var defaults = baseRest_default(function(object4, sources) {
|
|
object4 = Object(object4);
|
|
var index = -1;
|
|
var length = sources.length;
|
|
var guard = length > 2 ? sources[2] : void 0;
|
|
if (guard && isIterateeCall_default(sources[0], sources[1], guard)) {
|
|
length = 1;
|
|
}
|
|
while (++index < length) {
|
|
var source = sources[index];
|
|
var props2 = keysIn_default(source);
|
|
var propsIndex = -1;
|
|
var propsLength = props2.length;
|
|
while (++propsIndex < propsLength) {
|
|
var key = props2[propsIndex];
|
|
var value = object4[key];
|
|
if (value === void 0 || eq_default(value, objectProto21[key]) && !hasOwnProperty18.call(object4, key)) {
|
|
object4[key] = source[key];
|
|
}
|
|
}
|
|
}
|
|
return object4;
|
|
});
|
|
var defaults_default = defaults;
|
|
|
|
// node_modules/lodash-es/_assignMergeValue.js
|
|
function assignMergeValue(object4, key, value) {
|
|
if (value !== void 0 && !eq_default(object4[key], value) || value === void 0 && !(key in object4)) {
|
|
baseAssignValue_default(object4, key, value);
|
|
}
|
|
}
|
|
var assignMergeValue_default = assignMergeValue;
|
|
|
|
// node_modules/lodash-es/isArrayLikeObject.js
|
|
function isArrayLikeObject(value) {
|
|
return isObjectLike_default(value) && isArrayLike_default(value);
|
|
}
|
|
var isArrayLikeObject_default = isArrayLikeObject;
|
|
|
|
// node_modules/lodash-es/_safeGet.js
|
|
function safeGet(object4, key) {
|
|
if (key === "constructor" && typeof object4[key] === "function") {
|
|
return;
|
|
}
|
|
if (key == "__proto__") {
|
|
return;
|
|
}
|
|
return object4[key];
|
|
}
|
|
var safeGet_default = safeGet;
|
|
|
|
// node_modules/lodash-es/toPlainObject.js
|
|
function toPlainObject(value) {
|
|
return copyObject_default(value, keysIn_default(value));
|
|
}
|
|
var toPlainObject_default = toPlainObject;
|
|
|
|
// node_modules/lodash-es/_baseMergeDeep.js
|
|
function baseMergeDeep(object4, source, key, srcIndex, mergeFunc, customizer, stack) {
|
|
var objValue = safeGet_default(object4, key), srcValue = safeGet_default(source, key), stacked = stack.get(srcValue);
|
|
if (stacked) {
|
|
assignMergeValue_default(object4, key, stacked);
|
|
return;
|
|
}
|
|
var newValue = customizer ? customizer(objValue, srcValue, key + "", object4, source, stack) : void 0;
|
|
var isCommon = newValue === void 0;
|
|
if (isCommon) {
|
|
var isArr = isArray_default(srcValue), isBuff = !isArr && isBuffer_default(srcValue), isTyped = !isArr && !isBuff && isTypedArray_default(srcValue);
|
|
newValue = srcValue;
|
|
if (isArr || isBuff || isTyped) {
|
|
if (isArray_default(objValue)) {
|
|
newValue = objValue;
|
|
} else if (isArrayLikeObject_default(objValue)) {
|
|
newValue = copyArray_default(objValue);
|
|
} else if (isBuff) {
|
|
isCommon = false;
|
|
newValue = cloneBuffer_default(srcValue, true);
|
|
} else if (isTyped) {
|
|
isCommon = false;
|
|
newValue = cloneTypedArray_default(srcValue, true);
|
|
} else {
|
|
newValue = [];
|
|
}
|
|
} else if (isPlainObject_default(srcValue) || isArguments_default(srcValue)) {
|
|
newValue = objValue;
|
|
if (isArguments_default(objValue)) {
|
|
newValue = toPlainObject_default(objValue);
|
|
} else if (!isObject_default(objValue) || isFunction_default(objValue)) {
|
|
newValue = initCloneObject_default(srcValue);
|
|
}
|
|
} else {
|
|
isCommon = false;
|
|
}
|
|
}
|
|
if (isCommon) {
|
|
stack.set(srcValue, newValue);
|
|
mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
|
|
stack["delete"](srcValue);
|
|
}
|
|
assignMergeValue_default(object4, key, newValue);
|
|
}
|
|
var baseMergeDeep_default = baseMergeDeep;
|
|
|
|
// node_modules/lodash-es/_baseMerge.js
|
|
function baseMerge(object4, source, srcIndex, customizer, stack) {
|
|
if (object4 === source) {
|
|
return;
|
|
}
|
|
baseFor_default(source, function(srcValue, key) {
|
|
stack || (stack = new Stack_default());
|
|
if (isObject_default(srcValue)) {
|
|
baseMergeDeep_default(object4, source, key, srcIndex, baseMerge, customizer, stack);
|
|
} else {
|
|
var newValue = customizer ? customizer(safeGet_default(object4, key), srcValue, key + "", object4, source, stack) : void 0;
|
|
if (newValue === void 0) {
|
|
newValue = srcValue;
|
|
}
|
|
assignMergeValue_default(object4, key, newValue);
|
|
}
|
|
}, keysIn_default);
|
|
}
|
|
var baseMerge_default = baseMerge;
|
|
|
|
// node_modules/lodash-es/_customDefaultsMerge.js
|
|
function customDefaultsMerge(objValue, srcValue, key, object4, source, stack) {
|
|
if (isObject_default(objValue) && isObject_default(srcValue)) {
|
|
stack.set(srcValue, objValue);
|
|
baseMerge_default(objValue, srcValue, void 0, customDefaultsMerge, stack);
|
|
stack["delete"](srcValue);
|
|
}
|
|
return objValue;
|
|
}
|
|
var customDefaultsMerge_default = customDefaultsMerge;
|
|
|
|
// node_modules/lodash-es/mergeWith.js
|
|
var mergeWith = createAssigner_default(function(object4, source, srcIndex, customizer) {
|
|
baseMerge_default(object4, source, srcIndex, customizer);
|
|
});
|
|
var mergeWith_default = mergeWith;
|
|
|
|
// node_modules/lodash-es/defaultsDeep.js
|
|
var defaultsDeep = baseRest_default(function(args) {
|
|
args.push(void 0, customDefaultsMerge_default);
|
|
return apply_default(mergeWith_default, void 0, args);
|
|
});
|
|
var defaultsDeep_default = defaultsDeep;
|
|
|
|
// node_modules/lodash-es/_baseDelay.js
|
|
var FUNC_ERROR_TEXT7 = "Expected a function";
|
|
function baseDelay(func, wait, args) {
|
|
if (typeof func != "function") {
|
|
throw new TypeError(FUNC_ERROR_TEXT7);
|
|
}
|
|
return setTimeout(function() {
|
|
func.apply(void 0, args);
|
|
}, wait);
|
|
}
|
|
var baseDelay_default = baseDelay;
|
|
|
|
// node_modules/lodash-es/defer.js
|
|
var defer = baseRest_default(function(func, args) {
|
|
return baseDelay_default(func, 1, args);
|
|
});
|
|
var defer_default = defer;
|
|
|
|
// node_modules/lodash-es/delay.js
|
|
var delay = baseRest_default(function(func, wait, args) {
|
|
return baseDelay_default(func, toNumber_default(wait) || 0, args);
|
|
});
|
|
var delay_default = delay;
|
|
|
|
// node_modules/lodash-es/_arrayIncludesWith.js
|
|
function arrayIncludesWith(array4, value, comparator) {
|
|
var index = -1, length = array4 == null ? 0 : array4.length;
|
|
while (++index < length) {
|
|
if (comparator(value, array4[index])) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
var arrayIncludesWith_default = arrayIncludesWith;
|
|
|
|
// node_modules/lodash-es/_baseDifference.js
|
|
var LARGE_ARRAY_SIZE2 = 200;
|
|
function baseDifference(array4, values2, iteratee2, comparator) {
|
|
var index = -1, includes2 = arrayIncludes_default, isCommon = true, length = array4.length, result2 = [], valuesLength = values2.length;
|
|
if (!length) {
|
|
return result2;
|
|
}
|
|
if (iteratee2) {
|
|
values2 = arrayMap_default(values2, baseUnary_default(iteratee2));
|
|
}
|
|
if (comparator) {
|
|
includes2 = arrayIncludesWith_default;
|
|
isCommon = false;
|
|
} else if (values2.length >= LARGE_ARRAY_SIZE2) {
|
|
includes2 = cacheHas_default;
|
|
isCommon = false;
|
|
values2 = new SetCache_default(values2);
|
|
}
|
|
outer:
|
|
while (++index < length) {
|
|
var value = array4[index], computed2 = iteratee2 == null ? value : iteratee2(value);
|
|
value = comparator || value !== 0 ? value : 0;
|
|
if (isCommon && computed2 === computed2) {
|
|
var valuesIndex = valuesLength;
|
|
while (valuesIndex--) {
|
|
if (values2[valuesIndex] === computed2) {
|
|
continue outer;
|
|
}
|
|
}
|
|
result2.push(value);
|
|
} else if (!includes2(values2, computed2, comparator)) {
|
|
result2.push(value);
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var baseDifference_default = baseDifference;
|
|
|
|
// node_modules/lodash-es/difference.js
|
|
var difference = baseRest_default(function(array4, values2) {
|
|
return isArrayLikeObject_default(array4) ? baseDifference_default(array4, baseFlatten_default(values2, 1, isArrayLikeObject_default, true)) : [];
|
|
});
|
|
var difference_default = difference;
|
|
|
|
// node_modules/lodash-es/last.js
|
|
function last(array4) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
return length ? array4[length - 1] : void 0;
|
|
}
|
|
var last_default = last;
|
|
|
|
// node_modules/lodash-es/differenceBy.js
|
|
var differenceBy = baseRest_default(function(array4, values2) {
|
|
var iteratee2 = last_default(values2);
|
|
if (isArrayLikeObject_default(iteratee2)) {
|
|
iteratee2 = void 0;
|
|
}
|
|
return isArrayLikeObject_default(array4) ? baseDifference_default(array4, baseFlatten_default(values2, 1, isArrayLikeObject_default, true), baseIteratee_default(iteratee2, 2)) : [];
|
|
});
|
|
var differenceBy_default = differenceBy;
|
|
|
|
// node_modules/lodash-es/differenceWith.js
|
|
var differenceWith = baseRest_default(function(array4, values2) {
|
|
var comparator = last_default(values2);
|
|
if (isArrayLikeObject_default(comparator)) {
|
|
comparator = void 0;
|
|
}
|
|
return isArrayLikeObject_default(array4) ? baseDifference_default(array4, baseFlatten_default(values2, 1, isArrayLikeObject_default, true), void 0, comparator) : [];
|
|
});
|
|
var differenceWith_default = differenceWith;
|
|
|
|
// node_modules/lodash-es/divide.js
|
|
var divide = createMathOperation_default(function(dividend, divisor) {
|
|
return dividend / divisor;
|
|
}, 1);
|
|
var divide_default = divide;
|
|
|
|
// node_modules/lodash-es/drop.js
|
|
function drop(array4, n, guard) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
if (!length) {
|
|
return [];
|
|
}
|
|
n = guard || n === void 0 ? 1 : toInteger_default(n);
|
|
return baseSlice_default(array4, n < 0 ? 0 : n, length);
|
|
}
|
|
var drop_default = drop;
|
|
|
|
// node_modules/lodash-es/dropRight.js
|
|
function dropRight(array4, n, guard) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
if (!length) {
|
|
return [];
|
|
}
|
|
n = guard || n === void 0 ? 1 : toInteger_default(n);
|
|
n = length - n;
|
|
return baseSlice_default(array4, 0, n < 0 ? 0 : n);
|
|
}
|
|
var dropRight_default = dropRight;
|
|
|
|
// node_modules/lodash-es/_baseWhile.js
|
|
function baseWhile(array4, predicate, isDrop, fromRight) {
|
|
var length = array4.length, index = fromRight ? length : -1;
|
|
while ((fromRight ? index-- : ++index < length) && predicate(array4[index], index, array4)) {
|
|
}
|
|
return isDrop ? baseSlice_default(array4, fromRight ? 0 : index, fromRight ? index + 1 : length) : baseSlice_default(array4, fromRight ? index + 1 : 0, fromRight ? length : index);
|
|
}
|
|
var baseWhile_default = baseWhile;
|
|
|
|
// node_modules/lodash-es/dropRightWhile.js
|
|
function dropRightWhile(array4, predicate) {
|
|
return array4 && array4.length ? baseWhile_default(array4, baseIteratee_default(predicate, 3), true, true) : [];
|
|
}
|
|
var dropRightWhile_default = dropRightWhile;
|
|
|
|
// node_modules/lodash-es/dropWhile.js
|
|
function dropWhile(array4, predicate) {
|
|
return array4 && array4.length ? baseWhile_default(array4, baseIteratee_default(predicate, 3), true) : [];
|
|
}
|
|
var dropWhile_default = dropWhile;
|
|
|
|
// node_modules/lodash-es/_castFunction.js
|
|
function castFunction(value) {
|
|
return typeof value == "function" ? value : identity_default;
|
|
}
|
|
var castFunction_default = castFunction;
|
|
|
|
// node_modules/lodash-es/forEach.js
|
|
function forEach(collection, iteratee2) {
|
|
var func = isArray_default(collection) ? arrayEach_default : baseEach_default;
|
|
return func(collection, castFunction_default(iteratee2));
|
|
}
|
|
var forEach_default = forEach;
|
|
|
|
// node_modules/lodash-es/_arrayEachRight.js
|
|
function arrayEachRight(array4, iteratee2) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
while (length--) {
|
|
if (iteratee2(array4[length], length, array4) === false) {
|
|
break;
|
|
}
|
|
}
|
|
return array4;
|
|
}
|
|
var arrayEachRight_default = arrayEachRight;
|
|
|
|
// node_modules/lodash-es/_baseForRight.js
|
|
var baseForRight = createBaseFor_default(true);
|
|
var baseForRight_default = baseForRight;
|
|
|
|
// node_modules/lodash-es/_baseForOwnRight.js
|
|
function baseForOwnRight(object4, iteratee2) {
|
|
return object4 && baseForRight_default(object4, iteratee2, keys_default);
|
|
}
|
|
var baseForOwnRight_default = baseForOwnRight;
|
|
|
|
// node_modules/lodash-es/_baseEachRight.js
|
|
var baseEachRight = createBaseEach_default(baseForOwnRight_default, true);
|
|
var baseEachRight_default = baseEachRight;
|
|
|
|
// node_modules/lodash-es/forEachRight.js
|
|
function forEachRight(collection, iteratee2) {
|
|
var func = isArray_default(collection) ? arrayEachRight_default : baseEachRight_default;
|
|
return func(collection, castFunction_default(iteratee2));
|
|
}
|
|
var forEachRight_default = forEachRight;
|
|
|
|
// node_modules/lodash-es/endsWith.js
|
|
function endsWith(string3, target2, position) {
|
|
string3 = toString_default(string3);
|
|
target2 = baseToString_default(target2);
|
|
var length = string3.length;
|
|
position = position === void 0 ? length : baseClamp_default(toInteger_default(position), 0, length);
|
|
var end = position;
|
|
position -= target2.length;
|
|
return position >= 0 && string3.slice(position, end) == target2;
|
|
}
|
|
var endsWith_default = endsWith;
|
|
|
|
// node_modules/lodash-es/_baseToPairs.js
|
|
function baseToPairs(object4, props2) {
|
|
return arrayMap_default(props2, function(key) {
|
|
return [key, object4[key]];
|
|
});
|
|
}
|
|
var baseToPairs_default = baseToPairs;
|
|
|
|
// node_modules/lodash-es/_setToPairs.js
|
|
function setToPairs(set4) {
|
|
var index = -1, result2 = Array(set4.size);
|
|
set4.forEach(function(value) {
|
|
result2[++index] = [value, value];
|
|
});
|
|
return result2;
|
|
}
|
|
var setToPairs_default = setToPairs;
|
|
|
|
// node_modules/lodash-es/_createToPairs.js
|
|
var mapTag7 = "[object Map]";
|
|
var setTag7 = "[object Set]";
|
|
function createToPairs(keysFunc) {
|
|
return function(object4) {
|
|
var tag = getTag_default(object4);
|
|
if (tag == mapTag7) {
|
|
return mapToArray_default(object4);
|
|
}
|
|
if (tag == setTag7) {
|
|
return setToPairs_default(object4);
|
|
}
|
|
return baseToPairs_default(object4, keysFunc(object4));
|
|
};
|
|
}
|
|
var createToPairs_default = createToPairs;
|
|
|
|
// node_modules/lodash-es/toPairs.js
|
|
var toPairs = createToPairs_default(keys_default);
|
|
var toPairs_default = toPairs;
|
|
|
|
// node_modules/lodash-es/toPairsIn.js
|
|
var toPairsIn = createToPairs_default(keysIn_default);
|
|
var toPairsIn_default = toPairsIn;
|
|
|
|
// node_modules/lodash-es/_escapeHtmlChar.js
|
|
var htmlEscapes = {
|
|
"&": "&",
|
|
"<": "<",
|
|
">": ">",
|
|
'"': """,
|
|
"'": "'"
|
|
};
|
|
var escapeHtmlChar = basePropertyOf_default(htmlEscapes);
|
|
var escapeHtmlChar_default = escapeHtmlChar;
|
|
|
|
// node_modules/lodash-es/escape.js
|
|
var reUnescapedHtml = /[&<>"']/g;
|
|
var reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
|
|
function escape(string3) {
|
|
string3 = toString_default(string3);
|
|
return string3 && reHasUnescapedHtml.test(string3) ? string3.replace(reUnescapedHtml, escapeHtmlChar_default) : string3;
|
|
}
|
|
var escape_default = escape;
|
|
|
|
// node_modules/lodash-es/escapeRegExp.js
|
|
var reRegExpChar2 = /[\\^$.*+?()[\]{}|]/g;
|
|
var reHasRegExpChar = RegExp(reRegExpChar2.source);
|
|
function escapeRegExp(string3) {
|
|
string3 = toString_default(string3);
|
|
return string3 && reHasRegExpChar.test(string3) ? string3.replace(reRegExpChar2, "\\$&") : string3;
|
|
}
|
|
var escapeRegExp_default = escapeRegExp;
|
|
|
|
// node_modules/lodash-es/_arrayEvery.js
|
|
function arrayEvery(array4, predicate) {
|
|
var index = -1, length = array4 == null ? 0 : array4.length;
|
|
while (++index < length) {
|
|
if (!predicate(array4[index], index, array4)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
var arrayEvery_default = arrayEvery;
|
|
|
|
// node_modules/lodash-es/_baseEvery.js
|
|
function baseEvery(collection, predicate) {
|
|
var result2 = true;
|
|
baseEach_default(collection, function(value, index, collection2) {
|
|
result2 = !!predicate(value, index, collection2);
|
|
return result2;
|
|
});
|
|
return result2;
|
|
}
|
|
var baseEvery_default = baseEvery;
|
|
|
|
// node_modules/lodash-es/every.js
|
|
function every(collection, predicate, guard) {
|
|
var func = isArray_default(collection) ? arrayEvery_default : baseEvery_default;
|
|
if (guard && isIterateeCall_default(collection, predicate, guard)) {
|
|
predicate = void 0;
|
|
}
|
|
return func(collection, baseIteratee_default(predicate, 3));
|
|
}
|
|
var every_default = every;
|
|
|
|
// node_modules/lodash-es/toLength.js
|
|
var MAX_ARRAY_LENGTH2 = 4294967295;
|
|
function toLength(value) {
|
|
return value ? baseClamp_default(toInteger_default(value), 0, MAX_ARRAY_LENGTH2) : 0;
|
|
}
|
|
var toLength_default = toLength;
|
|
|
|
// node_modules/lodash-es/_baseFill.js
|
|
function baseFill(array4, value, start, end) {
|
|
var length = array4.length;
|
|
start = toInteger_default(start);
|
|
if (start < 0) {
|
|
start = -start > length ? 0 : length + start;
|
|
}
|
|
end = end === void 0 || end > length ? length : toInteger_default(end);
|
|
if (end < 0) {
|
|
end += length;
|
|
}
|
|
end = start > end ? 0 : toLength_default(end);
|
|
while (start < end) {
|
|
array4[start++] = value;
|
|
}
|
|
return array4;
|
|
}
|
|
var baseFill_default = baseFill;
|
|
|
|
// node_modules/lodash-es/fill.js
|
|
function fill(array4, value, start, end) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
if (!length) {
|
|
return [];
|
|
}
|
|
if (start && typeof start != "number" && isIterateeCall_default(array4, value, start)) {
|
|
start = 0;
|
|
end = length;
|
|
}
|
|
return baseFill_default(array4, value, start, end);
|
|
}
|
|
var fill_default = fill;
|
|
|
|
// node_modules/lodash-es/_baseFilter.js
|
|
function baseFilter(collection, predicate) {
|
|
var result2 = [];
|
|
baseEach_default(collection, function(value, index, collection2) {
|
|
if (predicate(value, index, collection2)) {
|
|
result2.push(value);
|
|
}
|
|
});
|
|
return result2;
|
|
}
|
|
var baseFilter_default = baseFilter;
|
|
|
|
// node_modules/lodash-es/filter.js
|
|
function filter(collection, predicate) {
|
|
var func = isArray_default(collection) ? arrayFilter_default : baseFilter_default;
|
|
return func(collection, baseIteratee_default(predicate, 3));
|
|
}
|
|
var filter_default = filter;
|
|
|
|
// node_modules/lodash-es/_createFind.js
|
|
function createFind(findIndexFunc) {
|
|
return function(collection, predicate, fromIndex) {
|
|
var iterable = Object(collection);
|
|
if (!isArrayLike_default(collection)) {
|
|
var iteratee2 = baseIteratee_default(predicate, 3);
|
|
collection = keys_default(collection);
|
|
predicate = function(key) {
|
|
return iteratee2(iterable[key], key, iterable);
|
|
};
|
|
}
|
|
var index = findIndexFunc(collection, predicate, fromIndex);
|
|
return index > -1 ? iterable[iteratee2 ? collection[index] : index] : void 0;
|
|
};
|
|
}
|
|
var createFind_default = createFind;
|
|
|
|
// node_modules/lodash-es/findIndex.js
|
|
var nativeMax7 = Math.max;
|
|
function findIndex(array4, predicate, fromIndex) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
if (!length) {
|
|
return -1;
|
|
}
|
|
var index = fromIndex == null ? 0 : toInteger_default(fromIndex);
|
|
if (index < 0) {
|
|
index = nativeMax7(length + index, 0);
|
|
}
|
|
return baseFindIndex_default(array4, baseIteratee_default(predicate, 3), index);
|
|
}
|
|
var findIndex_default = findIndex;
|
|
|
|
// node_modules/lodash-es/find.js
|
|
var find = createFind_default(findIndex_default);
|
|
var find_default = find;
|
|
|
|
// node_modules/lodash-es/_baseFindKey.js
|
|
function baseFindKey(collection, predicate, eachFunc) {
|
|
var result2;
|
|
eachFunc(collection, function(value, key, collection2) {
|
|
if (predicate(value, key, collection2)) {
|
|
result2 = key;
|
|
return false;
|
|
}
|
|
});
|
|
return result2;
|
|
}
|
|
var baseFindKey_default = baseFindKey;
|
|
|
|
// node_modules/lodash-es/findKey.js
|
|
function findKey(object4, predicate) {
|
|
return baseFindKey_default(object4, baseIteratee_default(predicate, 3), baseForOwn_default);
|
|
}
|
|
var findKey_default = findKey;
|
|
|
|
// node_modules/lodash-es/findLastIndex.js
|
|
var nativeMax8 = Math.max;
|
|
var nativeMin5 = Math.min;
|
|
function findLastIndex(array4, predicate, fromIndex) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
if (!length) {
|
|
return -1;
|
|
}
|
|
var index = length - 1;
|
|
if (fromIndex !== void 0) {
|
|
index = toInteger_default(fromIndex);
|
|
index = fromIndex < 0 ? nativeMax8(length + index, 0) : nativeMin5(index, length - 1);
|
|
}
|
|
return baseFindIndex_default(array4, baseIteratee_default(predicate, 3), index, true);
|
|
}
|
|
var findLastIndex_default = findLastIndex;
|
|
|
|
// node_modules/lodash-es/findLast.js
|
|
var findLast = createFind_default(findLastIndex_default);
|
|
var findLast_default = findLast;
|
|
|
|
// node_modules/lodash-es/findLastKey.js
|
|
function findLastKey(object4, predicate) {
|
|
return baseFindKey_default(object4, baseIteratee_default(predicate, 3), baseForOwnRight_default);
|
|
}
|
|
var findLastKey_default = findLastKey;
|
|
|
|
// node_modules/lodash-es/head.js
|
|
function head(array4) {
|
|
return array4 && array4.length ? array4[0] : void 0;
|
|
}
|
|
var head_default = head;
|
|
|
|
// node_modules/lodash-es/_baseMap.js
|
|
function baseMap(collection, iteratee2) {
|
|
var index = -1, result2 = isArrayLike_default(collection) ? Array(collection.length) : [];
|
|
baseEach_default(collection, function(value, key, collection2) {
|
|
result2[++index] = iteratee2(value, key, collection2);
|
|
});
|
|
return result2;
|
|
}
|
|
var baseMap_default = baseMap;
|
|
|
|
// node_modules/lodash-es/map.js
|
|
function map(collection, iteratee2) {
|
|
var func = isArray_default(collection) ? arrayMap_default : baseMap_default;
|
|
return func(collection, baseIteratee_default(iteratee2, 3));
|
|
}
|
|
var map_default = map;
|
|
|
|
// node_modules/lodash-es/flatMap.js
|
|
function flatMap(collection, iteratee2) {
|
|
return baseFlatten_default(map_default(collection, iteratee2), 1);
|
|
}
|
|
var flatMap_default = flatMap;
|
|
|
|
// node_modules/lodash-es/flatMapDeep.js
|
|
var INFINITY4 = 1 / 0;
|
|
function flatMapDeep(collection, iteratee2) {
|
|
return baseFlatten_default(map_default(collection, iteratee2), INFINITY4);
|
|
}
|
|
var flatMapDeep_default = flatMapDeep;
|
|
|
|
// node_modules/lodash-es/flatMapDepth.js
|
|
function flatMapDepth(collection, iteratee2, depth) {
|
|
depth = depth === void 0 ? 1 : toInteger_default(depth);
|
|
return baseFlatten_default(map_default(collection, iteratee2), depth);
|
|
}
|
|
var flatMapDepth_default = flatMapDepth;
|
|
|
|
// node_modules/lodash-es/flattenDeep.js
|
|
var INFINITY5 = 1 / 0;
|
|
function flattenDeep(array4) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
return length ? baseFlatten_default(array4, INFINITY5) : [];
|
|
}
|
|
var flattenDeep_default = flattenDeep;
|
|
|
|
// node_modules/lodash-es/flattenDepth.js
|
|
function flattenDepth(array4, depth) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
if (!length) {
|
|
return [];
|
|
}
|
|
depth = depth === void 0 ? 1 : toInteger_default(depth);
|
|
return baseFlatten_default(array4, depth);
|
|
}
|
|
var flattenDepth_default = flattenDepth;
|
|
|
|
// node_modules/lodash-es/flip.js
|
|
var WRAP_FLIP_FLAG3 = 512;
|
|
function flip(func) {
|
|
return createWrap_default(func, WRAP_FLIP_FLAG3);
|
|
}
|
|
var flip_default = flip;
|
|
|
|
// node_modules/lodash-es/floor.js
|
|
var floor = createRound_default("floor");
|
|
var floor_default = floor;
|
|
|
|
// node_modules/lodash-es/_createFlow.js
|
|
var FUNC_ERROR_TEXT8 = "Expected a function";
|
|
var WRAP_CURRY_FLAG7 = 8;
|
|
var WRAP_PARTIAL_FLAG6 = 32;
|
|
var WRAP_ARY_FLAG5 = 128;
|
|
var WRAP_REARG_FLAG3 = 256;
|
|
function createFlow(fromRight) {
|
|
return flatRest_default(function(funcs) {
|
|
var length = funcs.length, index = length, prereq = LodashWrapper_default.prototype.thru;
|
|
if (fromRight) {
|
|
funcs.reverse();
|
|
}
|
|
while (index--) {
|
|
var func = funcs[index];
|
|
if (typeof func != "function") {
|
|
throw new TypeError(FUNC_ERROR_TEXT8);
|
|
}
|
|
if (prereq && !wrapper && getFuncName_default(func) == "wrapper") {
|
|
var wrapper = new LodashWrapper_default([], true);
|
|
}
|
|
}
|
|
index = wrapper ? index : length;
|
|
while (++index < length) {
|
|
func = funcs[index];
|
|
var funcName = getFuncName_default(func), data = funcName == "wrapper" ? getData_default(func) : void 0;
|
|
if (data && isLaziable_default(data[0]) && data[1] == (WRAP_ARY_FLAG5 | WRAP_CURRY_FLAG7 | WRAP_PARTIAL_FLAG6 | WRAP_REARG_FLAG3) && !data[4].length && data[9] == 1) {
|
|
wrapper = wrapper[getFuncName_default(data[0])].apply(wrapper, data[3]);
|
|
} else {
|
|
wrapper = func.length == 1 && isLaziable_default(func) ? wrapper[funcName]() : wrapper.thru(func);
|
|
}
|
|
}
|
|
return function() {
|
|
var args = arguments, value = args[0];
|
|
if (wrapper && args.length == 1 && isArray_default(value)) {
|
|
return wrapper.plant(value).value();
|
|
}
|
|
var index2 = 0, result2 = length ? funcs[index2].apply(this, args) : value;
|
|
while (++index2 < length) {
|
|
result2 = funcs[index2].call(this, result2);
|
|
}
|
|
return result2;
|
|
};
|
|
});
|
|
}
|
|
var createFlow_default = createFlow;
|
|
|
|
// node_modules/lodash-es/flow.js
|
|
var flow = createFlow_default();
|
|
var flow_default = flow;
|
|
|
|
// node_modules/lodash-es/flowRight.js
|
|
var flowRight = createFlow_default(true);
|
|
var flowRight_default = flowRight;
|
|
|
|
// node_modules/lodash-es/forIn.js
|
|
function forIn(object4, iteratee2) {
|
|
return object4 == null ? object4 : baseFor_default(object4, castFunction_default(iteratee2), keysIn_default);
|
|
}
|
|
var forIn_default = forIn;
|
|
|
|
// node_modules/lodash-es/forInRight.js
|
|
function forInRight(object4, iteratee2) {
|
|
return object4 == null ? object4 : baseForRight_default(object4, castFunction_default(iteratee2), keysIn_default);
|
|
}
|
|
var forInRight_default = forInRight;
|
|
|
|
// node_modules/lodash-es/forOwn.js
|
|
function forOwn(object4, iteratee2) {
|
|
return object4 && baseForOwn_default(object4, castFunction_default(iteratee2));
|
|
}
|
|
var forOwn_default = forOwn;
|
|
|
|
// node_modules/lodash-es/forOwnRight.js
|
|
function forOwnRight(object4, iteratee2) {
|
|
return object4 && baseForOwnRight_default(object4, castFunction_default(iteratee2));
|
|
}
|
|
var forOwnRight_default = forOwnRight;
|
|
|
|
// node_modules/lodash-es/fromPairs.js
|
|
function fromPairs(pairs) {
|
|
var index = -1, length = pairs == null ? 0 : pairs.length, result2 = {};
|
|
while (++index < length) {
|
|
var pair = pairs[index];
|
|
result2[pair[0]] = pair[1];
|
|
}
|
|
return result2;
|
|
}
|
|
var fromPairs_default = fromPairs;
|
|
|
|
// node_modules/lodash-es/_baseFunctions.js
|
|
function baseFunctions(object4, props2) {
|
|
return arrayFilter_default(props2, function(key) {
|
|
return isFunction_default(object4[key]);
|
|
});
|
|
}
|
|
var baseFunctions_default = baseFunctions;
|
|
|
|
// node_modules/lodash-es/functions.js
|
|
function functions(object4) {
|
|
return object4 == null ? [] : baseFunctions_default(object4, keys_default(object4));
|
|
}
|
|
var functions_default = functions;
|
|
|
|
// node_modules/lodash-es/functionsIn.js
|
|
function functionsIn(object4) {
|
|
return object4 == null ? [] : baseFunctions_default(object4, keysIn_default(object4));
|
|
}
|
|
var functionsIn_default = functionsIn;
|
|
|
|
// node_modules/lodash-es/groupBy.js
|
|
var objectProto22 = Object.prototype;
|
|
var hasOwnProperty19 = objectProto22.hasOwnProperty;
|
|
var groupBy = createAggregator_default(function(result2, value, key) {
|
|
if (hasOwnProperty19.call(result2, key)) {
|
|
result2[key].push(value);
|
|
} else {
|
|
baseAssignValue_default(result2, key, [value]);
|
|
}
|
|
});
|
|
var groupBy_default = groupBy;
|
|
|
|
// node_modules/lodash-es/_baseGt.js
|
|
function baseGt(value, other) {
|
|
return value > other;
|
|
}
|
|
var baseGt_default = baseGt;
|
|
|
|
// node_modules/lodash-es/_createRelationalOperation.js
|
|
function createRelationalOperation(operator) {
|
|
return function(value, other) {
|
|
if (!(typeof value == "string" && typeof other == "string")) {
|
|
value = toNumber_default(value);
|
|
other = toNumber_default(other);
|
|
}
|
|
return operator(value, other);
|
|
};
|
|
}
|
|
var createRelationalOperation_default = createRelationalOperation;
|
|
|
|
// node_modules/lodash-es/gt.js
|
|
var gt = createRelationalOperation_default(baseGt_default);
|
|
var gt_default = gt;
|
|
|
|
// node_modules/lodash-es/gte.js
|
|
var gte = createRelationalOperation_default(function(value, other) {
|
|
return value >= other;
|
|
});
|
|
var gte_default = gte;
|
|
|
|
// node_modules/lodash-es/_baseHas.js
|
|
var objectProto23 = Object.prototype;
|
|
var hasOwnProperty20 = objectProto23.hasOwnProperty;
|
|
function baseHas(object4, key) {
|
|
return object4 != null && hasOwnProperty20.call(object4, key);
|
|
}
|
|
var baseHas_default = baseHas;
|
|
|
|
// node_modules/lodash-es/has.js
|
|
function has(object4, path) {
|
|
return object4 != null && hasPath_default(object4, path, baseHas_default);
|
|
}
|
|
var has_default = has;
|
|
|
|
// node_modules/lodash-es/_baseInRange.js
|
|
var nativeMax9 = Math.max;
|
|
var nativeMin6 = Math.min;
|
|
function baseInRange(number4, start, end) {
|
|
return number4 >= nativeMin6(start, end) && number4 < nativeMax9(start, end);
|
|
}
|
|
var baseInRange_default = baseInRange;
|
|
|
|
// node_modules/lodash-es/inRange.js
|
|
function inRange(number4, start, end) {
|
|
start = toFinite_default(start);
|
|
if (end === void 0) {
|
|
end = start;
|
|
start = 0;
|
|
} else {
|
|
end = toFinite_default(end);
|
|
}
|
|
number4 = toNumber_default(number4);
|
|
return baseInRange_default(number4, start, end);
|
|
}
|
|
var inRange_default = inRange;
|
|
|
|
// node_modules/lodash-es/isString.js
|
|
var stringTag5 = "[object String]";
|
|
function isString2(value) {
|
|
return typeof value == "string" || !isArray_default(value) && isObjectLike_default(value) && baseGetTag_default(value) == stringTag5;
|
|
}
|
|
var isString_default = isString2;
|
|
|
|
// node_modules/lodash-es/_baseValues.js
|
|
function baseValues(object4, props2) {
|
|
return arrayMap_default(props2, function(key) {
|
|
return object4[key];
|
|
});
|
|
}
|
|
var baseValues_default = baseValues;
|
|
|
|
// node_modules/lodash-es/values.js
|
|
function values(object4) {
|
|
return object4 == null ? [] : baseValues_default(object4, keys_default(object4));
|
|
}
|
|
var values_default = values;
|
|
|
|
// node_modules/lodash-es/includes.js
|
|
var nativeMax10 = Math.max;
|
|
function includes(collection, value, fromIndex, guard) {
|
|
collection = isArrayLike_default(collection) ? collection : values_default(collection);
|
|
fromIndex = fromIndex && !guard ? toInteger_default(fromIndex) : 0;
|
|
var length = collection.length;
|
|
if (fromIndex < 0) {
|
|
fromIndex = nativeMax10(length + fromIndex, 0);
|
|
}
|
|
return isString_default(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf_default(collection, value, fromIndex) > -1;
|
|
}
|
|
var includes_default = includes;
|
|
|
|
// node_modules/lodash-es/indexOf.js
|
|
var nativeMax11 = Math.max;
|
|
function indexOf(array4, value, fromIndex) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
if (!length) {
|
|
return -1;
|
|
}
|
|
var index = fromIndex == null ? 0 : toInteger_default(fromIndex);
|
|
if (index < 0) {
|
|
index = nativeMax11(length + index, 0);
|
|
}
|
|
return baseIndexOf_default(array4, value, index);
|
|
}
|
|
var indexOf_default = indexOf;
|
|
|
|
// node_modules/lodash-es/initial.js
|
|
function initial(array4) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
return length ? baseSlice_default(array4, 0, -1) : [];
|
|
}
|
|
var initial_default = initial;
|
|
|
|
// node_modules/lodash-es/_baseIntersection.js
|
|
var nativeMin7 = Math.min;
|
|
function baseIntersection(arrays, iteratee2, comparator) {
|
|
var includes2 = comparator ? arrayIncludesWith_default : arrayIncludes_default, length = arrays[0].length, othLength = arrays.length, othIndex = othLength, caches = Array(othLength), maxLength = Infinity, result2 = [];
|
|
while (othIndex--) {
|
|
var array4 = arrays[othIndex];
|
|
if (othIndex && iteratee2) {
|
|
array4 = arrayMap_default(array4, baseUnary_default(iteratee2));
|
|
}
|
|
maxLength = nativeMin7(array4.length, maxLength);
|
|
caches[othIndex] = !comparator && (iteratee2 || length >= 120 && array4.length >= 120) ? new SetCache_default(othIndex && array4) : void 0;
|
|
}
|
|
array4 = arrays[0];
|
|
var index = -1, seen = caches[0];
|
|
outer:
|
|
while (++index < length && result2.length < maxLength) {
|
|
var value = array4[index], computed2 = iteratee2 ? iteratee2(value) : value;
|
|
value = comparator || value !== 0 ? value : 0;
|
|
if (!(seen ? cacheHas_default(seen, computed2) : includes2(result2, computed2, comparator))) {
|
|
othIndex = othLength;
|
|
while (--othIndex) {
|
|
var cache2 = caches[othIndex];
|
|
if (!(cache2 ? cacheHas_default(cache2, computed2) : includes2(arrays[othIndex], computed2, comparator))) {
|
|
continue outer;
|
|
}
|
|
}
|
|
if (seen) {
|
|
seen.push(computed2);
|
|
}
|
|
result2.push(value);
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var baseIntersection_default = baseIntersection;
|
|
|
|
// node_modules/lodash-es/_castArrayLikeObject.js
|
|
function castArrayLikeObject(value) {
|
|
return isArrayLikeObject_default(value) ? value : [];
|
|
}
|
|
var castArrayLikeObject_default = castArrayLikeObject;
|
|
|
|
// node_modules/lodash-es/intersection.js
|
|
var intersection = baseRest_default(function(arrays) {
|
|
var mapped = arrayMap_default(arrays, castArrayLikeObject_default);
|
|
return mapped.length && mapped[0] === arrays[0] ? baseIntersection_default(mapped) : [];
|
|
});
|
|
var intersection_default = intersection;
|
|
|
|
// node_modules/lodash-es/intersectionBy.js
|
|
var intersectionBy = baseRest_default(function(arrays) {
|
|
var iteratee2 = last_default(arrays), mapped = arrayMap_default(arrays, castArrayLikeObject_default);
|
|
if (iteratee2 === last_default(mapped)) {
|
|
iteratee2 = void 0;
|
|
} else {
|
|
mapped.pop();
|
|
}
|
|
return mapped.length && mapped[0] === arrays[0] ? baseIntersection_default(mapped, baseIteratee_default(iteratee2, 2)) : [];
|
|
});
|
|
var intersectionBy_default = intersectionBy;
|
|
|
|
// node_modules/lodash-es/intersectionWith.js
|
|
var intersectionWith = baseRest_default(function(arrays) {
|
|
var comparator = last_default(arrays), mapped = arrayMap_default(arrays, castArrayLikeObject_default);
|
|
comparator = typeof comparator == "function" ? comparator : void 0;
|
|
if (comparator) {
|
|
mapped.pop();
|
|
}
|
|
return mapped.length && mapped[0] === arrays[0] ? baseIntersection_default(mapped, void 0, comparator) : [];
|
|
});
|
|
var intersectionWith_default = intersectionWith;
|
|
|
|
// node_modules/lodash-es/_baseInverter.js
|
|
function baseInverter(object4, setter, iteratee2, accumulator) {
|
|
baseForOwn_default(object4, function(value, key, object5) {
|
|
setter(accumulator, iteratee2(value), key, object5);
|
|
});
|
|
return accumulator;
|
|
}
|
|
var baseInverter_default = baseInverter;
|
|
|
|
// node_modules/lodash-es/_createInverter.js
|
|
function createInverter(setter, toIteratee) {
|
|
return function(object4, iteratee2) {
|
|
return baseInverter_default(object4, setter, toIteratee(iteratee2), {});
|
|
};
|
|
}
|
|
var createInverter_default = createInverter;
|
|
|
|
// node_modules/lodash-es/invert.js
|
|
var objectProto24 = Object.prototype;
|
|
var nativeObjectToString3 = objectProto24.toString;
|
|
var invert = createInverter_default(function(result2, value, key) {
|
|
if (value != null && typeof value.toString != "function") {
|
|
value = nativeObjectToString3.call(value);
|
|
}
|
|
result2[value] = key;
|
|
}, constant_default(identity_default));
|
|
var invert_default = invert;
|
|
|
|
// node_modules/lodash-es/invertBy.js
|
|
var objectProto25 = Object.prototype;
|
|
var hasOwnProperty21 = objectProto25.hasOwnProperty;
|
|
var nativeObjectToString4 = objectProto25.toString;
|
|
var invertBy = createInverter_default(function(result2, value, key) {
|
|
if (value != null && typeof value.toString != "function") {
|
|
value = nativeObjectToString4.call(value);
|
|
}
|
|
if (hasOwnProperty21.call(result2, value)) {
|
|
result2[value].push(key);
|
|
} else {
|
|
result2[value] = [key];
|
|
}
|
|
}, baseIteratee_default);
|
|
var invertBy_default = invertBy;
|
|
|
|
// node_modules/lodash-es/_parent.js
|
|
function parent(object4, path) {
|
|
return path.length < 2 ? object4 : baseGet_default(object4, baseSlice_default(path, 0, -1));
|
|
}
|
|
var parent_default = parent;
|
|
|
|
// node_modules/lodash-es/_baseInvoke.js
|
|
function baseInvoke(object4, path, args) {
|
|
path = castPath_default(path, object4);
|
|
object4 = parent_default(object4, path);
|
|
var func = object4 == null ? object4 : object4[toKey_default(last_default(path))];
|
|
return func == null ? void 0 : apply_default(func, object4, args);
|
|
}
|
|
var baseInvoke_default = baseInvoke;
|
|
|
|
// node_modules/lodash-es/invoke.js
|
|
var invoke = baseRest_default(baseInvoke_default);
|
|
var invoke_default = invoke;
|
|
|
|
// node_modules/lodash-es/invokeMap.js
|
|
var invokeMap = baseRest_default(function(collection, path, args) {
|
|
var index = -1, isFunc = typeof path == "function", result2 = isArrayLike_default(collection) ? Array(collection.length) : [];
|
|
baseEach_default(collection, function(value) {
|
|
result2[++index] = isFunc ? apply_default(path, value, args) : baseInvoke_default(value, path, args);
|
|
});
|
|
return result2;
|
|
});
|
|
var invokeMap_default = invokeMap;
|
|
|
|
// node_modules/lodash-es/_baseIsArrayBuffer.js
|
|
var arrayBufferTag5 = "[object ArrayBuffer]";
|
|
function baseIsArrayBuffer(value) {
|
|
return isObjectLike_default(value) && baseGetTag_default(value) == arrayBufferTag5;
|
|
}
|
|
var baseIsArrayBuffer_default = baseIsArrayBuffer;
|
|
|
|
// node_modules/lodash-es/isArrayBuffer.js
|
|
var nodeIsArrayBuffer = nodeUtil_default && nodeUtil_default.isArrayBuffer;
|
|
var isArrayBuffer = nodeIsArrayBuffer ? baseUnary_default(nodeIsArrayBuffer) : baseIsArrayBuffer_default;
|
|
var isArrayBuffer_default = isArrayBuffer;
|
|
|
|
// node_modules/lodash-es/isBoolean.js
|
|
var boolTag5 = "[object Boolean]";
|
|
function isBoolean(value) {
|
|
return value === true || value === false || isObjectLike_default(value) && baseGetTag_default(value) == boolTag5;
|
|
}
|
|
var isBoolean_default = isBoolean;
|
|
|
|
// node_modules/lodash-es/_baseIsDate.js
|
|
var dateTag5 = "[object Date]";
|
|
function baseIsDate(value) {
|
|
return isObjectLike_default(value) && baseGetTag_default(value) == dateTag5;
|
|
}
|
|
var baseIsDate_default = baseIsDate;
|
|
|
|
// node_modules/lodash-es/isDate.js
|
|
var nodeIsDate = nodeUtil_default && nodeUtil_default.isDate;
|
|
var isDate2 = nodeIsDate ? baseUnary_default(nodeIsDate) : baseIsDate_default;
|
|
var isDate_default = isDate2;
|
|
|
|
// node_modules/lodash-es/isElement.js
|
|
function isElement(value) {
|
|
return isObjectLike_default(value) && value.nodeType === 1 && !isPlainObject_default(value);
|
|
}
|
|
var isElement_default = isElement;
|
|
|
|
// node_modules/lodash-es/isEmpty.js
|
|
var mapTag8 = "[object Map]";
|
|
var setTag8 = "[object Set]";
|
|
var objectProto26 = Object.prototype;
|
|
var hasOwnProperty22 = objectProto26.hasOwnProperty;
|
|
function isEmpty(value) {
|
|
if (value == null) {
|
|
return true;
|
|
}
|
|
if (isArrayLike_default(value) && (isArray_default(value) || typeof value == "string" || typeof value.splice == "function" || isBuffer_default(value) || isTypedArray_default(value) || isArguments_default(value))) {
|
|
return !value.length;
|
|
}
|
|
var tag = getTag_default(value);
|
|
if (tag == mapTag8 || tag == setTag8) {
|
|
return !value.size;
|
|
}
|
|
if (isPrototype_default(value)) {
|
|
return !baseKeys_default(value).length;
|
|
}
|
|
for (var key in value) {
|
|
if (hasOwnProperty22.call(value, key)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
var isEmpty_default = isEmpty;
|
|
|
|
// node_modules/lodash-es/isEqual.js
|
|
function isEqual(value, other) {
|
|
return baseIsEqual_default(value, other);
|
|
}
|
|
var isEqual_default = isEqual;
|
|
|
|
// node_modules/lodash-es/isEqualWith.js
|
|
function isEqualWith(value, other, customizer) {
|
|
customizer = typeof customizer == "function" ? customizer : void 0;
|
|
var result2 = customizer ? customizer(value, other) : void 0;
|
|
return result2 === void 0 ? baseIsEqual_default(value, other, void 0, customizer) : !!result2;
|
|
}
|
|
var isEqualWith_default = isEqualWith;
|
|
|
|
// node_modules/lodash-es/isFinite.js
|
|
var nativeIsFinite2 = root_default.isFinite;
|
|
function isFinite(value) {
|
|
return typeof value == "number" && nativeIsFinite2(value);
|
|
}
|
|
var isFinite_default = isFinite;
|
|
|
|
// node_modules/lodash-es/isInteger.js
|
|
function isInteger(value) {
|
|
return typeof value == "number" && value == toInteger_default(value);
|
|
}
|
|
var isInteger_default = isInteger;
|
|
|
|
// node_modules/lodash-es/isMatch.js
|
|
function isMatch(object4, source) {
|
|
return object4 === source || baseIsMatch_default(object4, source, getMatchData_default(source));
|
|
}
|
|
var isMatch_default = isMatch;
|
|
|
|
// node_modules/lodash-es/isMatchWith.js
|
|
function isMatchWith(object4, source, customizer) {
|
|
customizer = typeof customizer == "function" ? customizer : void 0;
|
|
return baseIsMatch_default(object4, source, getMatchData_default(source), customizer);
|
|
}
|
|
var isMatchWith_default = isMatchWith;
|
|
|
|
// node_modules/lodash-es/isNumber.js
|
|
var numberTag5 = "[object Number]";
|
|
function isNumber(value) {
|
|
return typeof value == "number" || isObjectLike_default(value) && baseGetTag_default(value) == numberTag5;
|
|
}
|
|
var isNumber_default = isNumber;
|
|
|
|
// node_modules/lodash-es/isNaN.js
|
|
function isNaN2(value) {
|
|
return isNumber_default(value) && value != +value;
|
|
}
|
|
var isNaN_default = isNaN2;
|
|
|
|
// node_modules/lodash-es/_isMaskable.js
|
|
var isMaskable = coreJsData_default ? isFunction_default : stubFalse_default;
|
|
var isMaskable_default = isMaskable;
|
|
|
|
// node_modules/lodash-es/isNative.js
|
|
var CORE_ERROR_TEXT = "Unsupported core-js use. Try https://npms.io/search?q=ponyfill.";
|
|
function isNative(value) {
|
|
if (isMaskable_default(value)) {
|
|
throw new Error(CORE_ERROR_TEXT);
|
|
}
|
|
return baseIsNative_default(value);
|
|
}
|
|
var isNative_default = isNative;
|
|
|
|
// node_modules/lodash-es/isNil.js
|
|
function isNil(value) {
|
|
return value == null;
|
|
}
|
|
var isNil_default = isNil;
|
|
|
|
// node_modules/lodash-es/isNull.js
|
|
function isNull(value) {
|
|
return value === null;
|
|
}
|
|
var isNull_default = isNull;
|
|
|
|
// node_modules/lodash-es/_baseIsRegExp.js
|
|
var regexpTag5 = "[object RegExp]";
|
|
function baseIsRegExp(value) {
|
|
return isObjectLike_default(value) && baseGetTag_default(value) == regexpTag5;
|
|
}
|
|
var baseIsRegExp_default = baseIsRegExp;
|
|
|
|
// node_modules/lodash-es/isRegExp.js
|
|
var nodeIsRegExp = nodeUtil_default && nodeUtil_default.isRegExp;
|
|
var isRegExp = nodeIsRegExp ? baseUnary_default(nodeIsRegExp) : baseIsRegExp_default;
|
|
var isRegExp_default = isRegExp;
|
|
|
|
// node_modules/lodash-es/isSafeInteger.js
|
|
var MAX_SAFE_INTEGER3 = 9007199254740991;
|
|
function isSafeInteger(value) {
|
|
return isInteger_default(value) && value >= -MAX_SAFE_INTEGER3 && value <= MAX_SAFE_INTEGER3;
|
|
}
|
|
var isSafeInteger_default = isSafeInteger;
|
|
|
|
// node_modules/lodash-es/isUndefined.js
|
|
function isUndefined(value) {
|
|
return value === void 0;
|
|
}
|
|
var isUndefined_default = isUndefined;
|
|
|
|
// node_modules/lodash-es/isWeakMap.js
|
|
var weakMapTag4 = "[object WeakMap]";
|
|
function isWeakMap(value) {
|
|
return isObjectLike_default(value) && getTag_default(value) == weakMapTag4;
|
|
}
|
|
var isWeakMap_default = isWeakMap;
|
|
|
|
// node_modules/lodash-es/isWeakSet.js
|
|
var weakSetTag = "[object WeakSet]";
|
|
function isWeakSet(value) {
|
|
return isObjectLike_default(value) && baseGetTag_default(value) == weakSetTag;
|
|
}
|
|
var isWeakSet_default = isWeakSet;
|
|
|
|
// node_modules/lodash-es/iteratee.js
|
|
var CLONE_DEEP_FLAG5 = 1;
|
|
function iteratee(func) {
|
|
return baseIteratee_default(typeof func == "function" ? func : baseClone_default(func, CLONE_DEEP_FLAG5));
|
|
}
|
|
var iteratee_default = iteratee;
|
|
|
|
// node_modules/lodash-es/join.js
|
|
var arrayProto2 = Array.prototype;
|
|
var nativeJoin = arrayProto2.join;
|
|
function join(array4, separator) {
|
|
return array4 == null ? "" : nativeJoin.call(array4, separator);
|
|
}
|
|
var join_default = join;
|
|
|
|
// node_modules/lodash-es/kebabCase.js
|
|
var kebabCase = createCompounder_default(function(result2, word, index) {
|
|
return result2 + (index ? "-" : "") + word.toLowerCase();
|
|
});
|
|
var kebabCase_default = kebabCase;
|
|
|
|
// node_modules/lodash-es/keyBy.js
|
|
var keyBy = createAggregator_default(function(result2, value, key) {
|
|
baseAssignValue_default(result2, key, value);
|
|
});
|
|
var keyBy_default = keyBy;
|
|
|
|
// node_modules/lodash-es/_strictLastIndexOf.js
|
|
function strictLastIndexOf(array4, value, fromIndex) {
|
|
var index = fromIndex + 1;
|
|
while (index--) {
|
|
if (array4[index] === value) {
|
|
return index;
|
|
}
|
|
}
|
|
return index;
|
|
}
|
|
var strictLastIndexOf_default = strictLastIndexOf;
|
|
|
|
// node_modules/lodash-es/lastIndexOf.js
|
|
var nativeMax12 = Math.max;
|
|
var nativeMin8 = Math.min;
|
|
function lastIndexOf(array4, value, fromIndex) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
if (!length) {
|
|
return -1;
|
|
}
|
|
var index = length;
|
|
if (fromIndex !== void 0) {
|
|
index = toInteger_default(fromIndex);
|
|
index = index < 0 ? nativeMax12(length + index, 0) : nativeMin8(index, length - 1);
|
|
}
|
|
return value === value ? strictLastIndexOf_default(array4, value, index) : baseFindIndex_default(array4, baseIsNaN_default, index, true);
|
|
}
|
|
var lastIndexOf_default = lastIndexOf;
|
|
|
|
// node_modules/lodash-es/lowerCase.js
|
|
var lowerCase = createCompounder_default(function(result2, word, index) {
|
|
return result2 + (index ? " " : "") + word.toLowerCase();
|
|
});
|
|
var lowerCase_default = lowerCase;
|
|
|
|
// node_modules/lodash-es/lowerFirst.js
|
|
var lowerFirst = createCaseFirst_default("toLowerCase");
|
|
var lowerFirst_default = lowerFirst;
|
|
|
|
// node_modules/lodash-es/_baseLt.js
|
|
function baseLt(value, other) {
|
|
return value < other;
|
|
}
|
|
var baseLt_default = baseLt;
|
|
|
|
// node_modules/lodash-es/lt.js
|
|
var lt = createRelationalOperation_default(baseLt_default);
|
|
var lt_default = lt;
|
|
|
|
// node_modules/lodash-es/lte.js
|
|
var lte = createRelationalOperation_default(function(value, other) {
|
|
return value <= other;
|
|
});
|
|
var lte_default = lte;
|
|
|
|
// node_modules/lodash-es/mapKeys.js
|
|
function mapKeys(object4, iteratee2) {
|
|
var result2 = {};
|
|
iteratee2 = baseIteratee_default(iteratee2, 3);
|
|
baseForOwn_default(object4, function(value, key, object5) {
|
|
baseAssignValue_default(result2, iteratee2(value, key, object5), value);
|
|
});
|
|
return result2;
|
|
}
|
|
var mapKeys_default = mapKeys;
|
|
|
|
// node_modules/lodash-es/mapValues.js
|
|
function mapValues(object4, iteratee2) {
|
|
var result2 = {};
|
|
iteratee2 = baseIteratee_default(iteratee2, 3);
|
|
baseForOwn_default(object4, function(value, key, object5) {
|
|
baseAssignValue_default(result2, key, iteratee2(value, key, object5));
|
|
});
|
|
return result2;
|
|
}
|
|
var mapValues_default = mapValues;
|
|
|
|
// node_modules/lodash-es/matches.js
|
|
var CLONE_DEEP_FLAG6 = 1;
|
|
function matches(source) {
|
|
return baseMatches_default(baseClone_default(source, CLONE_DEEP_FLAG6));
|
|
}
|
|
var matches_default = matches;
|
|
|
|
// node_modules/lodash-es/matchesProperty.js
|
|
var CLONE_DEEP_FLAG7 = 1;
|
|
function matchesProperty(path, srcValue) {
|
|
return baseMatchesProperty_default(path, baseClone_default(srcValue, CLONE_DEEP_FLAG7));
|
|
}
|
|
var matchesProperty_default = matchesProperty;
|
|
|
|
// node_modules/lodash-es/_baseExtremum.js
|
|
function baseExtremum(array4, iteratee2, comparator) {
|
|
var index = -1, length = array4.length;
|
|
while (++index < length) {
|
|
var value = array4[index], current = iteratee2(value);
|
|
if (current != null && (computed2 === void 0 ? current === current && !isSymbol_default(current) : comparator(current, computed2))) {
|
|
var computed2 = current, result2 = value;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var baseExtremum_default = baseExtremum;
|
|
|
|
// node_modules/lodash-es/max.js
|
|
function max(array4) {
|
|
return array4 && array4.length ? baseExtremum_default(array4, identity_default, baseGt_default) : void 0;
|
|
}
|
|
var max_default = max;
|
|
|
|
// node_modules/lodash-es/maxBy.js
|
|
function maxBy(array4, iteratee2) {
|
|
return array4 && array4.length ? baseExtremum_default(array4, baseIteratee_default(iteratee2, 2), baseGt_default) : void 0;
|
|
}
|
|
var maxBy_default = maxBy;
|
|
|
|
// node_modules/lodash-es/_baseSum.js
|
|
function baseSum(array4, iteratee2) {
|
|
var result2, index = -1, length = array4.length;
|
|
while (++index < length) {
|
|
var current = iteratee2(array4[index]);
|
|
if (current !== void 0) {
|
|
result2 = result2 === void 0 ? current : result2 + current;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var baseSum_default = baseSum;
|
|
|
|
// node_modules/lodash-es/_baseMean.js
|
|
var NAN3 = 0 / 0;
|
|
function baseMean(array4, iteratee2) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
return length ? baseSum_default(array4, iteratee2) / length : NAN3;
|
|
}
|
|
var baseMean_default = baseMean;
|
|
|
|
// node_modules/lodash-es/mean.js
|
|
function mean(array4) {
|
|
return baseMean_default(array4, identity_default);
|
|
}
|
|
var mean_default = mean;
|
|
|
|
// node_modules/lodash-es/meanBy.js
|
|
function meanBy(array4, iteratee2) {
|
|
return baseMean_default(array4, baseIteratee_default(iteratee2, 2));
|
|
}
|
|
var meanBy_default = meanBy;
|
|
|
|
// node_modules/lodash-es/merge.js
|
|
var merge = createAssigner_default(function(object4, source, srcIndex) {
|
|
baseMerge_default(object4, source, srcIndex);
|
|
});
|
|
var merge_default = merge;
|
|
|
|
// node_modules/lodash-es/method.js
|
|
var method = baseRest_default(function(path, args) {
|
|
return function(object4) {
|
|
return baseInvoke_default(object4, path, args);
|
|
};
|
|
});
|
|
var method_default = method;
|
|
|
|
// node_modules/lodash-es/methodOf.js
|
|
var methodOf = baseRest_default(function(object4, args) {
|
|
return function(path) {
|
|
return baseInvoke_default(object4, path, args);
|
|
};
|
|
});
|
|
var methodOf_default = methodOf;
|
|
|
|
// node_modules/lodash-es/min.js
|
|
function min(array4) {
|
|
return array4 && array4.length ? baseExtremum_default(array4, identity_default, baseLt_default) : void 0;
|
|
}
|
|
var min_default = min;
|
|
|
|
// node_modules/lodash-es/minBy.js
|
|
function minBy(array4, iteratee2) {
|
|
return array4 && array4.length ? baseExtremum_default(array4, baseIteratee_default(iteratee2, 2), baseLt_default) : void 0;
|
|
}
|
|
var minBy_default = minBy;
|
|
|
|
// node_modules/lodash-es/mixin.js
|
|
function mixin(object4, source, options) {
|
|
var props2 = keys_default(source), methodNames = baseFunctions_default(source, props2);
|
|
var chain2 = !(isObject_default(options) && "chain" in options) || !!options.chain, isFunc = isFunction_default(object4);
|
|
arrayEach_default(methodNames, function(methodName) {
|
|
var func = source[methodName];
|
|
object4[methodName] = func;
|
|
if (isFunc) {
|
|
object4.prototype[methodName] = function() {
|
|
var chainAll = this.__chain__;
|
|
if (chain2 || chainAll) {
|
|
var result2 = object4(this.__wrapped__), actions = result2.__actions__ = copyArray_default(this.__actions__);
|
|
actions.push({ "func": func, "args": arguments, "thisArg": object4 });
|
|
result2.__chain__ = chainAll;
|
|
return result2;
|
|
}
|
|
return func.apply(object4, arrayPush_default([this.value()], arguments));
|
|
};
|
|
}
|
|
});
|
|
return object4;
|
|
}
|
|
var mixin_default = mixin;
|
|
|
|
// node_modules/lodash-es/multiply.js
|
|
var multiply = createMathOperation_default(function(multiplier, multiplicand) {
|
|
return multiplier * multiplicand;
|
|
}, 1);
|
|
var multiply_default = multiply;
|
|
|
|
// node_modules/lodash-es/negate.js
|
|
var FUNC_ERROR_TEXT9 = "Expected a function";
|
|
function negate(predicate) {
|
|
if (typeof predicate != "function") {
|
|
throw new TypeError(FUNC_ERROR_TEXT9);
|
|
}
|
|
return function() {
|
|
var args = arguments;
|
|
switch (args.length) {
|
|
case 0:
|
|
return !predicate.call(this);
|
|
case 1:
|
|
return !predicate.call(this, args[0]);
|
|
case 2:
|
|
return !predicate.call(this, args[0], args[1]);
|
|
case 3:
|
|
return !predicate.call(this, args[0], args[1], args[2]);
|
|
}
|
|
return !predicate.apply(this, args);
|
|
};
|
|
}
|
|
var negate_default = negate;
|
|
|
|
// node_modules/lodash-es/_iteratorToArray.js
|
|
function iteratorToArray(iterator) {
|
|
var data, result2 = [];
|
|
while (!(data = iterator.next()).done) {
|
|
result2.push(data.value);
|
|
}
|
|
return result2;
|
|
}
|
|
var iteratorToArray_default = iteratorToArray;
|
|
|
|
// node_modules/lodash-es/toArray.js
|
|
var mapTag9 = "[object Map]";
|
|
var setTag9 = "[object Set]";
|
|
var symIterator = Symbol_default ? Symbol_default.iterator : void 0;
|
|
function toArray(value) {
|
|
if (!value) {
|
|
return [];
|
|
}
|
|
if (isArrayLike_default(value)) {
|
|
return isString_default(value) ? stringToArray_default(value) : copyArray_default(value);
|
|
}
|
|
if (symIterator && value[symIterator]) {
|
|
return iteratorToArray_default(value[symIterator]());
|
|
}
|
|
var tag = getTag_default(value), func = tag == mapTag9 ? mapToArray_default : tag == setTag9 ? setToArray_default : values_default;
|
|
return func(value);
|
|
}
|
|
var toArray_default = toArray;
|
|
|
|
// node_modules/lodash-es/next.js
|
|
function wrapperNext() {
|
|
if (this.__values__ === void 0) {
|
|
this.__values__ = toArray_default(this.value());
|
|
}
|
|
var done = this.__index__ >= this.__values__.length, value = done ? void 0 : this.__values__[this.__index__++];
|
|
return { "done": done, "value": value };
|
|
}
|
|
var next_default = wrapperNext;
|
|
|
|
// node_modules/lodash-es/_baseNth.js
|
|
function baseNth(array4, n) {
|
|
var length = array4.length;
|
|
if (!length) {
|
|
return;
|
|
}
|
|
n += n < 0 ? length : 0;
|
|
return isIndex_default(n, length) ? array4[n] : void 0;
|
|
}
|
|
var baseNth_default = baseNth;
|
|
|
|
// node_modules/lodash-es/nth.js
|
|
function nth(array4, n) {
|
|
return array4 && array4.length ? baseNth_default(array4, toInteger_default(n)) : void 0;
|
|
}
|
|
var nth_default = nth;
|
|
|
|
// node_modules/lodash-es/nthArg.js
|
|
function nthArg(n) {
|
|
n = toInteger_default(n);
|
|
return baseRest_default(function(args) {
|
|
return baseNth_default(args, n);
|
|
});
|
|
}
|
|
var nthArg_default = nthArg;
|
|
|
|
// node_modules/lodash-es/_baseUnset.js
|
|
function baseUnset(object4, path) {
|
|
path = castPath_default(path, object4);
|
|
object4 = parent_default(object4, path);
|
|
return object4 == null || delete object4[toKey_default(last_default(path))];
|
|
}
|
|
var baseUnset_default = baseUnset;
|
|
|
|
// node_modules/lodash-es/_customOmitClone.js
|
|
function customOmitClone(value) {
|
|
return isPlainObject_default(value) ? void 0 : value;
|
|
}
|
|
var customOmitClone_default = customOmitClone;
|
|
|
|
// node_modules/lodash-es/omit.js
|
|
var CLONE_DEEP_FLAG8 = 1;
|
|
var CLONE_FLAT_FLAG2 = 2;
|
|
var CLONE_SYMBOLS_FLAG6 = 4;
|
|
var omit = flatRest_default(function(object4, paths) {
|
|
var result2 = {};
|
|
if (object4 == null) {
|
|
return result2;
|
|
}
|
|
var isDeep = false;
|
|
paths = arrayMap_default(paths, function(path) {
|
|
path = castPath_default(path, object4);
|
|
isDeep || (isDeep = path.length > 1);
|
|
return path;
|
|
});
|
|
copyObject_default(object4, getAllKeysIn_default(object4), result2);
|
|
if (isDeep) {
|
|
result2 = baseClone_default(result2, CLONE_DEEP_FLAG8 | CLONE_FLAT_FLAG2 | CLONE_SYMBOLS_FLAG6, customOmitClone_default);
|
|
}
|
|
var length = paths.length;
|
|
while (length--) {
|
|
baseUnset_default(result2, paths[length]);
|
|
}
|
|
return result2;
|
|
});
|
|
var omit_default = omit;
|
|
|
|
// node_modules/lodash-es/_baseSet.js
|
|
function baseSet(object4, path, value, customizer) {
|
|
if (!isObject_default(object4)) {
|
|
return object4;
|
|
}
|
|
path = castPath_default(path, object4);
|
|
var index = -1, length = path.length, lastIndex = length - 1, nested = object4;
|
|
while (nested != null && ++index < length) {
|
|
var key = toKey_default(path[index]), newValue = value;
|
|
if (key === "__proto__" || key === "constructor" || key === "prototype") {
|
|
return object4;
|
|
}
|
|
if (index != lastIndex) {
|
|
var objValue = nested[key];
|
|
newValue = customizer ? customizer(objValue, key, nested) : void 0;
|
|
if (newValue === void 0) {
|
|
newValue = isObject_default(objValue) ? objValue : isIndex_default(path[index + 1]) ? [] : {};
|
|
}
|
|
}
|
|
assignValue_default(nested, key, newValue);
|
|
nested = nested[key];
|
|
}
|
|
return object4;
|
|
}
|
|
var baseSet_default = baseSet;
|
|
|
|
// node_modules/lodash-es/_basePickBy.js
|
|
function basePickBy(object4, paths, predicate) {
|
|
var index = -1, length = paths.length, result2 = {};
|
|
while (++index < length) {
|
|
var path = paths[index], value = baseGet_default(object4, path);
|
|
if (predicate(value, path)) {
|
|
baseSet_default(result2, castPath_default(path, object4), value);
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var basePickBy_default = basePickBy;
|
|
|
|
// node_modules/lodash-es/pickBy.js
|
|
function pickBy(object4, predicate) {
|
|
if (object4 == null) {
|
|
return {};
|
|
}
|
|
var props2 = arrayMap_default(getAllKeysIn_default(object4), function(prop) {
|
|
return [prop];
|
|
});
|
|
predicate = baseIteratee_default(predicate);
|
|
return basePickBy_default(object4, props2, function(value, path) {
|
|
return predicate(value, path[0]);
|
|
});
|
|
}
|
|
var pickBy_default = pickBy;
|
|
|
|
// node_modules/lodash-es/omitBy.js
|
|
function omitBy(object4, predicate) {
|
|
return pickBy_default(object4, negate_default(baseIteratee_default(predicate)));
|
|
}
|
|
var omitBy_default = omitBy;
|
|
|
|
// node_modules/lodash-es/once.js
|
|
function once(func) {
|
|
return before_default(2, func);
|
|
}
|
|
var once_default = once;
|
|
|
|
// node_modules/lodash-es/_baseSortBy.js
|
|
function baseSortBy(array4, comparer) {
|
|
var length = array4.length;
|
|
array4.sort(comparer);
|
|
while (length--) {
|
|
array4[length] = array4[length].value;
|
|
}
|
|
return array4;
|
|
}
|
|
var baseSortBy_default = baseSortBy;
|
|
|
|
// node_modules/lodash-es/_compareAscending.js
|
|
function compareAscending(value, other) {
|
|
if (value !== other) {
|
|
var valIsDefined = value !== void 0, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol_default(value);
|
|
var othIsDefined = other !== void 0, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol_default(other);
|
|
if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) {
|
|
return 1;
|
|
}
|
|
if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) {
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
var compareAscending_default = compareAscending;
|
|
|
|
// node_modules/lodash-es/_compareMultiple.js
|
|
function compareMultiple(object4, other, orders) {
|
|
var index = -1, objCriteria = object4.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
|
|
while (++index < length) {
|
|
var result2 = compareAscending_default(objCriteria[index], othCriteria[index]);
|
|
if (result2) {
|
|
if (index >= ordersLength) {
|
|
return result2;
|
|
}
|
|
var order = orders[index];
|
|
return result2 * (order == "desc" ? -1 : 1);
|
|
}
|
|
}
|
|
return object4.index - other.index;
|
|
}
|
|
var compareMultiple_default = compareMultiple;
|
|
|
|
// node_modules/lodash-es/_baseOrderBy.js
|
|
function baseOrderBy(collection, iteratees, orders) {
|
|
if (iteratees.length) {
|
|
iteratees = arrayMap_default(iteratees, function(iteratee2) {
|
|
if (isArray_default(iteratee2)) {
|
|
return function(value) {
|
|
return baseGet_default(value, iteratee2.length === 1 ? iteratee2[0] : iteratee2);
|
|
};
|
|
}
|
|
return iteratee2;
|
|
});
|
|
} else {
|
|
iteratees = [identity_default];
|
|
}
|
|
var index = -1;
|
|
iteratees = arrayMap_default(iteratees, baseUnary_default(baseIteratee_default));
|
|
var result2 = baseMap_default(collection, function(value, key, collection2) {
|
|
var criteria = arrayMap_default(iteratees, function(iteratee2) {
|
|
return iteratee2(value);
|
|
});
|
|
return { "criteria": criteria, "index": ++index, "value": value };
|
|
});
|
|
return baseSortBy_default(result2, function(object4, other) {
|
|
return compareMultiple_default(object4, other, orders);
|
|
});
|
|
}
|
|
var baseOrderBy_default = baseOrderBy;
|
|
|
|
// node_modules/lodash-es/orderBy.js
|
|
function orderBy(collection, iteratees, orders, guard) {
|
|
if (collection == null) {
|
|
return [];
|
|
}
|
|
if (!isArray_default(iteratees)) {
|
|
iteratees = iteratees == null ? [] : [iteratees];
|
|
}
|
|
orders = guard ? void 0 : orders;
|
|
if (!isArray_default(orders)) {
|
|
orders = orders == null ? [] : [orders];
|
|
}
|
|
return baseOrderBy_default(collection, iteratees, orders);
|
|
}
|
|
var orderBy_default = orderBy;
|
|
|
|
// node_modules/lodash-es/_createOver.js
|
|
function createOver(arrayFunc) {
|
|
return flatRest_default(function(iteratees) {
|
|
iteratees = arrayMap_default(iteratees, baseUnary_default(baseIteratee_default));
|
|
return baseRest_default(function(args) {
|
|
var thisArg = this;
|
|
return arrayFunc(iteratees, function(iteratee2) {
|
|
return apply_default(iteratee2, thisArg, args);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
var createOver_default = createOver;
|
|
|
|
// node_modules/lodash-es/over.js
|
|
var over = createOver_default(arrayMap_default);
|
|
var over_default = over;
|
|
|
|
// node_modules/lodash-es/_castRest.js
|
|
var castRest = baseRest_default;
|
|
var castRest_default = castRest;
|
|
|
|
// node_modules/lodash-es/overArgs.js
|
|
var nativeMin9 = Math.min;
|
|
var overArgs = castRest_default(function(func, transforms) {
|
|
transforms = transforms.length == 1 && isArray_default(transforms[0]) ? arrayMap_default(transforms[0], baseUnary_default(baseIteratee_default)) : arrayMap_default(baseFlatten_default(transforms, 1), baseUnary_default(baseIteratee_default));
|
|
var funcsLength = transforms.length;
|
|
return baseRest_default(function(args) {
|
|
var index = -1, length = nativeMin9(args.length, funcsLength);
|
|
while (++index < length) {
|
|
args[index] = transforms[index].call(this, args[index]);
|
|
}
|
|
return apply_default(func, this, args);
|
|
});
|
|
});
|
|
var overArgs_default = overArgs;
|
|
|
|
// node_modules/lodash-es/overEvery.js
|
|
var overEvery = createOver_default(arrayEvery_default);
|
|
var overEvery_default = overEvery;
|
|
|
|
// node_modules/lodash-es/overSome.js
|
|
var overSome = createOver_default(arraySome_default);
|
|
var overSome_default = overSome;
|
|
|
|
// node_modules/lodash-es/_baseRepeat.js
|
|
var MAX_SAFE_INTEGER4 = 9007199254740991;
|
|
var nativeFloor = Math.floor;
|
|
function baseRepeat(string3, n) {
|
|
var result2 = "";
|
|
if (!string3 || n < 1 || n > MAX_SAFE_INTEGER4) {
|
|
return result2;
|
|
}
|
|
do {
|
|
if (n % 2) {
|
|
result2 += string3;
|
|
}
|
|
n = nativeFloor(n / 2);
|
|
if (n) {
|
|
string3 += string3;
|
|
}
|
|
} while (n);
|
|
return result2;
|
|
}
|
|
var baseRepeat_default = baseRepeat;
|
|
|
|
// node_modules/lodash-es/_asciiSize.js
|
|
var asciiSize = baseProperty_default("length");
|
|
var asciiSize_default = asciiSize;
|
|
|
|
// node_modules/lodash-es/_unicodeSize.js
|
|
var rsAstralRange4 = "\\ud800-\\udfff";
|
|
var rsComboMarksRange5 = "\\u0300-\\u036f";
|
|
var reComboHalfMarksRange5 = "\\ufe20-\\ufe2f";
|
|
var rsComboSymbolsRange5 = "\\u20d0-\\u20ff";
|
|
var rsComboRange5 = rsComboMarksRange5 + reComboHalfMarksRange5 + rsComboSymbolsRange5;
|
|
var rsVarRange4 = "\\ufe0e\\ufe0f";
|
|
var rsAstral2 = "[" + rsAstralRange4 + "]";
|
|
var rsCombo4 = "[" + rsComboRange5 + "]";
|
|
var rsFitz3 = "\\ud83c[\\udffb-\\udfff]";
|
|
var rsModifier3 = "(?:" + rsCombo4 + "|" + rsFitz3 + ")";
|
|
var rsNonAstral3 = "[^" + rsAstralRange4 + "]";
|
|
var rsRegional3 = "(?:\\ud83c[\\udde6-\\uddff]){2}";
|
|
var rsSurrPair3 = "[\\ud800-\\udbff][\\udc00-\\udfff]";
|
|
var rsZWJ4 = "\\u200d";
|
|
var reOptMod3 = rsModifier3 + "?";
|
|
var rsOptVar3 = "[" + rsVarRange4 + "]?";
|
|
var rsOptJoin3 = "(?:" + rsZWJ4 + "(?:" + [rsNonAstral3, rsRegional3, rsSurrPair3].join("|") + ")" + rsOptVar3 + reOptMod3 + ")*";
|
|
var rsSeq3 = rsOptVar3 + reOptMod3 + rsOptJoin3;
|
|
var rsSymbol2 = "(?:" + [rsNonAstral3 + rsCombo4 + "?", rsCombo4, rsRegional3, rsSurrPair3, rsAstral2].join("|") + ")";
|
|
var reUnicode2 = RegExp(rsFitz3 + "(?=" + rsFitz3 + ")|" + rsSymbol2 + rsSeq3, "g");
|
|
function unicodeSize(string3) {
|
|
var result2 = reUnicode2.lastIndex = 0;
|
|
while (reUnicode2.test(string3)) {
|
|
++result2;
|
|
}
|
|
return result2;
|
|
}
|
|
var unicodeSize_default = unicodeSize;
|
|
|
|
// node_modules/lodash-es/_stringSize.js
|
|
function stringSize(string3) {
|
|
return hasUnicode_default(string3) ? unicodeSize_default(string3) : asciiSize_default(string3);
|
|
}
|
|
var stringSize_default = stringSize;
|
|
|
|
// node_modules/lodash-es/_createPadding.js
|
|
var nativeCeil2 = Math.ceil;
|
|
function createPadding(length, chars) {
|
|
chars = chars === void 0 ? " " : baseToString_default(chars);
|
|
var charsLength = chars.length;
|
|
if (charsLength < 2) {
|
|
return charsLength ? baseRepeat_default(chars, length) : chars;
|
|
}
|
|
var result2 = baseRepeat_default(chars, nativeCeil2(length / stringSize_default(chars)));
|
|
return hasUnicode_default(chars) ? castSlice_default(stringToArray_default(result2), 0, length).join("") : result2.slice(0, length);
|
|
}
|
|
var createPadding_default = createPadding;
|
|
|
|
// node_modules/lodash-es/pad.js
|
|
var nativeCeil3 = Math.ceil;
|
|
var nativeFloor2 = Math.floor;
|
|
function pad(string3, length, chars) {
|
|
string3 = toString_default(string3);
|
|
length = toInteger_default(length);
|
|
var strLength = length ? stringSize_default(string3) : 0;
|
|
if (!length || strLength >= length) {
|
|
return string3;
|
|
}
|
|
var mid = (length - strLength) / 2;
|
|
return createPadding_default(nativeFloor2(mid), chars) + string3 + createPadding_default(nativeCeil3(mid), chars);
|
|
}
|
|
var pad_default = pad;
|
|
|
|
// node_modules/lodash-es/padEnd.js
|
|
function padEnd(string3, length, chars) {
|
|
string3 = toString_default(string3);
|
|
length = toInteger_default(length);
|
|
var strLength = length ? stringSize_default(string3) : 0;
|
|
return length && strLength < length ? string3 + createPadding_default(length - strLength, chars) : string3;
|
|
}
|
|
var padEnd_default = padEnd;
|
|
|
|
// node_modules/lodash-es/padStart.js
|
|
function padStart(string3, length, chars) {
|
|
string3 = toString_default(string3);
|
|
length = toInteger_default(length);
|
|
var strLength = length ? stringSize_default(string3) : 0;
|
|
return length && strLength < length ? createPadding_default(length - strLength, chars) + string3 : string3;
|
|
}
|
|
var padStart_default = padStart;
|
|
|
|
// node_modules/lodash-es/parseInt.js
|
|
var reTrimStart2 = /^\s+/;
|
|
var nativeParseInt = root_default.parseInt;
|
|
function parseInt2(string3, radix, guard) {
|
|
if (guard || radix == null) {
|
|
radix = 0;
|
|
} else if (radix) {
|
|
radix = +radix;
|
|
}
|
|
return nativeParseInt(toString_default(string3).replace(reTrimStart2, ""), radix || 0);
|
|
}
|
|
var parseInt_default = parseInt2;
|
|
|
|
// node_modules/lodash-es/partial.js
|
|
var WRAP_PARTIAL_FLAG7 = 32;
|
|
var partial = baseRest_default(function(func, partials) {
|
|
var holders = replaceHolders_default(partials, getHolder_default(partial));
|
|
return createWrap_default(func, WRAP_PARTIAL_FLAG7, void 0, partials, holders);
|
|
});
|
|
partial.placeholder = {};
|
|
var partial_default = partial;
|
|
|
|
// node_modules/lodash-es/partialRight.js
|
|
var WRAP_PARTIAL_RIGHT_FLAG4 = 64;
|
|
var partialRight = baseRest_default(function(func, partials) {
|
|
var holders = replaceHolders_default(partials, getHolder_default(partialRight));
|
|
return createWrap_default(func, WRAP_PARTIAL_RIGHT_FLAG4, void 0, partials, holders);
|
|
});
|
|
partialRight.placeholder = {};
|
|
var partialRight_default = partialRight;
|
|
|
|
// node_modules/lodash-es/partition.js
|
|
var partition = createAggregator_default(function(result2, value, key) {
|
|
result2[key ? 0 : 1].push(value);
|
|
}, function() {
|
|
return [[], []];
|
|
});
|
|
var partition_default = partition;
|
|
|
|
// node_modules/lodash-es/_basePick.js
|
|
function basePick(object4, paths) {
|
|
return basePickBy_default(object4, paths, function(value, path) {
|
|
return hasIn_default(object4, path);
|
|
});
|
|
}
|
|
var basePick_default = basePick;
|
|
|
|
// node_modules/lodash-es/pick.js
|
|
var pick = flatRest_default(function(object4, paths) {
|
|
return object4 == null ? {} : basePick_default(object4, paths);
|
|
});
|
|
var pick_default = pick;
|
|
|
|
// node_modules/lodash-es/plant.js
|
|
function wrapperPlant(value) {
|
|
var result2, parent2 = this;
|
|
while (parent2 instanceof baseLodash_default) {
|
|
var clone2 = wrapperClone_default(parent2);
|
|
clone2.__index__ = 0;
|
|
clone2.__values__ = void 0;
|
|
if (result2) {
|
|
previous.__wrapped__ = clone2;
|
|
} else {
|
|
result2 = clone2;
|
|
}
|
|
var previous = clone2;
|
|
parent2 = parent2.__wrapped__;
|
|
}
|
|
previous.__wrapped__ = value;
|
|
return result2;
|
|
}
|
|
var plant_default = wrapperPlant;
|
|
|
|
// node_modules/lodash-es/propertyOf.js
|
|
function propertyOf(object4) {
|
|
return function(path) {
|
|
return object4 == null ? void 0 : baseGet_default(object4, path);
|
|
};
|
|
}
|
|
var propertyOf_default = propertyOf;
|
|
|
|
// node_modules/lodash-es/_baseIndexOfWith.js
|
|
function baseIndexOfWith(array4, value, fromIndex, comparator) {
|
|
var index = fromIndex - 1, length = array4.length;
|
|
while (++index < length) {
|
|
if (comparator(array4[index], value)) {
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
var baseIndexOfWith_default = baseIndexOfWith;
|
|
|
|
// node_modules/lodash-es/_basePullAll.js
|
|
var arrayProto3 = Array.prototype;
|
|
var splice2 = arrayProto3.splice;
|
|
function basePullAll(array4, values2, iteratee2, comparator) {
|
|
var indexOf2 = comparator ? baseIndexOfWith_default : baseIndexOf_default, index = -1, length = values2.length, seen = array4;
|
|
if (array4 === values2) {
|
|
values2 = copyArray_default(values2);
|
|
}
|
|
if (iteratee2) {
|
|
seen = arrayMap_default(array4, baseUnary_default(iteratee2));
|
|
}
|
|
while (++index < length) {
|
|
var fromIndex = 0, value = values2[index], computed2 = iteratee2 ? iteratee2(value) : value;
|
|
while ((fromIndex = indexOf2(seen, computed2, fromIndex, comparator)) > -1) {
|
|
if (seen !== array4) {
|
|
splice2.call(seen, fromIndex, 1);
|
|
}
|
|
splice2.call(array4, fromIndex, 1);
|
|
}
|
|
}
|
|
return array4;
|
|
}
|
|
var basePullAll_default = basePullAll;
|
|
|
|
// node_modules/lodash-es/pullAll.js
|
|
function pullAll(array4, values2) {
|
|
return array4 && array4.length && values2 && values2.length ? basePullAll_default(array4, values2) : array4;
|
|
}
|
|
var pullAll_default = pullAll;
|
|
|
|
// node_modules/lodash-es/pull.js
|
|
var pull = baseRest_default(pullAll_default);
|
|
var pull_default = pull;
|
|
|
|
// node_modules/lodash-es/pullAllBy.js
|
|
function pullAllBy(array4, values2, iteratee2) {
|
|
return array4 && array4.length && values2 && values2.length ? basePullAll_default(array4, values2, baseIteratee_default(iteratee2, 2)) : array4;
|
|
}
|
|
var pullAllBy_default = pullAllBy;
|
|
|
|
// node_modules/lodash-es/pullAllWith.js
|
|
function pullAllWith(array4, values2, comparator) {
|
|
return array4 && array4.length && values2 && values2.length ? basePullAll_default(array4, values2, void 0, comparator) : array4;
|
|
}
|
|
var pullAllWith_default = pullAllWith;
|
|
|
|
// node_modules/lodash-es/_basePullAt.js
|
|
var arrayProto4 = Array.prototype;
|
|
var splice3 = arrayProto4.splice;
|
|
function basePullAt(array4, indexes) {
|
|
var length = array4 ? indexes.length : 0, lastIndex = length - 1;
|
|
while (length--) {
|
|
var index = indexes[length];
|
|
if (length == lastIndex || index !== previous) {
|
|
var previous = index;
|
|
if (isIndex_default(index)) {
|
|
splice3.call(array4, index, 1);
|
|
} else {
|
|
baseUnset_default(array4, index);
|
|
}
|
|
}
|
|
}
|
|
return array4;
|
|
}
|
|
var basePullAt_default = basePullAt;
|
|
|
|
// node_modules/lodash-es/pullAt.js
|
|
var pullAt = flatRest_default(function(array4, indexes) {
|
|
var length = array4 == null ? 0 : array4.length, result2 = baseAt_default(array4, indexes);
|
|
basePullAt_default(array4, arrayMap_default(indexes, function(index) {
|
|
return isIndex_default(index, length) ? +index : index;
|
|
}).sort(compareAscending_default));
|
|
return result2;
|
|
});
|
|
var pullAt_default = pullAt;
|
|
|
|
// node_modules/lodash-es/_baseRandom.js
|
|
var nativeFloor3 = Math.floor;
|
|
var nativeRandom = Math.random;
|
|
function baseRandom(lower, upper) {
|
|
return lower + nativeFloor3(nativeRandom() * (upper - lower + 1));
|
|
}
|
|
var baseRandom_default = baseRandom;
|
|
|
|
// node_modules/lodash-es/random.js
|
|
var freeParseFloat = parseFloat;
|
|
var nativeMin10 = Math.min;
|
|
var nativeRandom2 = Math.random;
|
|
function random(lower, upper, floating) {
|
|
if (floating && typeof floating != "boolean" && isIterateeCall_default(lower, upper, floating)) {
|
|
upper = floating = void 0;
|
|
}
|
|
if (floating === void 0) {
|
|
if (typeof upper == "boolean") {
|
|
floating = upper;
|
|
upper = void 0;
|
|
} else if (typeof lower == "boolean") {
|
|
floating = lower;
|
|
lower = void 0;
|
|
}
|
|
}
|
|
if (lower === void 0 && upper === void 0) {
|
|
lower = 0;
|
|
upper = 1;
|
|
} else {
|
|
lower = toFinite_default(lower);
|
|
if (upper === void 0) {
|
|
upper = lower;
|
|
lower = 0;
|
|
} else {
|
|
upper = toFinite_default(upper);
|
|
}
|
|
}
|
|
if (lower > upper) {
|
|
var temp = lower;
|
|
lower = upper;
|
|
upper = temp;
|
|
}
|
|
if (floating || lower % 1 || upper % 1) {
|
|
var rand = nativeRandom2();
|
|
return nativeMin10(lower + rand * (upper - lower + freeParseFloat("1e-" + ((rand + "").length - 1))), upper);
|
|
}
|
|
return baseRandom_default(lower, upper);
|
|
}
|
|
var random_default = random;
|
|
|
|
// node_modules/lodash-es/_baseRange.js
|
|
var nativeCeil4 = Math.ceil;
|
|
var nativeMax13 = Math.max;
|
|
function baseRange(start, end, step, fromRight) {
|
|
var index = -1, length = nativeMax13(nativeCeil4((end - start) / (step || 1)), 0), result2 = Array(length);
|
|
while (length--) {
|
|
result2[fromRight ? length : ++index] = start;
|
|
start += step;
|
|
}
|
|
return result2;
|
|
}
|
|
var baseRange_default = baseRange;
|
|
|
|
// node_modules/lodash-es/_createRange.js
|
|
function createRange(fromRight) {
|
|
return function(start, end, step) {
|
|
if (step && typeof step != "number" && isIterateeCall_default(start, end, step)) {
|
|
end = step = void 0;
|
|
}
|
|
start = toFinite_default(start);
|
|
if (end === void 0) {
|
|
end = start;
|
|
start = 0;
|
|
} else {
|
|
end = toFinite_default(end);
|
|
}
|
|
step = step === void 0 ? start < end ? 1 : -1 : toFinite_default(step);
|
|
return baseRange_default(start, end, step, fromRight);
|
|
};
|
|
}
|
|
var createRange_default = createRange;
|
|
|
|
// node_modules/lodash-es/range.js
|
|
var range = createRange_default();
|
|
var range_default = range;
|
|
|
|
// node_modules/lodash-es/rangeRight.js
|
|
var rangeRight = createRange_default(true);
|
|
var rangeRight_default = rangeRight;
|
|
|
|
// node_modules/lodash-es/rearg.js
|
|
var WRAP_REARG_FLAG4 = 256;
|
|
var rearg = flatRest_default(function(func, indexes) {
|
|
return createWrap_default(func, WRAP_REARG_FLAG4, void 0, void 0, void 0, indexes);
|
|
});
|
|
var rearg_default = rearg;
|
|
|
|
// node_modules/lodash-es/_baseReduce.js
|
|
function baseReduce(collection, iteratee2, accumulator, initAccum, eachFunc) {
|
|
eachFunc(collection, function(value, index, collection2) {
|
|
accumulator = initAccum ? (initAccum = false, value) : iteratee2(accumulator, value, index, collection2);
|
|
});
|
|
return accumulator;
|
|
}
|
|
var baseReduce_default = baseReduce;
|
|
|
|
// node_modules/lodash-es/reduce.js
|
|
function reduce(collection, iteratee2, accumulator) {
|
|
var func = isArray_default(collection) ? arrayReduce_default : baseReduce_default, initAccum = arguments.length < 3;
|
|
return func(collection, baseIteratee_default(iteratee2, 4), accumulator, initAccum, baseEach_default);
|
|
}
|
|
var reduce_default = reduce;
|
|
|
|
// node_modules/lodash-es/_arrayReduceRight.js
|
|
function arrayReduceRight(array4, iteratee2, accumulator, initAccum) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
if (initAccum && length) {
|
|
accumulator = array4[--length];
|
|
}
|
|
while (length--) {
|
|
accumulator = iteratee2(accumulator, array4[length], length, array4);
|
|
}
|
|
return accumulator;
|
|
}
|
|
var arrayReduceRight_default = arrayReduceRight;
|
|
|
|
// node_modules/lodash-es/reduceRight.js
|
|
function reduceRight(collection, iteratee2, accumulator) {
|
|
var func = isArray_default(collection) ? arrayReduceRight_default : baseReduce_default, initAccum = arguments.length < 3;
|
|
return func(collection, baseIteratee_default(iteratee2, 4), accumulator, initAccum, baseEachRight_default);
|
|
}
|
|
var reduceRight_default = reduceRight;
|
|
|
|
// node_modules/lodash-es/reject.js
|
|
function reject(collection, predicate) {
|
|
var func = isArray_default(collection) ? arrayFilter_default : baseFilter_default;
|
|
return func(collection, negate_default(baseIteratee_default(predicate, 3)));
|
|
}
|
|
var reject_default = reject;
|
|
|
|
// node_modules/lodash-es/remove.js
|
|
function remove(array4, predicate) {
|
|
var result2 = [];
|
|
if (!(array4 && array4.length)) {
|
|
return result2;
|
|
}
|
|
var index = -1, indexes = [], length = array4.length;
|
|
predicate = baseIteratee_default(predicate, 3);
|
|
while (++index < length) {
|
|
var value = array4[index];
|
|
if (predicate(value, index, array4)) {
|
|
result2.push(value);
|
|
indexes.push(index);
|
|
}
|
|
}
|
|
basePullAt_default(array4, indexes);
|
|
return result2;
|
|
}
|
|
var remove_default = remove;
|
|
|
|
// node_modules/lodash-es/repeat.js
|
|
function repeat(string3, n, guard) {
|
|
if (guard ? isIterateeCall_default(string3, n, guard) : n === void 0) {
|
|
n = 1;
|
|
} else {
|
|
n = toInteger_default(n);
|
|
}
|
|
return baseRepeat_default(toString_default(string3), n);
|
|
}
|
|
var repeat_default = repeat;
|
|
|
|
// node_modules/lodash-es/replace.js
|
|
function replace() {
|
|
var args = arguments, string3 = toString_default(args[0]);
|
|
return args.length < 3 ? string3 : string3.replace(args[1], args[2]);
|
|
}
|
|
var replace_default = replace;
|
|
|
|
// node_modules/lodash-es/rest.js
|
|
var FUNC_ERROR_TEXT10 = "Expected a function";
|
|
function rest(func, start) {
|
|
if (typeof func != "function") {
|
|
throw new TypeError(FUNC_ERROR_TEXT10);
|
|
}
|
|
start = start === void 0 ? start : toInteger_default(start);
|
|
return baseRest_default(func, start);
|
|
}
|
|
var rest_default = rest;
|
|
|
|
// node_modules/lodash-es/result.js
|
|
function result(object4, path, defaultValue) {
|
|
path = castPath_default(path, object4);
|
|
var index = -1, length = path.length;
|
|
if (!length) {
|
|
length = 1;
|
|
object4 = void 0;
|
|
}
|
|
while (++index < length) {
|
|
var value = object4 == null ? void 0 : object4[toKey_default(path[index])];
|
|
if (value === void 0) {
|
|
index = length;
|
|
value = defaultValue;
|
|
}
|
|
object4 = isFunction_default(value) ? value.call(object4) : value;
|
|
}
|
|
return object4;
|
|
}
|
|
var result_default = result;
|
|
|
|
// node_modules/lodash-es/reverse.js
|
|
var arrayProto5 = Array.prototype;
|
|
var nativeReverse = arrayProto5.reverse;
|
|
function reverse(array4) {
|
|
return array4 == null ? array4 : nativeReverse.call(array4);
|
|
}
|
|
var reverse_default = reverse;
|
|
|
|
// node_modules/lodash-es/round.js
|
|
var round = createRound_default("round");
|
|
var round_default = round;
|
|
|
|
// node_modules/lodash-es/_arraySample.js
|
|
function arraySample(array4) {
|
|
var length = array4.length;
|
|
return length ? array4[baseRandom_default(0, length - 1)] : void 0;
|
|
}
|
|
var arraySample_default = arraySample;
|
|
|
|
// node_modules/lodash-es/_baseSample.js
|
|
function baseSample(collection) {
|
|
return arraySample_default(values_default(collection));
|
|
}
|
|
var baseSample_default = baseSample;
|
|
|
|
// node_modules/lodash-es/sample.js
|
|
function sample(collection) {
|
|
var func = isArray_default(collection) ? arraySample_default : baseSample_default;
|
|
return func(collection);
|
|
}
|
|
var sample_default = sample;
|
|
|
|
// node_modules/lodash-es/_shuffleSelf.js
|
|
function shuffleSelf(array4, size3) {
|
|
var index = -1, length = array4.length, lastIndex = length - 1;
|
|
size3 = size3 === void 0 ? length : size3;
|
|
while (++index < size3) {
|
|
var rand = baseRandom_default(index, lastIndex), value = array4[rand];
|
|
array4[rand] = array4[index];
|
|
array4[index] = value;
|
|
}
|
|
array4.length = size3;
|
|
return array4;
|
|
}
|
|
var shuffleSelf_default = shuffleSelf;
|
|
|
|
// node_modules/lodash-es/_arraySampleSize.js
|
|
function arraySampleSize(array4, n) {
|
|
return shuffleSelf_default(copyArray_default(array4), baseClamp_default(n, 0, array4.length));
|
|
}
|
|
var arraySampleSize_default = arraySampleSize;
|
|
|
|
// node_modules/lodash-es/_baseSampleSize.js
|
|
function baseSampleSize(collection, n) {
|
|
var array4 = values_default(collection);
|
|
return shuffleSelf_default(array4, baseClamp_default(n, 0, array4.length));
|
|
}
|
|
var baseSampleSize_default = baseSampleSize;
|
|
|
|
// node_modules/lodash-es/sampleSize.js
|
|
function sampleSize(collection, n, guard) {
|
|
if (guard ? isIterateeCall_default(collection, n, guard) : n === void 0) {
|
|
n = 1;
|
|
} else {
|
|
n = toInteger_default(n);
|
|
}
|
|
var func = isArray_default(collection) ? arraySampleSize_default : baseSampleSize_default;
|
|
return func(collection, n);
|
|
}
|
|
var sampleSize_default = sampleSize;
|
|
|
|
// node_modules/lodash-es/set.js
|
|
function set(object4, path, value) {
|
|
return object4 == null ? object4 : baseSet_default(object4, path, value);
|
|
}
|
|
var set_default = set;
|
|
|
|
// node_modules/lodash-es/setWith.js
|
|
function setWith(object4, path, value, customizer) {
|
|
customizer = typeof customizer == "function" ? customizer : void 0;
|
|
return object4 == null ? object4 : baseSet_default(object4, path, value, customizer);
|
|
}
|
|
var setWith_default = setWith;
|
|
|
|
// node_modules/lodash-es/_arrayShuffle.js
|
|
function arrayShuffle(array4) {
|
|
return shuffleSelf_default(copyArray_default(array4));
|
|
}
|
|
var arrayShuffle_default = arrayShuffle;
|
|
|
|
// node_modules/lodash-es/_baseShuffle.js
|
|
function baseShuffle(collection) {
|
|
return shuffleSelf_default(values_default(collection));
|
|
}
|
|
var baseShuffle_default = baseShuffle;
|
|
|
|
// node_modules/lodash-es/shuffle.js
|
|
function shuffle(collection) {
|
|
var func = isArray_default(collection) ? arrayShuffle_default : baseShuffle_default;
|
|
return func(collection);
|
|
}
|
|
var shuffle_default = shuffle;
|
|
|
|
// node_modules/lodash-es/size.js
|
|
var mapTag10 = "[object Map]";
|
|
var setTag10 = "[object Set]";
|
|
function size(collection) {
|
|
if (collection == null) {
|
|
return 0;
|
|
}
|
|
if (isArrayLike_default(collection)) {
|
|
return isString_default(collection) ? stringSize_default(collection) : collection.length;
|
|
}
|
|
var tag = getTag_default(collection);
|
|
if (tag == mapTag10 || tag == setTag10) {
|
|
return collection.size;
|
|
}
|
|
return baseKeys_default(collection).length;
|
|
}
|
|
var size_default = size;
|
|
|
|
// node_modules/lodash-es/slice.js
|
|
function slice(array4, start, end) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
if (!length) {
|
|
return [];
|
|
}
|
|
if (end && typeof end != "number" && isIterateeCall_default(array4, start, end)) {
|
|
start = 0;
|
|
end = length;
|
|
} else {
|
|
start = start == null ? 0 : toInteger_default(start);
|
|
end = end === void 0 ? length : toInteger_default(end);
|
|
}
|
|
return baseSlice_default(array4, start, end);
|
|
}
|
|
var slice_default = slice;
|
|
|
|
// node_modules/lodash-es/snakeCase.js
|
|
var snakeCase = createCompounder_default(function(result2, word, index) {
|
|
return result2 + (index ? "_" : "") + word.toLowerCase();
|
|
});
|
|
var snakeCase_default = snakeCase;
|
|
|
|
// node_modules/lodash-es/_baseSome.js
|
|
function baseSome(collection, predicate) {
|
|
var result2;
|
|
baseEach_default(collection, function(value, index, collection2) {
|
|
result2 = predicate(value, index, collection2);
|
|
return !result2;
|
|
});
|
|
return !!result2;
|
|
}
|
|
var baseSome_default = baseSome;
|
|
|
|
// node_modules/lodash-es/some.js
|
|
function some(collection, predicate, guard) {
|
|
var func = isArray_default(collection) ? arraySome_default : baseSome_default;
|
|
if (guard && isIterateeCall_default(collection, predicate, guard)) {
|
|
predicate = void 0;
|
|
}
|
|
return func(collection, baseIteratee_default(predicate, 3));
|
|
}
|
|
var some_default = some;
|
|
|
|
// node_modules/lodash-es/sortBy.js
|
|
var sortBy = baseRest_default(function(collection, iteratees) {
|
|
if (collection == null) {
|
|
return [];
|
|
}
|
|
var length = iteratees.length;
|
|
if (length > 1 && isIterateeCall_default(collection, iteratees[0], iteratees[1])) {
|
|
iteratees = [];
|
|
} else if (length > 2 && isIterateeCall_default(iteratees[0], iteratees[1], iteratees[2])) {
|
|
iteratees = [iteratees[0]];
|
|
}
|
|
return baseOrderBy_default(collection, baseFlatten_default(iteratees, 1), []);
|
|
});
|
|
var sortBy_default = sortBy;
|
|
|
|
// node_modules/lodash-es/_baseSortedIndexBy.js
|
|
var MAX_ARRAY_LENGTH3 = 4294967295;
|
|
var MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH3 - 1;
|
|
var nativeFloor4 = Math.floor;
|
|
var nativeMin11 = Math.min;
|
|
function baseSortedIndexBy(array4, value, iteratee2, retHighest) {
|
|
var low = 0, high = array4 == null ? 0 : array4.length;
|
|
if (high === 0) {
|
|
return 0;
|
|
}
|
|
value = iteratee2(value);
|
|
var valIsNaN = value !== value, valIsNull = value === null, valIsSymbol = isSymbol_default(value), valIsUndefined = value === void 0;
|
|
while (low < high) {
|
|
var mid = nativeFloor4((low + high) / 2), computed2 = iteratee2(array4[mid]), othIsDefined = computed2 !== void 0, othIsNull = computed2 === null, othIsReflexive = computed2 === computed2, othIsSymbol = isSymbol_default(computed2);
|
|
if (valIsNaN) {
|
|
var setLow = retHighest || othIsReflexive;
|
|
} else if (valIsUndefined) {
|
|
setLow = othIsReflexive && (retHighest || othIsDefined);
|
|
} else if (valIsNull) {
|
|
setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
|
|
} else if (valIsSymbol) {
|
|
setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
|
|
} else if (othIsNull || othIsSymbol) {
|
|
setLow = false;
|
|
} else {
|
|
setLow = retHighest ? computed2 <= value : computed2 < value;
|
|
}
|
|
if (setLow) {
|
|
low = mid + 1;
|
|
} else {
|
|
high = mid;
|
|
}
|
|
}
|
|
return nativeMin11(high, MAX_ARRAY_INDEX);
|
|
}
|
|
var baseSortedIndexBy_default = baseSortedIndexBy;
|
|
|
|
// node_modules/lodash-es/_baseSortedIndex.js
|
|
var MAX_ARRAY_LENGTH4 = 4294967295;
|
|
var HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH4 >>> 1;
|
|
function baseSortedIndex(array4, value, retHighest) {
|
|
var low = 0, high = array4 == null ? low : array4.length;
|
|
if (typeof value == "number" && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
|
|
while (low < high) {
|
|
var mid = low + high >>> 1, computed2 = array4[mid];
|
|
if (computed2 !== null && !isSymbol_default(computed2) && (retHighest ? computed2 <= value : computed2 < value)) {
|
|
low = mid + 1;
|
|
} else {
|
|
high = mid;
|
|
}
|
|
}
|
|
return high;
|
|
}
|
|
return baseSortedIndexBy_default(array4, value, identity_default, retHighest);
|
|
}
|
|
var baseSortedIndex_default = baseSortedIndex;
|
|
|
|
// node_modules/lodash-es/sortedIndex.js
|
|
function sortedIndex(array4, value) {
|
|
return baseSortedIndex_default(array4, value);
|
|
}
|
|
var sortedIndex_default = sortedIndex;
|
|
|
|
// node_modules/lodash-es/sortedIndexBy.js
|
|
function sortedIndexBy(array4, value, iteratee2) {
|
|
return baseSortedIndexBy_default(array4, value, baseIteratee_default(iteratee2, 2));
|
|
}
|
|
var sortedIndexBy_default = sortedIndexBy;
|
|
|
|
// node_modules/lodash-es/sortedIndexOf.js
|
|
function sortedIndexOf(array4, value) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
if (length) {
|
|
var index = baseSortedIndex_default(array4, value);
|
|
if (index < length && eq_default(array4[index], value)) {
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
var sortedIndexOf_default = sortedIndexOf;
|
|
|
|
// node_modules/lodash-es/sortedLastIndex.js
|
|
function sortedLastIndex(array4, value) {
|
|
return baseSortedIndex_default(array4, value, true);
|
|
}
|
|
var sortedLastIndex_default = sortedLastIndex;
|
|
|
|
// node_modules/lodash-es/sortedLastIndexBy.js
|
|
function sortedLastIndexBy(array4, value, iteratee2) {
|
|
return baseSortedIndexBy_default(array4, value, baseIteratee_default(iteratee2, 2), true);
|
|
}
|
|
var sortedLastIndexBy_default = sortedLastIndexBy;
|
|
|
|
// node_modules/lodash-es/sortedLastIndexOf.js
|
|
function sortedLastIndexOf(array4, value) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
if (length) {
|
|
var index = baseSortedIndex_default(array4, value, true) - 1;
|
|
if (eq_default(array4[index], value)) {
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
var sortedLastIndexOf_default = sortedLastIndexOf;
|
|
|
|
// node_modules/lodash-es/_baseSortedUniq.js
|
|
function baseSortedUniq(array4, iteratee2) {
|
|
var index = -1, length = array4.length, resIndex = 0, result2 = [];
|
|
while (++index < length) {
|
|
var value = array4[index], computed2 = iteratee2 ? iteratee2(value) : value;
|
|
if (!index || !eq_default(computed2, seen)) {
|
|
var seen = computed2;
|
|
result2[resIndex++] = value === 0 ? 0 : value;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var baseSortedUniq_default = baseSortedUniq;
|
|
|
|
// node_modules/lodash-es/sortedUniq.js
|
|
function sortedUniq(array4) {
|
|
return array4 && array4.length ? baseSortedUniq_default(array4) : [];
|
|
}
|
|
var sortedUniq_default = sortedUniq;
|
|
|
|
// node_modules/lodash-es/sortedUniqBy.js
|
|
function sortedUniqBy(array4, iteratee2) {
|
|
return array4 && array4.length ? baseSortedUniq_default(array4, baseIteratee_default(iteratee2, 2)) : [];
|
|
}
|
|
var sortedUniqBy_default = sortedUniqBy;
|
|
|
|
// node_modules/lodash-es/split.js
|
|
var MAX_ARRAY_LENGTH5 = 4294967295;
|
|
function split(string3, separator, limit) {
|
|
if (limit && typeof limit != "number" && isIterateeCall_default(string3, separator, limit)) {
|
|
separator = limit = void 0;
|
|
}
|
|
limit = limit === void 0 ? MAX_ARRAY_LENGTH5 : limit >>> 0;
|
|
if (!limit) {
|
|
return [];
|
|
}
|
|
string3 = toString_default(string3);
|
|
if (string3 && (typeof separator == "string" || separator != null && !isRegExp_default(separator))) {
|
|
separator = baseToString_default(separator);
|
|
if (!separator && hasUnicode_default(string3)) {
|
|
return castSlice_default(stringToArray_default(string3), 0, limit);
|
|
}
|
|
}
|
|
return string3.split(separator, limit);
|
|
}
|
|
var split_default = split;
|
|
|
|
// node_modules/lodash-es/spread.js
|
|
var FUNC_ERROR_TEXT11 = "Expected a function";
|
|
var nativeMax14 = Math.max;
|
|
function spread(func, start) {
|
|
if (typeof func != "function") {
|
|
throw new TypeError(FUNC_ERROR_TEXT11);
|
|
}
|
|
start = start == null ? 0 : nativeMax14(toInteger_default(start), 0);
|
|
return baseRest_default(function(args) {
|
|
var array4 = args[start], otherArgs = castSlice_default(args, 0, start);
|
|
if (array4) {
|
|
arrayPush_default(otherArgs, array4);
|
|
}
|
|
return apply_default(func, this, otherArgs);
|
|
});
|
|
}
|
|
var spread_default = spread;
|
|
|
|
// node_modules/lodash-es/startCase.js
|
|
var startCase = createCompounder_default(function(result2, word, index) {
|
|
return result2 + (index ? " " : "") + upperFirst_default(word);
|
|
});
|
|
var startCase_default = startCase;
|
|
|
|
// node_modules/lodash-es/startsWith.js
|
|
function startsWith(string3, target2, position) {
|
|
string3 = toString_default(string3);
|
|
position = position == null ? 0 : baseClamp_default(toInteger_default(position), 0, string3.length);
|
|
target2 = baseToString_default(target2);
|
|
return string3.slice(position, position + target2.length) == target2;
|
|
}
|
|
var startsWith_default = startsWith;
|
|
|
|
// node_modules/lodash-es/stubObject.js
|
|
function stubObject() {
|
|
return {};
|
|
}
|
|
var stubObject_default = stubObject;
|
|
|
|
// node_modules/lodash-es/stubString.js
|
|
function stubString() {
|
|
return "";
|
|
}
|
|
var stubString_default = stubString;
|
|
|
|
// node_modules/lodash-es/stubTrue.js
|
|
function stubTrue() {
|
|
return true;
|
|
}
|
|
var stubTrue_default = stubTrue;
|
|
|
|
// node_modules/lodash-es/subtract.js
|
|
var subtract = createMathOperation_default(function(minuend, subtrahend) {
|
|
return minuend - subtrahend;
|
|
}, 0);
|
|
var subtract_default = subtract;
|
|
|
|
// node_modules/lodash-es/sum.js
|
|
function sum(array4) {
|
|
return array4 && array4.length ? baseSum_default(array4, identity_default) : 0;
|
|
}
|
|
var sum_default = sum;
|
|
|
|
// node_modules/lodash-es/sumBy.js
|
|
function sumBy(array4, iteratee2) {
|
|
return array4 && array4.length ? baseSum_default(array4, baseIteratee_default(iteratee2, 2)) : 0;
|
|
}
|
|
var sumBy_default = sumBy;
|
|
|
|
// node_modules/lodash-es/tail.js
|
|
function tail(array4) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
return length ? baseSlice_default(array4, 1, length) : [];
|
|
}
|
|
var tail_default = tail;
|
|
|
|
// node_modules/lodash-es/take.js
|
|
function take(array4, n, guard) {
|
|
if (!(array4 && array4.length)) {
|
|
return [];
|
|
}
|
|
n = guard || n === void 0 ? 1 : toInteger_default(n);
|
|
return baseSlice_default(array4, 0, n < 0 ? 0 : n);
|
|
}
|
|
var take_default = take;
|
|
|
|
// node_modules/lodash-es/takeRight.js
|
|
function takeRight(array4, n, guard) {
|
|
var length = array4 == null ? 0 : array4.length;
|
|
if (!length) {
|
|
return [];
|
|
}
|
|
n = guard || n === void 0 ? 1 : toInteger_default(n);
|
|
n = length - n;
|
|
return baseSlice_default(array4, n < 0 ? 0 : n, length);
|
|
}
|
|
var takeRight_default = takeRight;
|
|
|
|
// node_modules/lodash-es/takeRightWhile.js
|
|
function takeRightWhile(array4, predicate) {
|
|
return array4 && array4.length ? baseWhile_default(array4, baseIteratee_default(predicate, 3), false, true) : [];
|
|
}
|
|
var takeRightWhile_default = takeRightWhile;
|
|
|
|
// node_modules/lodash-es/takeWhile.js
|
|
function takeWhile(array4, predicate) {
|
|
return array4 && array4.length ? baseWhile_default(array4, baseIteratee_default(predicate, 3)) : [];
|
|
}
|
|
var takeWhile_default = takeWhile;
|
|
|
|
// node_modules/lodash-es/tap.js
|
|
function tap(value, interceptor) {
|
|
interceptor(value);
|
|
return value;
|
|
}
|
|
var tap_default = tap;
|
|
|
|
// node_modules/lodash-es/_customDefaultsAssignIn.js
|
|
var objectProto27 = Object.prototype;
|
|
var hasOwnProperty23 = objectProto27.hasOwnProperty;
|
|
function customDefaultsAssignIn(objValue, srcValue, key, object4) {
|
|
if (objValue === void 0 || eq_default(objValue, objectProto27[key]) && !hasOwnProperty23.call(object4, key)) {
|
|
return srcValue;
|
|
}
|
|
return objValue;
|
|
}
|
|
var customDefaultsAssignIn_default = customDefaultsAssignIn;
|
|
|
|
// node_modules/lodash-es/_escapeStringChar.js
|
|
var stringEscapes = {
|
|
"\\": "\\",
|
|
"'": "'",
|
|
"\n": "n",
|
|
"\r": "r",
|
|
"\u2028": "u2028",
|
|
"\u2029": "u2029"
|
|
};
|
|
function escapeStringChar(chr) {
|
|
return "\\" + stringEscapes[chr];
|
|
}
|
|
var escapeStringChar_default = escapeStringChar;
|
|
|
|
// node_modules/lodash-es/_reInterpolate.js
|
|
var reInterpolate = /<%=([\s\S]+?)%>/g;
|
|
var reInterpolate_default = reInterpolate;
|
|
|
|
// node_modules/lodash-es/_reEscape.js
|
|
var reEscape = /<%-([\s\S]+?)%>/g;
|
|
var reEscape_default = reEscape;
|
|
|
|
// node_modules/lodash-es/_reEvaluate.js
|
|
var reEvaluate = /<%([\s\S]+?)%>/g;
|
|
var reEvaluate_default = reEvaluate;
|
|
|
|
// node_modules/lodash-es/templateSettings.js
|
|
var templateSettings = {
|
|
"escape": reEscape_default,
|
|
"evaluate": reEvaluate_default,
|
|
"interpolate": reInterpolate_default,
|
|
"variable": "",
|
|
"imports": {
|
|
"_": { "escape": escape_default }
|
|
}
|
|
};
|
|
var templateSettings_default = templateSettings;
|
|
|
|
// node_modules/lodash-es/template.js
|
|
var INVALID_TEMPL_VAR_ERROR_TEXT = "Invalid `variable` option passed into `_.template`";
|
|
var reEmptyStringLeading = /\b__p \+= '';/g;
|
|
var reEmptyStringMiddle = /\b(__p \+=) '' \+/g;
|
|
var reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
|
|
var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/;
|
|
var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
|
|
var reNoMatch = /($^)/;
|
|
var reUnescapedString = /['\n\r\u2028\u2029\\]/g;
|
|
var objectProto28 = Object.prototype;
|
|
var hasOwnProperty24 = objectProto28.hasOwnProperty;
|
|
function template(string3, options, guard) {
|
|
var settings = templateSettings_default.imports._.templateSettings || templateSettings_default;
|
|
if (guard && isIterateeCall_default(string3, options, guard)) {
|
|
options = void 0;
|
|
}
|
|
string3 = toString_default(string3);
|
|
options = assignInWith_default({}, options, settings, customDefaultsAssignIn_default);
|
|
var imports = assignInWith_default({}, options.imports, settings.imports, customDefaultsAssignIn_default), importsKeys = keys_default(imports), importsValues = baseValues_default(imports, importsKeys);
|
|
var isEscaping, isEvaluating, index = 0, interpolate = options.interpolate || reNoMatch, source = "__p += '";
|
|
var reDelimiters = RegExp((options.escape || reNoMatch).source + "|" + interpolate.source + "|" + (interpolate === reInterpolate_default ? reEsTemplate : reNoMatch).source + "|" + (options.evaluate || reNoMatch).source + "|$", "g");
|
|
var sourceURL = hasOwnProperty24.call(options, "sourceURL") ? "//# sourceURL=" + (options.sourceURL + "").replace(/\s/g, " ") + "\n" : "";
|
|
string3.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset3) {
|
|
interpolateValue || (interpolateValue = esTemplateValue);
|
|
source += string3.slice(index, offset3).replace(reUnescapedString, escapeStringChar_default);
|
|
if (escapeValue) {
|
|
isEscaping = true;
|
|
source += "' +\n__e(" + escapeValue + ") +\n'";
|
|
}
|
|
if (evaluateValue) {
|
|
isEvaluating = true;
|
|
source += "';\n" + evaluateValue + ";\n__p += '";
|
|
}
|
|
if (interpolateValue) {
|
|
source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
|
|
}
|
|
index = offset3 + match.length;
|
|
return match;
|
|
});
|
|
source += "';\n";
|
|
var variable = hasOwnProperty24.call(options, "variable") && options.variable;
|
|
if (!variable) {
|
|
source = "with (obj) {\n" + source + "\n}\n";
|
|
} else if (reForbiddenIdentifierChars.test(variable)) {
|
|
throw new Error(INVALID_TEMPL_VAR_ERROR_TEXT);
|
|
}
|
|
source = (isEvaluating ? source.replace(reEmptyStringLeading, "") : source).replace(reEmptyStringMiddle, "$1").replace(reEmptyStringTrailing, "$1;");
|
|
source = "function(" + (variable || "obj") + ") {\n" + (variable ? "" : "obj || (obj = {});\n") + "var __t, __p = ''" + (isEscaping ? ", __e = _.escape" : "") + (isEvaluating ? ", __j = Array.prototype.join;\nfunction print() { __p += __j.call(arguments, '') }\n" : ";\n") + source + "return __p\n}";
|
|
var result2 = attempt_default(function() {
|
|
return Function(importsKeys, sourceURL + "return " + source).apply(void 0, importsValues);
|
|
});
|
|
result2.source = source;
|
|
if (isError_default(result2)) {
|
|
throw result2;
|
|
}
|
|
return result2;
|
|
}
|
|
var template_default = template;
|
|
|
|
// node_modules/lodash-es/throttle.js
|
|
var FUNC_ERROR_TEXT12 = "Expected a function";
|
|
function throttle(func, wait, options) {
|
|
var leading = true, trailing = true;
|
|
if (typeof func != "function") {
|
|
throw new TypeError(FUNC_ERROR_TEXT12);
|
|
}
|
|
if (isObject_default(options)) {
|
|
leading = "leading" in options ? !!options.leading : leading;
|
|
trailing = "trailing" in options ? !!options.trailing : trailing;
|
|
}
|
|
return debounce_default(func, wait, {
|
|
"leading": leading,
|
|
"maxWait": wait,
|
|
"trailing": trailing
|
|
});
|
|
}
|
|
var throttle_default = throttle;
|
|
|
|
// node_modules/lodash-es/thru.js
|
|
function thru(value, interceptor) {
|
|
return interceptor(value);
|
|
}
|
|
var thru_default = thru;
|
|
|
|
// node_modules/lodash-es/times.js
|
|
var MAX_SAFE_INTEGER5 = 9007199254740991;
|
|
var MAX_ARRAY_LENGTH6 = 4294967295;
|
|
var nativeMin12 = Math.min;
|
|
function times(n, iteratee2) {
|
|
n = toInteger_default(n);
|
|
if (n < 1 || n > MAX_SAFE_INTEGER5) {
|
|
return [];
|
|
}
|
|
var index = MAX_ARRAY_LENGTH6, length = nativeMin12(n, MAX_ARRAY_LENGTH6);
|
|
iteratee2 = castFunction_default(iteratee2);
|
|
n -= MAX_ARRAY_LENGTH6;
|
|
var result2 = baseTimes_default(length, iteratee2);
|
|
while (++index < n) {
|
|
iteratee2(index);
|
|
}
|
|
return result2;
|
|
}
|
|
var times_default = times;
|
|
|
|
// node_modules/lodash-es/toIterator.js
|
|
function wrapperToIterator() {
|
|
return this;
|
|
}
|
|
var toIterator_default = wrapperToIterator;
|
|
|
|
// node_modules/lodash-es/_baseWrapperValue.js
|
|
function baseWrapperValue(value, actions) {
|
|
var result2 = value;
|
|
if (result2 instanceof LazyWrapper_default) {
|
|
result2 = result2.value();
|
|
}
|
|
return arrayReduce_default(actions, function(result3, action) {
|
|
return action.func.apply(action.thisArg, arrayPush_default([result3], action.args));
|
|
}, result2);
|
|
}
|
|
var baseWrapperValue_default = baseWrapperValue;
|
|
|
|
// node_modules/lodash-es/wrapperValue.js
|
|
function wrapperValue() {
|
|
return baseWrapperValue_default(this.__wrapped__, this.__actions__);
|
|
}
|
|
var wrapperValue_default = wrapperValue;
|
|
|
|
// node_modules/lodash-es/toLower.js
|
|
function toLower(value) {
|
|
return toString_default(value).toLowerCase();
|
|
}
|
|
var toLower_default = toLower;
|
|
|
|
// node_modules/lodash-es/toPath.js
|
|
function toPath(value) {
|
|
if (isArray_default(value)) {
|
|
return arrayMap_default(value, toKey_default);
|
|
}
|
|
return isSymbol_default(value) ? [value] : copyArray_default(stringToPath_default(toString_default(value)));
|
|
}
|
|
var toPath_default = toPath;
|
|
|
|
// node_modules/lodash-es/toSafeInteger.js
|
|
var MAX_SAFE_INTEGER6 = 9007199254740991;
|
|
function toSafeInteger(value) {
|
|
return value ? baseClamp_default(toInteger_default(value), -MAX_SAFE_INTEGER6, MAX_SAFE_INTEGER6) : value === 0 ? value : 0;
|
|
}
|
|
var toSafeInteger_default = toSafeInteger;
|
|
|
|
// node_modules/lodash-es/toUpper.js
|
|
function toUpper(value) {
|
|
return toString_default(value).toUpperCase();
|
|
}
|
|
var toUpper_default = toUpper;
|
|
|
|
// node_modules/lodash-es/transform.js
|
|
function transform(object4, iteratee2, accumulator) {
|
|
var isArr = isArray_default(object4), isArrLike = isArr || isBuffer_default(object4) || isTypedArray_default(object4);
|
|
iteratee2 = baseIteratee_default(iteratee2, 4);
|
|
if (accumulator == null) {
|
|
var Ctor = object4 && object4.constructor;
|
|
if (isArrLike) {
|
|
accumulator = isArr ? new Ctor() : [];
|
|
} else if (isObject_default(object4)) {
|
|
accumulator = isFunction_default(Ctor) ? baseCreate_default(getPrototype_default(object4)) : {};
|
|
} else {
|
|
accumulator = {};
|
|
}
|
|
}
|
|
(isArrLike ? arrayEach_default : baseForOwn_default)(object4, function(value, index, object5) {
|
|
return iteratee2(accumulator, value, index, object5);
|
|
});
|
|
return accumulator;
|
|
}
|
|
var transform_default = transform;
|
|
|
|
// node_modules/lodash-es/_charsEndIndex.js
|
|
function charsEndIndex(strSymbols, chrSymbols) {
|
|
var index = strSymbols.length;
|
|
while (index-- && baseIndexOf_default(chrSymbols, strSymbols[index], 0) > -1) {
|
|
}
|
|
return index;
|
|
}
|
|
var charsEndIndex_default = charsEndIndex;
|
|
|
|
// node_modules/lodash-es/_charsStartIndex.js
|
|
function charsStartIndex(strSymbols, chrSymbols) {
|
|
var index = -1, length = strSymbols.length;
|
|
while (++index < length && baseIndexOf_default(chrSymbols, strSymbols[index], 0) > -1) {
|
|
}
|
|
return index;
|
|
}
|
|
var charsStartIndex_default = charsStartIndex;
|
|
|
|
// node_modules/lodash-es/trim.js
|
|
function trim(string3, chars, guard) {
|
|
string3 = toString_default(string3);
|
|
if (string3 && (guard || chars === void 0)) {
|
|
return baseTrim_default(string3);
|
|
}
|
|
if (!string3 || !(chars = baseToString_default(chars))) {
|
|
return string3;
|
|
}
|
|
var strSymbols = stringToArray_default(string3), chrSymbols = stringToArray_default(chars), start = charsStartIndex_default(strSymbols, chrSymbols), end = charsEndIndex_default(strSymbols, chrSymbols) + 1;
|
|
return castSlice_default(strSymbols, start, end).join("");
|
|
}
|
|
var trim_default = trim;
|
|
|
|
// node_modules/lodash-es/trimEnd.js
|
|
function trimEnd(string3, chars, guard) {
|
|
string3 = toString_default(string3);
|
|
if (string3 && (guard || chars === void 0)) {
|
|
return string3.slice(0, trimmedEndIndex_default(string3) + 1);
|
|
}
|
|
if (!string3 || !(chars = baseToString_default(chars))) {
|
|
return string3;
|
|
}
|
|
var strSymbols = stringToArray_default(string3), end = charsEndIndex_default(strSymbols, stringToArray_default(chars)) + 1;
|
|
return castSlice_default(strSymbols, 0, end).join("");
|
|
}
|
|
var trimEnd_default = trimEnd;
|
|
|
|
// node_modules/lodash-es/trimStart.js
|
|
var reTrimStart3 = /^\s+/;
|
|
function trimStart(string3, chars, guard) {
|
|
string3 = toString_default(string3);
|
|
if (string3 && (guard || chars === void 0)) {
|
|
return string3.replace(reTrimStart3, "");
|
|
}
|
|
if (!string3 || !(chars = baseToString_default(chars))) {
|
|
return string3;
|
|
}
|
|
var strSymbols = stringToArray_default(string3), start = charsStartIndex_default(strSymbols, stringToArray_default(chars));
|
|
return castSlice_default(strSymbols, start).join("");
|
|
}
|
|
var trimStart_default = trimStart;
|
|
|
|
// node_modules/lodash-es/truncate.js
|
|
var DEFAULT_TRUNC_LENGTH = 30;
|
|
var DEFAULT_TRUNC_OMISSION = "...";
|
|
var reFlags2 = /\w*$/;
|
|
function truncate(string3, options) {
|
|
var length = DEFAULT_TRUNC_LENGTH, omission = DEFAULT_TRUNC_OMISSION;
|
|
if (isObject_default(options)) {
|
|
var separator = "separator" in options ? options.separator : separator;
|
|
length = "length" in options ? toInteger_default(options.length) : length;
|
|
omission = "omission" in options ? baseToString_default(options.omission) : omission;
|
|
}
|
|
string3 = toString_default(string3);
|
|
var strLength = string3.length;
|
|
if (hasUnicode_default(string3)) {
|
|
var strSymbols = stringToArray_default(string3);
|
|
strLength = strSymbols.length;
|
|
}
|
|
if (length >= strLength) {
|
|
return string3;
|
|
}
|
|
var end = length - stringSize_default(omission);
|
|
if (end < 1) {
|
|
return omission;
|
|
}
|
|
var result2 = strSymbols ? castSlice_default(strSymbols, 0, end).join("") : string3.slice(0, end);
|
|
if (separator === void 0) {
|
|
return result2 + omission;
|
|
}
|
|
if (strSymbols) {
|
|
end += result2.length - end;
|
|
}
|
|
if (isRegExp_default(separator)) {
|
|
if (string3.slice(end).search(separator)) {
|
|
var match, substring = result2;
|
|
if (!separator.global) {
|
|
separator = RegExp(separator.source, toString_default(reFlags2.exec(separator)) + "g");
|
|
}
|
|
separator.lastIndex = 0;
|
|
while (match = separator.exec(substring)) {
|
|
var newEnd = match.index;
|
|
}
|
|
result2 = result2.slice(0, newEnd === void 0 ? end : newEnd);
|
|
}
|
|
} else if (string3.indexOf(baseToString_default(separator), end) != end) {
|
|
var index = result2.lastIndexOf(separator);
|
|
if (index > -1) {
|
|
result2 = result2.slice(0, index);
|
|
}
|
|
}
|
|
return result2 + omission;
|
|
}
|
|
var truncate_default = truncate;
|
|
|
|
// node_modules/lodash-es/unary.js
|
|
function unary(func) {
|
|
return ary_default(func, 1);
|
|
}
|
|
var unary_default = unary;
|
|
|
|
// node_modules/lodash-es/_unescapeHtmlChar.js
|
|
var htmlUnescapes = {
|
|
"&": "&",
|
|
"<": "<",
|
|
">": ">",
|
|
""": '"',
|
|
"'": "'"
|
|
};
|
|
var unescapeHtmlChar = basePropertyOf_default(htmlUnescapes);
|
|
var unescapeHtmlChar_default = unescapeHtmlChar;
|
|
|
|
// node_modules/lodash-es/unescape.js
|
|
var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g;
|
|
var reHasEscapedHtml = RegExp(reEscapedHtml.source);
|
|
function unescape(string3) {
|
|
string3 = toString_default(string3);
|
|
return string3 && reHasEscapedHtml.test(string3) ? string3.replace(reEscapedHtml, unescapeHtmlChar_default) : string3;
|
|
}
|
|
var unescape_default = unescape;
|
|
|
|
// node_modules/lodash-es/_createSet.js
|
|
var INFINITY6 = 1 / 0;
|
|
var createSet = !(Set_default && 1 / setToArray_default(new Set_default([, -0]))[1] == INFINITY6) ? noop_default : function(values2) {
|
|
return new Set_default(values2);
|
|
};
|
|
var createSet_default = createSet;
|
|
|
|
// node_modules/lodash-es/_baseUniq.js
|
|
var LARGE_ARRAY_SIZE3 = 200;
|
|
function baseUniq(array4, iteratee2, comparator) {
|
|
var index = -1, includes2 = arrayIncludes_default, length = array4.length, isCommon = true, result2 = [], seen = result2;
|
|
if (comparator) {
|
|
isCommon = false;
|
|
includes2 = arrayIncludesWith_default;
|
|
} else if (length >= LARGE_ARRAY_SIZE3) {
|
|
var set4 = iteratee2 ? null : createSet_default(array4);
|
|
if (set4) {
|
|
return setToArray_default(set4);
|
|
}
|
|
isCommon = false;
|
|
includes2 = cacheHas_default;
|
|
seen = new SetCache_default();
|
|
} else {
|
|
seen = iteratee2 ? [] : result2;
|
|
}
|
|
outer:
|
|
while (++index < length) {
|
|
var value = array4[index], computed2 = iteratee2 ? iteratee2(value) : value;
|
|
value = comparator || value !== 0 ? value : 0;
|
|
if (isCommon && computed2 === computed2) {
|
|
var seenIndex = seen.length;
|
|
while (seenIndex--) {
|
|
if (seen[seenIndex] === computed2) {
|
|
continue outer;
|
|
}
|
|
}
|
|
if (iteratee2) {
|
|
seen.push(computed2);
|
|
}
|
|
result2.push(value);
|
|
} else if (!includes2(seen, computed2, comparator)) {
|
|
if (seen !== result2) {
|
|
seen.push(computed2);
|
|
}
|
|
result2.push(value);
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
var baseUniq_default = baseUniq;
|
|
|
|
// node_modules/lodash-es/union.js
|
|
var union = baseRest_default(function(arrays) {
|
|
return baseUniq_default(baseFlatten_default(arrays, 1, isArrayLikeObject_default, true));
|
|
});
|
|
var union_default = union;
|
|
|
|
// node_modules/lodash-es/unionBy.js
|
|
var unionBy = baseRest_default(function(arrays) {
|
|
var iteratee2 = last_default(arrays);
|
|
if (isArrayLikeObject_default(iteratee2)) {
|
|
iteratee2 = void 0;
|
|
}
|
|
return baseUniq_default(baseFlatten_default(arrays, 1, isArrayLikeObject_default, true), baseIteratee_default(iteratee2, 2));
|
|
});
|
|
var unionBy_default = unionBy;
|
|
|
|
// node_modules/lodash-es/unionWith.js
|
|
var unionWith = baseRest_default(function(arrays) {
|
|
var comparator = last_default(arrays);
|
|
comparator = typeof comparator == "function" ? comparator : void 0;
|
|
return baseUniq_default(baseFlatten_default(arrays, 1, isArrayLikeObject_default, true), void 0, comparator);
|
|
});
|
|
var unionWith_default = unionWith;
|
|
|
|
// node_modules/lodash-es/uniq.js
|
|
function uniq(array4) {
|
|
return array4 && array4.length ? baseUniq_default(array4) : [];
|
|
}
|
|
var uniq_default = uniq;
|
|
|
|
// node_modules/lodash-es/uniqBy.js
|
|
function uniqBy(array4, iteratee2) {
|
|
return array4 && array4.length ? baseUniq_default(array4, baseIteratee_default(iteratee2, 2)) : [];
|
|
}
|
|
var uniqBy_default = uniqBy;
|
|
|
|
// node_modules/lodash-es/uniqWith.js
|
|
function uniqWith(array4, comparator) {
|
|
comparator = typeof comparator == "function" ? comparator : void 0;
|
|
return array4 && array4.length ? baseUniq_default(array4, void 0, comparator) : [];
|
|
}
|
|
var uniqWith_default = uniqWith;
|
|
|
|
// node_modules/lodash-es/uniqueId.js
|
|
var idCounter = 0;
|
|
function uniqueId(prefix) {
|
|
var id = ++idCounter;
|
|
return toString_default(prefix) + id;
|
|
}
|
|
var uniqueId_default = uniqueId;
|
|
|
|
// node_modules/lodash-es/unset.js
|
|
function unset(object4, path) {
|
|
return object4 == null ? true : baseUnset_default(object4, path);
|
|
}
|
|
var unset_default = unset;
|
|
|
|
// node_modules/lodash-es/unzip.js
|
|
var nativeMax15 = Math.max;
|
|
function unzip(array4) {
|
|
if (!(array4 && array4.length)) {
|
|
return [];
|
|
}
|
|
var length = 0;
|
|
array4 = arrayFilter_default(array4, function(group) {
|
|
if (isArrayLikeObject_default(group)) {
|
|
length = nativeMax15(group.length, length);
|
|
return true;
|
|
}
|
|
});
|
|
return baseTimes_default(length, function(index) {
|
|
return arrayMap_default(array4, baseProperty_default(index));
|
|
});
|
|
}
|
|
var unzip_default = unzip;
|
|
|
|
// node_modules/lodash-es/unzipWith.js
|
|
function unzipWith(array4, iteratee2) {
|
|
if (!(array4 && array4.length)) {
|
|
return [];
|
|
}
|
|
var result2 = unzip_default(array4);
|
|
if (iteratee2 == null) {
|
|
return result2;
|
|
}
|
|
return arrayMap_default(result2, function(group) {
|
|
return apply_default(iteratee2, void 0, group);
|
|
});
|
|
}
|
|
var unzipWith_default = unzipWith;
|
|
|
|
// node_modules/lodash-es/_baseUpdate.js
|
|
function baseUpdate(object4, path, updater, customizer) {
|
|
return baseSet_default(object4, path, updater(baseGet_default(object4, path)), customizer);
|
|
}
|
|
var baseUpdate_default = baseUpdate;
|
|
|
|
// node_modules/lodash-es/update.js
|
|
function update(object4, path, updater) {
|
|
return object4 == null ? object4 : baseUpdate_default(object4, path, castFunction_default(updater));
|
|
}
|
|
var update_default = update;
|
|
|
|
// node_modules/lodash-es/updateWith.js
|
|
function updateWith(object4, path, updater, customizer) {
|
|
customizer = typeof customizer == "function" ? customizer : void 0;
|
|
return object4 == null ? object4 : baseUpdate_default(object4, path, castFunction_default(updater), customizer);
|
|
}
|
|
var updateWith_default = updateWith;
|
|
|
|
// node_modules/lodash-es/upperCase.js
|
|
var upperCase = createCompounder_default(function(result2, word, index) {
|
|
return result2 + (index ? " " : "") + word.toUpperCase();
|
|
});
|
|
var upperCase_default = upperCase;
|
|
|
|
// node_modules/lodash-es/valuesIn.js
|
|
function valuesIn(object4) {
|
|
return object4 == null ? [] : baseValues_default(object4, keysIn_default(object4));
|
|
}
|
|
var valuesIn_default = valuesIn;
|
|
|
|
// node_modules/lodash-es/without.js
|
|
var without = baseRest_default(function(array4, values2) {
|
|
return isArrayLikeObject_default(array4) ? baseDifference_default(array4, values2) : [];
|
|
});
|
|
var without_default = without;
|
|
|
|
// node_modules/lodash-es/wrap.js
|
|
function wrap(value, wrapper) {
|
|
return partial_default(castFunction_default(wrapper), value);
|
|
}
|
|
var wrap_default = wrap;
|
|
|
|
// node_modules/lodash-es/wrapperAt.js
|
|
var wrapperAt = flatRest_default(function(paths) {
|
|
var length = paths.length, start = length ? paths[0] : 0, value = this.__wrapped__, interceptor = function(object4) {
|
|
return baseAt_default(object4, paths);
|
|
};
|
|
if (length > 1 || this.__actions__.length || !(value instanceof LazyWrapper_default) || !isIndex_default(start)) {
|
|
return this.thru(interceptor);
|
|
}
|
|
value = value.slice(start, +start + (length ? 1 : 0));
|
|
value.__actions__.push({
|
|
"func": thru_default,
|
|
"args": [interceptor],
|
|
"thisArg": void 0
|
|
});
|
|
return new LodashWrapper_default(value, this.__chain__).thru(function(array4) {
|
|
if (length && !array4.length) {
|
|
array4.push(void 0);
|
|
}
|
|
return array4;
|
|
});
|
|
});
|
|
var wrapperAt_default = wrapperAt;
|
|
|
|
// node_modules/lodash-es/wrapperChain.js
|
|
function wrapperChain() {
|
|
return chain_default(this);
|
|
}
|
|
var wrapperChain_default = wrapperChain;
|
|
|
|
// node_modules/lodash-es/wrapperReverse.js
|
|
function wrapperReverse() {
|
|
var value = this.__wrapped__;
|
|
if (value instanceof LazyWrapper_default) {
|
|
var wrapped = value;
|
|
if (this.__actions__.length) {
|
|
wrapped = new LazyWrapper_default(this);
|
|
}
|
|
wrapped = wrapped.reverse();
|
|
wrapped.__actions__.push({
|
|
"func": thru_default,
|
|
"args": [reverse_default],
|
|
"thisArg": void 0
|
|
});
|
|
return new LodashWrapper_default(wrapped, this.__chain__);
|
|
}
|
|
return this.thru(reverse_default);
|
|
}
|
|
var wrapperReverse_default = wrapperReverse;
|
|
|
|
// node_modules/lodash-es/_baseXor.js
|
|
function baseXor(arrays, iteratee2, comparator) {
|
|
var length = arrays.length;
|
|
if (length < 2) {
|
|
return length ? baseUniq_default(arrays[0]) : [];
|
|
}
|
|
var index = -1, result2 = Array(length);
|
|
while (++index < length) {
|
|
var array4 = arrays[index], othIndex = -1;
|
|
while (++othIndex < length) {
|
|
if (othIndex != index) {
|
|
result2[index] = baseDifference_default(result2[index] || array4, arrays[othIndex], iteratee2, comparator);
|
|
}
|
|
}
|
|
}
|
|
return baseUniq_default(baseFlatten_default(result2, 1), iteratee2, comparator);
|
|
}
|
|
var baseXor_default = baseXor;
|
|
|
|
// node_modules/lodash-es/xor.js
|
|
var xor = baseRest_default(function(arrays) {
|
|
return baseXor_default(arrayFilter_default(arrays, isArrayLikeObject_default));
|
|
});
|
|
var xor_default = xor;
|
|
|
|
// node_modules/lodash-es/xorBy.js
|
|
var xorBy = baseRest_default(function(arrays) {
|
|
var iteratee2 = last_default(arrays);
|
|
if (isArrayLikeObject_default(iteratee2)) {
|
|
iteratee2 = void 0;
|
|
}
|
|
return baseXor_default(arrayFilter_default(arrays, isArrayLikeObject_default), baseIteratee_default(iteratee2, 2));
|
|
});
|
|
var xorBy_default = xorBy;
|
|
|
|
// node_modules/lodash-es/xorWith.js
|
|
var xorWith = baseRest_default(function(arrays) {
|
|
var comparator = last_default(arrays);
|
|
comparator = typeof comparator == "function" ? comparator : void 0;
|
|
return baseXor_default(arrayFilter_default(arrays, isArrayLikeObject_default), void 0, comparator);
|
|
});
|
|
var xorWith_default = xorWith;
|
|
|
|
// node_modules/lodash-es/zip.js
|
|
var zip = baseRest_default(unzip_default);
|
|
var zip_default = zip;
|
|
|
|
// node_modules/lodash-es/_baseZipObject.js
|
|
function baseZipObject(props2, values2, assignFunc) {
|
|
var index = -1, length = props2.length, valsLength = values2.length, result2 = {};
|
|
while (++index < length) {
|
|
var value = index < valsLength ? values2[index] : void 0;
|
|
assignFunc(result2, props2[index], value);
|
|
}
|
|
return result2;
|
|
}
|
|
var baseZipObject_default = baseZipObject;
|
|
|
|
// node_modules/lodash-es/zipObject.js
|
|
function zipObject(props2, values2) {
|
|
return baseZipObject_default(props2 || [], values2 || [], assignValue_default);
|
|
}
|
|
var zipObject_default = zipObject;
|
|
|
|
// node_modules/lodash-es/zipObjectDeep.js
|
|
function zipObjectDeep(props2, values2) {
|
|
return baseZipObject_default(props2 || [], values2 || [], baseSet_default);
|
|
}
|
|
var zipObjectDeep_default = zipObjectDeep;
|
|
|
|
// node_modules/lodash-es/zipWith.js
|
|
var zipWith = baseRest_default(function(arrays) {
|
|
var length = arrays.length, iteratee2 = length > 1 ? arrays[length - 1] : void 0;
|
|
iteratee2 = typeof iteratee2 == "function" ? (arrays.pop(), iteratee2) : void 0;
|
|
return unzipWith_default(arrays, iteratee2);
|
|
});
|
|
var zipWith_default = zipWith;
|
|
|
|
// node_modules/lodash-es/array.default.js
|
|
var array_default_default = {
|
|
chunk: chunk_default,
|
|
compact: compact_default,
|
|
concat: concat_default,
|
|
difference: difference_default,
|
|
differenceBy: differenceBy_default,
|
|
differenceWith: differenceWith_default,
|
|
drop: drop_default,
|
|
dropRight: dropRight_default,
|
|
dropRightWhile: dropRightWhile_default,
|
|
dropWhile: dropWhile_default,
|
|
fill: fill_default,
|
|
findIndex: findIndex_default,
|
|
findLastIndex: findLastIndex_default,
|
|
first: head_default,
|
|
flatten: flatten_default,
|
|
flattenDeep: flattenDeep_default,
|
|
flattenDepth: flattenDepth_default,
|
|
fromPairs: fromPairs_default,
|
|
head: head_default,
|
|
indexOf: indexOf_default,
|
|
initial: initial_default,
|
|
intersection: intersection_default,
|
|
intersectionBy: intersectionBy_default,
|
|
intersectionWith: intersectionWith_default,
|
|
join: join_default,
|
|
last: last_default,
|
|
lastIndexOf: lastIndexOf_default,
|
|
nth: nth_default,
|
|
pull: pull_default,
|
|
pullAll: pullAll_default,
|
|
pullAllBy: pullAllBy_default,
|
|
pullAllWith: pullAllWith_default,
|
|
pullAt: pullAt_default,
|
|
remove: remove_default,
|
|
reverse: reverse_default,
|
|
slice: slice_default,
|
|
sortedIndex: sortedIndex_default,
|
|
sortedIndexBy: sortedIndexBy_default,
|
|
sortedIndexOf: sortedIndexOf_default,
|
|
sortedLastIndex: sortedLastIndex_default,
|
|
sortedLastIndexBy: sortedLastIndexBy_default,
|
|
sortedLastIndexOf: sortedLastIndexOf_default,
|
|
sortedUniq: sortedUniq_default,
|
|
sortedUniqBy: sortedUniqBy_default,
|
|
tail: tail_default,
|
|
take: take_default,
|
|
takeRight: takeRight_default,
|
|
takeRightWhile: takeRightWhile_default,
|
|
takeWhile: takeWhile_default,
|
|
union: union_default,
|
|
unionBy: unionBy_default,
|
|
unionWith: unionWith_default,
|
|
uniq: uniq_default,
|
|
uniqBy: uniqBy_default,
|
|
uniqWith: uniqWith_default,
|
|
unzip: unzip_default,
|
|
unzipWith: unzipWith_default,
|
|
without: without_default,
|
|
xor: xor_default,
|
|
xorBy: xorBy_default,
|
|
xorWith: xorWith_default,
|
|
zip: zip_default,
|
|
zipObject: zipObject_default,
|
|
zipObjectDeep: zipObjectDeep_default,
|
|
zipWith: zipWith_default
|
|
};
|
|
|
|
// node_modules/lodash-es/collection.default.js
|
|
var collection_default_default = {
|
|
countBy: countBy_default,
|
|
each: forEach_default,
|
|
eachRight: forEachRight_default,
|
|
every: every_default,
|
|
filter: filter_default,
|
|
find: find_default,
|
|
findLast: findLast_default,
|
|
flatMap: flatMap_default,
|
|
flatMapDeep: flatMapDeep_default,
|
|
flatMapDepth: flatMapDepth_default,
|
|
forEach: forEach_default,
|
|
forEachRight: forEachRight_default,
|
|
groupBy: groupBy_default,
|
|
includes: includes_default,
|
|
invokeMap: invokeMap_default,
|
|
keyBy: keyBy_default,
|
|
map: map_default,
|
|
orderBy: orderBy_default,
|
|
partition: partition_default,
|
|
reduce: reduce_default,
|
|
reduceRight: reduceRight_default,
|
|
reject: reject_default,
|
|
sample: sample_default,
|
|
sampleSize: sampleSize_default,
|
|
shuffle: shuffle_default,
|
|
size: size_default,
|
|
some: some_default,
|
|
sortBy: sortBy_default
|
|
};
|
|
|
|
// node_modules/lodash-es/date.default.js
|
|
var date_default_default = {
|
|
now: now_default
|
|
};
|
|
|
|
// node_modules/lodash-es/function.default.js
|
|
var function_default_default = {
|
|
after: after_default,
|
|
ary: ary_default,
|
|
before: before_default,
|
|
bind: bind_default,
|
|
bindKey: bindKey_default,
|
|
curry: curry_default,
|
|
curryRight: curryRight_default,
|
|
debounce: debounce_default,
|
|
defer: defer_default,
|
|
delay: delay_default,
|
|
flip: flip_default,
|
|
memoize: memoize_default,
|
|
negate: negate_default,
|
|
once: once_default,
|
|
overArgs: overArgs_default,
|
|
partial: partial_default,
|
|
partialRight: partialRight_default,
|
|
rearg: rearg_default,
|
|
rest: rest_default,
|
|
spread: spread_default,
|
|
throttle: throttle_default,
|
|
unary: unary_default,
|
|
wrap: wrap_default
|
|
};
|
|
|
|
// node_modules/lodash-es/lang.default.js
|
|
var lang_default_default = {
|
|
castArray: castArray_default,
|
|
clone: clone_default,
|
|
cloneDeep: cloneDeep_default,
|
|
cloneDeepWith: cloneDeepWith_default,
|
|
cloneWith: cloneWith_default,
|
|
conformsTo: conformsTo_default,
|
|
eq: eq_default,
|
|
gt: gt_default,
|
|
gte: gte_default,
|
|
isArguments: isArguments_default,
|
|
isArray: isArray_default,
|
|
isArrayBuffer: isArrayBuffer_default,
|
|
isArrayLike: isArrayLike_default,
|
|
isArrayLikeObject: isArrayLikeObject_default,
|
|
isBoolean: isBoolean_default,
|
|
isBuffer: isBuffer_default,
|
|
isDate: isDate_default,
|
|
isElement: isElement_default,
|
|
isEmpty: isEmpty_default,
|
|
isEqual: isEqual_default,
|
|
isEqualWith: isEqualWith_default,
|
|
isError: isError_default,
|
|
isFinite: isFinite_default,
|
|
isFunction: isFunction_default,
|
|
isInteger: isInteger_default,
|
|
isLength: isLength_default,
|
|
isMap: isMap_default,
|
|
isMatch: isMatch_default,
|
|
isMatchWith: isMatchWith_default,
|
|
isNaN: isNaN_default,
|
|
isNative: isNative_default,
|
|
isNil: isNil_default,
|
|
isNull: isNull_default,
|
|
isNumber: isNumber_default,
|
|
isObject: isObject_default,
|
|
isObjectLike: isObjectLike_default,
|
|
isPlainObject: isPlainObject_default,
|
|
isRegExp: isRegExp_default,
|
|
isSafeInteger: isSafeInteger_default,
|
|
isSet: isSet_default,
|
|
isString: isString_default,
|
|
isSymbol: isSymbol_default,
|
|
isTypedArray: isTypedArray_default,
|
|
isUndefined: isUndefined_default,
|
|
isWeakMap: isWeakMap_default,
|
|
isWeakSet: isWeakSet_default,
|
|
lt: lt_default,
|
|
lte: lte_default,
|
|
toArray: toArray_default,
|
|
toFinite: toFinite_default,
|
|
toInteger: toInteger_default,
|
|
toLength: toLength_default,
|
|
toNumber: toNumber_default,
|
|
toPlainObject: toPlainObject_default,
|
|
toSafeInteger: toSafeInteger_default,
|
|
toString: toString_default
|
|
};
|
|
|
|
// node_modules/lodash-es/math.default.js
|
|
var math_default_default = {
|
|
add: add_default,
|
|
ceil: ceil_default,
|
|
divide: divide_default,
|
|
floor: floor_default,
|
|
max: max_default,
|
|
maxBy: maxBy_default,
|
|
mean: mean_default,
|
|
meanBy: meanBy_default,
|
|
min: min_default,
|
|
minBy: minBy_default,
|
|
multiply: multiply_default,
|
|
round: round_default,
|
|
subtract: subtract_default,
|
|
sum: sum_default,
|
|
sumBy: sumBy_default
|
|
};
|
|
|
|
// node_modules/lodash-es/number.default.js
|
|
var number_default_default = {
|
|
clamp: clamp_default,
|
|
inRange: inRange_default,
|
|
random: random_default
|
|
};
|
|
|
|
// node_modules/lodash-es/object.default.js
|
|
var object_default_default = {
|
|
assign: assign_default,
|
|
assignIn: assignIn_default,
|
|
assignInWith: assignInWith_default,
|
|
assignWith: assignWith_default,
|
|
at: at_default,
|
|
create: create_default,
|
|
defaults: defaults_default,
|
|
defaultsDeep: defaultsDeep_default,
|
|
entries: toPairs_default,
|
|
entriesIn: toPairsIn_default,
|
|
extend: assignIn_default,
|
|
extendWith: assignInWith_default,
|
|
findKey: findKey_default,
|
|
findLastKey: findLastKey_default,
|
|
forIn: forIn_default,
|
|
forInRight: forInRight_default,
|
|
forOwn: forOwn_default,
|
|
forOwnRight: forOwnRight_default,
|
|
functions: functions_default,
|
|
functionsIn: functionsIn_default,
|
|
get: get_default,
|
|
has: has_default,
|
|
hasIn: hasIn_default,
|
|
invert: invert_default,
|
|
invertBy: invertBy_default,
|
|
invoke: invoke_default,
|
|
keys: keys_default,
|
|
keysIn: keysIn_default,
|
|
mapKeys: mapKeys_default,
|
|
mapValues: mapValues_default,
|
|
merge: merge_default,
|
|
mergeWith: mergeWith_default,
|
|
omit: omit_default,
|
|
omitBy: omitBy_default,
|
|
pick: pick_default,
|
|
pickBy: pickBy_default,
|
|
result: result_default,
|
|
set: set_default,
|
|
setWith: setWith_default,
|
|
toPairs: toPairs_default,
|
|
toPairsIn: toPairsIn_default,
|
|
transform: transform_default,
|
|
unset: unset_default,
|
|
update: update_default,
|
|
updateWith: updateWith_default,
|
|
values: values_default,
|
|
valuesIn: valuesIn_default
|
|
};
|
|
|
|
// node_modules/lodash-es/seq.default.js
|
|
var seq_default_default = {
|
|
at: wrapperAt_default,
|
|
chain: chain_default,
|
|
commit: commit_default,
|
|
lodash: wrapperLodash_default,
|
|
next: next_default,
|
|
plant: plant_default,
|
|
reverse: wrapperReverse_default,
|
|
tap: tap_default,
|
|
thru: thru_default,
|
|
toIterator: toIterator_default,
|
|
toJSON: wrapperValue_default,
|
|
value: wrapperValue_default,
|
|
valueOf: wrapperValue_default,
|
|
wrapperChain: wrapperChain_default
|
|
};
|
|
|
|
// node_modules/lodash-es/string.default.js
|
|
var string_default_default = {
|
|
camelCase: camelCase_default,
|
|
capitalize: capitalize_default,
|
|
deburr: deburr_default,
|
|
endsWith: endsWith_default,
|
|
escape: escape_default,
|
|
escapeRegExp: escapeRegExp_default,
|
|
kebabCase: kebabCase_default,
|
|
lowerCase: lowerCase_default,
|
|
lowerFirst: lowerFirst_default,
|
|
pad: pad_default,
|
|
padEnd: padEnd_default,
|
|
padStart: padStart_default,
|
|
parseInt: parseInt_default,
|
|
repeat: repeat_default,
|
|
replace: replace_default,
|
|
snakeCase: snakeCase_default,
|
|
split: split_default,
|
|
startCase: startCase_default,
|
|
startsWith: startsWith_default,
|
|
template: template_default,
|
|
templateSettings: templateSettings_default,
|
|
toLower: toLower_default,
|
|
toUpper: toUpper_default,
|
|
trim: trim_default,
|
|
trimEnd: trimEnd_default,
|
|
trimStart: trimStart_default,
|
|
truncate: truncate_default,
|
|
unescape: unescape_default,
|
|
upperCase: upperCase_default,
|
|
upperFirst: upperFirst_default,
|
|
words: words_default
|
|
};
|
|
|
|
// node_modules/lodash-es/util.default.js
|
|
var util_default_default = {
|
|
attempt: attempt_default,
|
|
bindAll: bindAll_default,
|
|
cond: cond_default,
|
|
conforms: conforms_default,
|
|
constant: constant_default,
|
|
defaultTo: defaultTo_default,
|
|
flow: flow_default,
|
|
flowRight: flowRight_default,
|
|
identity: identity_default,
|
|
iteratee: iteratee_default,
|
|
matches: matches_default,
|
|
matchesProperty: matchesProperty_default,
|
|
method: method_default,
|
|
methodOf: methodOf_default,
|
|
mixin: mixin_default,
|
|
noop: noop_default,
|
|
nthArg: nthArg_default,
|
|
over: over_default,
|
|
overEvery: overEvery_default,
|
|
overSome: overSome_default,
|
|
property: property_default,
|
|
propertyOf: propertyOf_default,
|
|
range: range_default,
|
|
rangeRight: rangeRight_default,
|
|
stubArray: stubArray_default,
|
|
stubFalse: stubFalse_default,
|
|
stubObject: stubObject_default,
|
|
stubString: stubString_default,
|
|
stubTrue: stubTrue_default,
|
|
times: times_default,
|
|
toPath: toPath_default,
|
|
uniqueId: uniqueId_default
|
|
};
|
|
|
|
// node_modules/lodash-es/_lazyClone.js
|
|
function lazyClone() {
|
|
var result2 = new LazyWrapper_default(this.__wrapped__);
|
|
result2.__actions__ = copyArray_default(this.__actions__);
|
|
result2.__dir__ = this.__dir__;
|
|
result2.__filtered__ = this.__filtered__;
|
|
result2.__iteratees__ = copyArray_default(this.__iteratees__);
|
|
result2.__takeCount__ = this.__takeCount__;
|
|
result2.__views__ = copyArray_default(this.__views__);
|
|
return result2;
|
|
}
|
|
var lazyClone_default = lazyClone;
|
|
|
|
// node_modules/lodash-es/_lazyReverse.js
|
|
function lazyReverse() {
|
|
if (this.__filtered__) {
|
|
var result2 = new LazyWrapper_default(this);
|
|
result2.__dir__ = -1;
|
|
result2.__filtered__ = true;
|
|
} else {
|
|
result2 = this.clone();
|
|
result2.__dir__ *= -1;
|
|
}
|
|
return result2;
|
|
}
|
|
var lazyReverse_default = lazyReverse;
|
|
|
|
// node_modules/lodash-es/_getView.js
|
|
var nativeMax16 = Math.max;
|
|
var nativeMin13 = Math.min;
|
|
function getView(start, end, transforms) {
|
|
var index = -1, length = transforms.length;
|
|
while (++index < length) {
|
|
var data = transforms[index], size3 = data.size;
|
|
switch (data.type) {
|
|
case "drop":
|
|
start += size3;
|
|
break;
|
|
case "dropRight":
|
|
end -= size3;
|
|
break;
|
|
case "take":
|
|
end = nativeMin13(end, start + size3);
|
|
break;
|
|
case "takeRight":
|
|
start = nativeMax16(start, end - size3);
|
|
break;
|
|
}
|
|
}
|
|
return { "start": start, "end": end };
|
|
}
|
|
var getView_default = getView;
|
|
|
|
// node_modules/lodash-es/_lazyValue.js
|
|
var LAZY_FILTER_FLAG = 1;
|
|
var LAZY_MAP_FLAG = 2;
|
|
var nativeMin14 = Math.min;
|
|
function lazyValue() {
|
|
var array4 = this.__wrapped__.value(), dir = this.__dir__, isArr = isArray_default(array4), isRight = dir < 0, arrLength = isArr ? array4.length : 0, view = getView_default(0, arrLength, this.__views__), start = view.start, end = view.end, length = end - start, index = isRight ? end : start - 1, iteratees = this.__iteratees__, iterLength = iteratees.length, resIndex = 0, takeCount = nativeMin14(length, this.__takeCount__);
|
|
if (!isArr || !isRight && arrLength == length && takeCount == length) {
|
|
return baseWrapperValue_default(array4, this.__actions__);
|
|
}
|
|
var result2 = [];
|
|
outer:
|
|
while (length-- && resIndex < takeCount) {
|
|
index += dir;
|
|
var iterIndex = -1, value = array4[index];
|
|
while (++iterIndex < iterLength) {
|
|
var data = iteratees[iterIndex], iteratee2 = data.iteratee, type4 = data.type, computed2 = iteratee2(value);
|
|
if (type4 == LAZY_MAP_FLAG) {
|
|
value = computed2;
|
|
} else if (!computed2) {
|
|
if (type4 == LAZY_FILTER_FLAG) {
|
|
continue outer;
|
|
} else {
|
|
break outer;
|
|
}
|
|
}
|
|
}
|
|
result2[resIndex++] = value;
|
|
}
|
|
return result2;
|
|
}
|
|
var lazyValue_default = lazyValue;
|
|
|
|
// node_modules/lodash-es/lodash.default.js
|
|
var VERSION = "4.17.21";
|
|
var WRAP_BIND_KEY_FLAG7 = 2;
|
|
var LAZY_FILTER_FLAG2 = 1;
|
|
var LAZY_WHILE_FLAG = 3;
|
|
var MAX_ARRAY_LENGTH7 = 4294967295;
|
|
var arrayProto6 = Array.prototype;
|
|
var objectProto29 = Object.prototype;
|
|
var hasOwnProperty25 = objectProto29.hasOwnProperty;
|
|
var symIterator2 = Symbol_default ? Symbol_default.iterator : void 0;
|
|
var nativeMax17 = Math.max;
|
|
var nativeMin15 = Math.min;
|
|
var mixin2 = function(func) {
|
|
return function(object4, source, options) {
|
|
if (options == null) {
|
|
var isObj = isObject_default(source), props2 = isObj && keys_default(source), methodNames = props2 && props2.length && baseFunctions_default(source, props2);
|
|
if (!(methodNames ? methodNames.length : isObj)) {
|
|
options = source;
|
|
source = object4;
|
|
object4 = this;
|
|
}
|
|
}
|
|
return func(object4, source, options);
|
|
};
|
|
}(mixin_default);
|
|
wrapperLodash_default.after = function_default_default.after;
|
|
wrapperLodash_default.ary = function_default_default.ary;
|
|
wrapperLodash_default.assign = object_default_default.assign;
|
|
wrapperLodash_default.assignIn = object_default_default.assignIn;
|
|
wrapperLodash_default.assignInWith = object_default_default.assignInWith;
|
|
wrapperLodash_default.assignWith = object_default_default.assignWith;
|
|
wrapperLodash_default.at = object_default_default.at;
|
|
wrapperLodash_default.before = function_default_default.before;
|
|
wrapperLodash_default.bind = function_default_default.bind;
|
|
wrapperLodash_default.bindAll = util_default_default.bindAll;
|
|
wrapperLodash_default.bindKey = function_default_default.bindKey;
|
|
wrapperLodash_default.castArray = lang_default_default.castArray;
|
|
wrapperLodash_default.chain = seq_default_default.chain;
|
|
wrapperLodash_default.chunk = array_default_default.chunk;
|
|
wrapperLodash_default.compact = array_default_default.compact;
|
|
wrapperLodash_default.concat = array_default_default.concat;
|
|
wrapperLodash_default.cond = util_default_default.cond;
|
|
wrapperLodash_default.conforms = util_default_default.conforms;
|
|
wrapperLodash_default.constant = util_default_default.constant;
|
|
wrapperLodash_default.countBy = collection_default_default.countBy;
|
|
wrapperLodash_default.create = object_default_default.create;
|
|
wrapperLodash_default.curry = function_default_default.curry;
|
|
wrapperLodash_default.curryRight = function_default_default.curryRight;
|
|
wrapperLodash_default.debounce = function_default_default.debounce;
|
|
wrapperLodash_default.defaults = object_default_default.defaults;
|
|
wrapperLodash_default.defaultsDeep = object_default_default.defaultsDeep;
|
|
wrapperLodash_default.defer = function_default_default.defer;
|
|
wrapperLodash_default.delay = function_default_default.delay;
|
|
wrapperLodash_default.difference = array_default_default.difference;
|
|
wrapperLodash_default.differenceBy = array_default_default.differenceBy;
|
|
wrapperLodash_default.differenceWith = array_default_default.differenceWith;
|
|
wrapperLodash_default.drop = array_default_default.drop;
|
|
wrapperLodash_default.dropRight = array_default_default.dropRight;
|
|
wrapperLodash_default.dropRightWhile = array_default_default.dropRightWhile;
|
|
wrapperLodash_default.dropWhile = array_default_default.dropWhile;
|
|
wrapperLodash_default.fill = array_default_default.fill;
|
|
wrapperLodash_default.filter = collection_default_default.filter;
|
|
wrapperLodash_default.flatMap = collection_default_default.flatMap;
|
|
wrapperLodash_default.flatMapDeep = collection_default_default.flatMapDeep;
|
|
wrapperLodash_default.flatMapDepth = collection_default_default.flatMapDepth;
|
|
wrapperLodash_default.flatten = array_default_default.flatten;
|
|
wrapperLodash_default.flattenDeep = array_default_default.flattenDeep;
|
|
wrapperLodash_default.flattenDepth = array_default_default.flattenDepth;
|
|
wrapperLodash_default.flip = function_default_default.flip;
|
|
wrapperLodash_default.flow = util_default_default.flow;
|
|
wrapperLodash_default.flowRight = util_default_default.flowRight;
|
|
wrapperLodash_default.fromPairs = array_default_default.fromPairs;
|
|
wrapperLodash_default.functions = object_default_default.functions;
|
|
wrapperLodash_default.functionsIn = object_default_default.functionsIn;
|
|
wrapperLodash_default.groupBy = collection_default_default.groupBy;
|
|
wrapperLodash_default.initial = array_default_default.initial;
|
|
wrapperLodash_default.intersection = array_default_default.intersection;
|
|
wrapperLodash_default.intersectionBy = array_default_default.intersectionBy;
|
|
wrapperLodash_default.intersectionWith = array_default_default.intersectionWith;
|
|
wrapperLodash_default.invert = object_default_default.invert;
|
|
wrapperLodash_default.invertBy = object_default_default.invertBy;
|
|
wrapperLodash_default.invokeMap = collection_default_default.invokeMap;
|
|
wrapperLodash_default.iteratee = util_default_default.iteratee;
|
|
wrapperLodash_default.keyBy = collection_default_default.keyBy;
|
|
wrapperLodash_default.keys = keys_default;
|
|
wrapperLodash_default.keysIn = object_default_default.keysIn;
|
|
wrapperLodash_default.map = collection_default_default.map;
|
|
wrapperLodash_default.mapKeys = object_default_default.mapKeys;
|
|
wrapperLodash_default.mapValues = object_default_default.mapValues;
|
|
wrapperLodash_default.matches = util_default_default.matches;
|
|
wrapperLodash_default.matchesProperty = util_default_default.matchesProperty;
|
|
wrapperLodash_default.memoize = function_default_default.memoize;
|
|
wrapperLodash_default.merge = object_default_default.merge;
|
|
wrapperLodash_default.mergeWith = object_default_default.mergeWith;
|
|
wrapperLodash_default.method = util_default_default.method;
|
|
wrapperLodash_default.methodOf = util_default_default.methodOf;
|
|
wrapperLodash_default.mixin = mixin2;
|
|
wrapperLodash_default.negate = negate_default;
|
|
wrapperLodash_default.nthArg = util_default_default.nthArg;
|
|
wrapperLodash_default.omit = object_default_default.omit;
|
|
wrapperLodash_default.omitBy = object_default_default.omitBy;
|
|
wrapperLodash_default.once = function_default_default.once;
|
|
wrapperLodash_default.orderBy = collection_default_default.orderBy;
|
|
wrapperLodash_default.over = util_default_default.over;
|
|
wrapperLodash_default.overArgs = function_default_default.overArgs;
|
|
wrapperLodash_default.overEvery = util_default_default.overEvery;
|
|
wrapperLodash_default.overSome = util_default_default.overSome;
|
|
wrapperLodash_default.partial = function_default_default.partial;
|
|
wrapperLodash_default.partialRight = function_default_default.partialRight;
|
|
wrapperLodash_default.partition = collection_default_default.partition;
|
|
wrapperLodash_default.pick = object_default_default.pick;
|
|
wrapperLodash_default.pickBy = object_default_default.pickBy;
|
|
wrapperLodash_default.property = util_default_default.property;
|
|
wrapperLodash_default.propertyOf = util_default_default.propertyOf;
|
|
wrapperLodash_default.pull = array_default_default.pull;
|
|
wrapperLodash_default.pullAll = array_default_default.pullAll;
|
|
wrapperLodash_default.pullAllBy = array_default_default.pullAllBy;
|
|
wrapperLodash_default.pullAllWith = array_default_default.pullAllWith;
|
|
wrapperLodash_default.pullAt = array_default_default.pullAt;
|
|
wrapperLodash_default.range = util_default_default.range;
|
|
wrapperLodash_default.rangeRight = util_default_default.rangeRight;
|
|
wrapperLodash_default.rearg = function_default_default.rearg;
|
|
wrapperLodash_default.reject = collection_default_default.reject;
|
|
wrapperLodash_default.remove = array_default_default.remove;
|
|
wrapperLodash_default.rest = function_default_default.rest;
|
|
wrapperLodash_default.reverse = array_default_default.reverse;
|
|
wrapperLodash_default.sampleSize = collection_default_default.sampleSize;
|
|
wrapperLodash_default.set = object_default_default.set;
|
|
wrapperLodash_default.setWith = object_default_default.setWith;
|
|
wrapperLodash_default.shuffle = collection_default_default.shuffle;
|
|
wrapperLodash_default.slice = array_default_default.slice;
|
|
wrapperLodash_default.sortBy = collection_default_default.sortBy;
|
|
wrapperLodash_default.sortedUniq = array_default_default.sortedUniq;
|
|
wrapperLodash_default.sortedUniqBy = array_default_default.sortedUniqBy;
|
|
wrapperLodash_default.split = string_default_default.split;
|
|
wrapperLodash_default.spread = function_default_default.spread;
|
|
wrapperLodash_default.tail = array_default_default.tail;
|
|
wrapperLodash_default.take = array_default_default.take;
|
|
wrapperLodash_default.takeRight = array_default_default.takeRight;
|
|
wrapperLodash_default.takeRightWhile = array_default_default.takeRightWhile;
|
|
wrapperLodash_default.takeWhile = array_default_default.takeWhile;
|
|
wrapperLodash_default.tap = seq_default_default.tap;
|
|
wrapperLodash_default.throttle = function_default_default.throttle;
|
|
wrapperLodash_default.thru = thru_default;
|
|
wrapperLodash_default.toArray = lang_default_default.toArray;
|
|
wrapperLodash_default.toPairs = object_default_default.toPairs;
|
|
wrapperLodash_default.toPairsIn = object_default_default.toPairsIn;
|
|
wrapperLodash_default.toPath = util_default_default.toPath;
|
|
wrapperLodash_default.toPlainObject = lang_default_default.toPlainObject;
|
|
wrapperLodash_default.transform = object_default_default.transform;
|
|
wrapperLodash_default.unary = function_default_default.unary;
|
|
wrapperLodash_default.union = array_default_default.union;
|
|
wrapperLodash_default.unionBy = array_default_default.unionBy;
|
|
wrapperLodash_default.unionWith = array_default_default.unionWith;
|
|
wrapperLodash_default.uniq = array_default_default.uniq;
|
|
wrapperLodash_default.uniqBy = array_default_default.uniqBy;
|
|
wrapperLodash_default.uniqWith = array_default_default.uniqWith;
|
|
wrapperLodash_default.unset = object_default_default.unset;
|
|
wrapperLodash_default.unzip = array_default_default.unzip;
|
|
wrapperLodash_default.unzipWith = array_default_default.unzipWith;
|
|
wrapperLodash_default.update = object_default_default.update;
|
|
wrapperLodash_default.updateWith = object_default_default.updateWith;
|
|
wrapperLodash_default.values = object_default_default.values;
|
|
wrapperLodash_default.valuesIn = object_default_default.valuesIn;
|
|
wrapperLodash_default.without = array_default_default.without;
|
|
wrapperLodash_default.words = string_default_default.words;
|
|
wrapperLodash_default.wrap = function_default_default.wrap;
|
|
wrapperLodash_default.xor = array_default_default.xor;
|
|
wrapperLodash_default.xorBy = array_default_default.xorBy;
|
|
wrapperLodash_default.xorWith = array_default_default.xorWith;
|
|
wrapperLodash_default.zip = array_default_default.zip;
|
|
wrapperLodash_default.zipObject = array_default_default.zipObject;
|
|
wrapperLodash_default.zipObjectDeep = array_default_default.zipObjectDeep;
|
|
wrapperLodash_default.zipWith = array_default_default.zipWith;
|
|
wrapperLodash_default.entries = object_default_default.toPairs;
|
|
wrapperLodash_default.entriesIn = object_default_default.toPairsIn;
|
|
wrapperLodash_default.extend = object_default_default.assignIn;
|
|
wrapperLodash_default.extendWith = object_default_default.assignInWith;
|
|
mixin2(wrapperLodash_default, wrapperLodash_default);
|
|
wrapperLodash_default.add = math_default_default.add;
|
|
wrapperLodash_default.attempt = util_default_default.attempt;
|
|
wrapperLodash_default.camelCase = string_default_default.camelCase;
|
|
wrapperLodash_default.capitalize = string_default_default.capitalize;
|
|
wrapperLodash_default.ceil = math_default_default.ceil;
|
|
wrapperLodash_default.clamp = number_default_default.clamp;
|
|
wrapperLodash_default.clone = lang_default_default.clone;
|
|
wrapperLodash_default.cloneDeep = lang_default_default.cloneDeep;
|
|
wrapperLodash_default.cloneDeepWith = lang_default_default.cloneDeepWith;
|
|
wrapperLodash_default.cloneWith = lang_default_default.cloneWith;
|
|
wrapperLodash_default.conformsTo = lang_default_default.conformsTo;
|
|
wrapperLodash_default.deburr = string_default_default.deburr;
|
|
wrapperLodash_default.defaultTo = util_default_default.defaultTo;
|
|
wrapperLodash_default.divide = math_default_default.divide;
|
|
wrapperLodash_default.endsWith = string_default_default.endsWith;
|
|
wrapperLodash_default.eq = lang_default_default.eq;
|
|
wrapperLodash_default.escape = string_default_default.escape;
|
|
wrapperLodash_default.escapeRegExp = string_default_default.escapeRegExp;
|
|
wrapperLodash_default.every = collection_default_default.every;
|
|
wrapperLodash_default.find = collection_default_default.find;
|
|
wrapperLodash_default.findIndex = array_default_default.findIndex;
|
|
wrapperLodash_default.findKey = object_default_default.findKey;
|
|
wrapperLodash_default.findLast = collection_default_default.findLast;
|
|
wrapperLodash_default.findLastIndex = array_default_default.findLastIndex;
|
|
wrapperLodash_default.findLastKey = object_default_default.findLastKey;
|
|
wrapperLodash_default.floor = math_default_default.floor;
|
|
wrapperLodash_default.forEach = collection_default_default.forEach;
|
|
wrapperLodash_default.forEachRight = collection_default_default.forEachRight;
|
|
wrapperLodash_default.forIn = object_default_default.forIn;
|
|
wrapperLodash_default.forInRight = object_default_default.forInRight;
|
|
wrapperLodash_default.forOwn = object_default_default.forOwn;
|
|
wrapperLodash_default.forOwnRight = object_default_default.forOwnRight;
|
|
wrapperLodash_default.get = object_default_default.get;
|
|
wrapperLodash_default.gt = lang_default_default.gt;
|
|
wrapperLodash_default.gte = lang_default_default.gte;
|
|
wrapperLodash_default.has = object_default_default.has;
|
|
wrapperLodash_default.hasIn = object_default_default.hasIn;
|
|
wrapperLodash_default.head = array_default_default.head;
|
|
wrapperLodash_default.identity = identity_default;
|
|
wrapperLodash_default.includes = collection_default_default.includes;
|
|
wrapperLodash_default.indexOf = array_default_default.indexOf;
|
|
wrapperLodash_default.inRange = number_default_default.inRange;
|
|
wrapperLodash_default.invoke = object_default_default.invoke;
|
|
wrapperLodash_default.isArguments = lang_default_default.isArguments;
|
|
wrapperLodash_default.isArray = isArray_default;
|
|
wrapperLodash_default.isArrayBuffer = lang_default_default.isArrayBuffer;
|
|
wrapperLodash_default.isArrayLike = lang_default_default.isArrayLike;
|
|
wrapperLodash_default.isArrayLikeObject = lang_default_default.isArrayLikeObject;
|
|
wrapperLodash_default.isBoolean = lang_default_default.isBoolean;
|
|
wrapperLodash_default.isBuffer = lang_default_default.isBuffer;
|
|
wrapperLodash_default.isDate = lang_default_default.isDate;
|
|
wrapperLodash_default.isElement = lang_default_default.isElement;
|
|
wrapperLodash_default.isEmpty = lang_default_default.isEmpty;
|
|
wrapperLodash_default.isEqual = lang_default_default.isEqual;
|
|
wrapperLodash_default.isEqualWith = lang_default_default.isEqualWith;
|
|
wrapperLodash_default.isError = lang_default_default.isError;
|
|
wrapperLodash_default.isFinite = lang_default_default.isFinite;
|
|
wrapperLodash_default.isFunction = lang_default_default.isFunction;
|
|
wrapperLodash_default.isInteger = lang_default_default.isInteger;
|
|
wrapperLodash_default.isLength = lang_default_default.isLength;
|
|
wrapperLodash_default.isMap = lang_default_default.isMap;
|
|
wrapperLodash_default.isMatch = lang_default_default.isMatch;
|
|
wrapperLodash_default.isMatchWith = lang_default_default.isMatchWith;
|
|
wrapperLodash_default.isNaN = lang_default_default.isNaN;
|
|
wrapperLodash_default.isNative = lang_default_default.isNative;
|
|
wrapperLodash_default.isNil = lang_default_default.isNil;
|
|
wrapperLodash_default.isNull = lang_default_default.isNull;
|
|
wrapperLodash_default.isNumber = lang_default_default.isNumber;
|
|
wrapperLodash_default.isObject = isObject_default;
|
|
wrapperLodash_default.isObjectLike = lang_default_default.isObjectLike;
|
|
wrapperLodash_default.isPlainObject = lang_default_default.isPlainObject;
|
|
wrapperLodash_default.isRegExp = lang_default_default.isRegExp;
|
|
wrapperLodash_default.isSafeInteger = lang_default_default.isSafeInteger;
|
|
wrapperLodash_default.isSet = lang_default_default.isSet;
|
|
wrapperLodash_default.isString = lang_default_default.isString;
|
|
wrapperLodash_default.isSymbol = lang_default_default.isSymbol;
|
|
wrapperLodash_default.isTypedArray = lang_default_default.isTypedArray;
|
|
wrapperLodash_default.isUndefined = lang_default_default.isUndefined;
|
|
wrapperLodash_default.isWeakMap = lang_default_default.isWeakMap;
|
|
wrapperLodash_default.isWeakSet = lang_default_default.isWeakSet;
|
|
wrapperLodash_default.join = array_default_default.join;
|
|
wrapperLodash_default.kebabCase = string_default_default.kebabCase;
|
|
wrapperLodash_default.last = last_default;
|
|
wrapperLodash_default.lastIndexOf = array_default_default.lastIndexOf;
|
|
wrapperLodash_default.lowerCase = string_default_default.lowerCase;
|
|
wrapperLodash_default.lowerFirst = string_default_default.lowerFirst;
|
|
wrapperLodash_default.lt = lang_default_default.lt;
|
|
wrapperLodash_default.lte = lang_default_default.lte;
|
|
wrapperLodash_default.max = math_default_default.max;
|
|
wrapperLodash_default.maxBy = math_default_default.maxBy;
|
|
wrapperLodash_default.mean = math_default_default.mean;
|
|
wrapperLodash_default.meanBy = math_default_default.meanBy;
|
|
wrapperLodash_default.min = math_default_default.min;
|
|
wrapperLodash_default.minBy = math_default_default.minBy;
|
|
wrapperLodash_default.stubArray = util_default_default.stubArray;
|
|
wrapperLodash_default.stubFalse = util_default_default.stubFalse;
|
|
wrapperLodash_default.stubObject = util_default_default.stubObject;
|
|
wrapperLodash_default.stubString = util_default_default.stubString;
|
|
wrapperLodash_default.stubTrue = util_default_default.stubTrue;
|
|
wrapperLodash_default.multiply = math_default_default.multiply;
|
|
wrapperLodash_default.nth = array_default_default.nth;
|
|
wrapperLodash_default.noop = util_default_default.noop;
|
|
wrapperLodash_default.now = date_default_default.now;
|
|
wrapperLodash_default.pad = string_default_default.pad;
|
|
wrapperLodash_default.padEnd = string_default_default.padEnd;
|
|
wrapperLodash_default.padStart = string_default_default.padStart;
|
|
wrapperLodash_default.parseInt = string_default_default.parseInt;
|
|
wrapperLodash_default.random = number_default_default.random;
|
|
wrapperLodash_default.reduce = collection_default_default.reduce;
|
|
wrapperLodash_default.reduceRight = collection_default_default.reduceRight;
|
|
wrapperLodash_default.repeat = string_default_default.repeat;
|
|
wrapperLodash_default.replace = string_default_default.replace;
|
|
wrapperLodash_default.result = object_default_default.result;
|
|
wrapperLodash_default.round = math_default_default.round;
|
|
wrapperLodash_default.sample = collection_default_default.sample;
|
|
wrapperLodash_default.size = collection_default_default.size;
|
|
wrapperLodash_default.snakeCase = string_default_default.snakeCase;
|
|
wrapperLodash_default.some = collection_default_default.some;
|
|
wrapperLodash_default.sortedIndex = array_default_default.sortedIndex;
|
|
wrapperLodash_default.sortedIndexBy = array_default_default.sortedIndexBy;
|
|
wrapperLodash_default.sortedIndexOf = array_default_default.sortedIndexOf;
|
|
wrapperLodash_default.sortedLastIndex = array_default_default.sortedLastIndex;
|
|
wrapperLodash_default.sortedLastIndexBy = array_default_default.sortedLastIndexBy;
|
|
wrapperLodash_default.sortedLastIndexOf = array_default_default.sortedLastIndexOf;
|
|
wrapperLodash_default.startCase = string_default_default.startCase;
|
|
wrapperLodash_default.startsWith = string_default_default.startsWith;
|
|
wrapperLodash_default.subtract = math_default_default.subtract;
|
|
wrapperLodash_default.sum = math_default_default.sum;
|
|
wrapperLodash_default.sumBy = math_default_default.sumBy;
|
|
wrapperLodash_default.template = string_default_default.template;
|
|
wrapperLodash_default.times = util_default_default.times;
|
|
wrapperLodash_default.toFinite = lang_default_default.toFinite;
|
|
wrapperLodash_default.toInteger = toInteger_default;
|
|
wrapperLodash_default.toLength = lang_default_default.toLength;
|
|
wrapperLodash_default.toLower = string_default_default.toLower;
|
|
wrapperLodash_default.toNumber = lang_default_default.toNumber;
|
|
wrapperLodash_default.toSafeInteger = lang_default_default.toSafeInteger;
|
|
wrapperLodash_default.toString = lang_default_default.toString;
|
|
wrapperLodash_default.toUpper = string_default_default.toUpper;
|
|
wrapperLodash_default.trim = string_default_default.trim;
|
|
wrapperLodash_default.trimEnd = string_default_default.trimEnd;
|
|
wrapperLodash_default.trimStart = string_default_default.trimStart;
|
|
wrapperLodash_default.truncate = string_default_default.truncate;
|
|
wrapperLodash_default.unescape = string_default_default.unescape;
|
|
wrapperLodash_default.uniqueId = util_default_default.uniqueId;
|
|
wrapperLodash_default.upperCase = string_default_default.upperCase;
|
|
wrapperLodash_default.upperFirst = string_default_default.upperFirst;
|
|
wrapperLodash_default.each = collection_default_default.forEach;
|
|
wrapperLodash_default.eachRight = collection_default_default.forEachRight;
|
|
wrapperLodash_default.first = array_default_default.head;
|
|
mixin2(wrapperLodash_default, function() {
|
|
var source = {};
|
|
baseForOwn_default(wrapperLodash_default, function(func, methodName) {
|
|
if (!hasOwnProperty25.call(wrapperLodash_default.prototype, methodName)) {
|
|
source[methodName] = func;
|
|
}
|
|
});
|
|
return source;
|
|
}(), { "chain": false });
|
|
wrapperLodash_default.VERSION = VERSION;
|
|
(wrapperLodash_default.templateSettings = string_default_default.templateSettings).imports._ = wrapperLodash_default;
|
|
arrayEach_default(["bind", "bindKey", "curry", "curryRight", "partial", "partialRight"], function(methodName) {
|
|
wrapperLodash_default[methodName].placeholder = wrapperLodash_default;
|
|
});
|
|
arrayEach_default(["drop", "take"], function(methodName, index) {
|
|
LazyWrapper_default.prototype[methodName] = function(n) {
|
|
n = n === void 0 ? 1 : nativeMax17(toInteger_default(n), 0);
|
|
var result2 = this.__filtered__ && !index ? new LazyWrapper_default(this) : this.clone();
|
|
if (result2.__filtered__) {
|
|
result2.__takeCount__ = nativeMin15(n, result2.__takeCount__);
|
|
} else {
|
|
result2.__views__.push({
|
|
"size": nativeMin15(n, MAX_ARRAY_LENGTH7),
|
|
"type": methodName + (result2.__dir__ < 0 ? "Right" : "")
|
|
});
|
|
}
|
|
return result2;
|
|
};
|
|
LazyWrapper_default.prototype[methodName + "Right"] = function(n) {
|
|
return this.reverse()[methodName](n).reverse();
|
|
};
|
|
});
|
|
arrayEach_default(["filter", "map", "takeWhile"], function(methodName, index) {
|
|
var type4 = index + 1, isFilter = type4 == LAZY_FILTER_FLAG2 || type4 == LAZY_WHILE_FLAG;
|
|
LazyWrapper_default.prototype[methodName] = function(iteratee2) {
|
|
var result2 = this.clone();
|
|
result2.__iteratees__.push({
|
|
"iteratee": baseIteratee_default(iteratee2, 3),
|
|
"type": type4
|
|
});
|
|
result2.__filtered__ = result2.__filtered__ || isFilter;
|
|
return result2;
|
|
};
|
|
});
|
|
arrayEach_default(["head", "last"], function(methodName, index) {
|
|
var takeName = "take" + (index ? "Right" : "");
|
|
LazyWrapper_default.prototype[methodName] = function() {
|
|
return this[takeName](1).value()[0];
|
|
};
|
|
});
|
|
arrayEach_default(["initial", "tail"], function(methodName, index) {
|
|
var dropName = "drop" + (index ? "" : "Right");
|
|
LazyWrapper_default.prototype[methodName] = function() {
|
|
return this.__filtered__ ? new LazyWrapper_default(this) : this[dropName](1);
|
|
};
|
|
});
|
|
LazyWrapper_default.prototype.compact = function() {
|
|
return this.filter(identity_default);
|
|
};
|
|
LazyWrapper_default.prototype.find = function(predicate) {
|
|
return this.filter(predicate).head();
|
|
};
|
|
LazyWrapper_default.prototype.findLast = function(predicate) {
|
|
return this.reverse().find(predicate);
|
|
};
|
|
LazyWrapper_default.prototype.invokeMap = baseRest_default(function(path, args) {
|
|
if (typeof path == "function") {
|
|
return new LazyWrapper_default(this);
|
|
}
|
|
return this.map(function(value) {
|
|
return baseInvoke_default(value, path, args);
|
|
});
|
|
});
|
|
LazyWrapper_default.prototype.reject = function(predicate) {
|
|
return this.filter(negate_default(baseIteratee_default(predicate)));
|
|
};
|
|
LazyWrapper_default.prototype.slice = function(start, end) {
|
|
start = toInteger_default(start);
|
|
var result2 = this;
|
|
if (result2.__filtered__ && (start > 0 || end < 0)) {
|
|
return new LazyWrapper_default(result2);
|
|
}
|
|
if (start < 0) {
|
|
result2 = result2.takeRight(-start);
|
|
} else if (start) {
|
|
result2 = result2.drop(start);
|
|
}
|
|
if (end !== void 0) {
|
|
end = toInteger_default(end);
|
|
result2 = end < 0 ? result2.dropRight(-end) : result2.take(end - start);
|
|
}
|
|
return result2;
|
|
};
|
|
LazyWrapper_default.prototype.takeRightWhile = function(predicate) {
|
|
return this.reverse().takeWhile(predicate).reverse();
|
|
};
|
|
LazyWrapper_default.prototype.toArray = function() {
|
|
return this.take(MAX_ARRAY_LENGTH7);
|
|
};
|
|
baseForOwn_default(LazyWrapper_default.prototype, function(func, methodName) {
|
|
var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName), isTaker = /^(?:head|last)$/.test(methodName), lodashFunc = wrapperLodash_default[isTaker ? "take" + (methodName == "last" ? "Right" : "") : methodName], retUnwrapped = isTaker || /^find/.test(methodName);
|
|
if (!lodashFunc) {
|
|
return;
|
|
}
|
|
wrapperLodash_default.prototype[methodName] = function() {
|
|
var value = this.__wrapped__, args = isTaker ? [1] : arguments, isLazy = value instanceof LazyWrapper_default, iteratee2 = args[0], useLazy = isLazy || isArray_default(value);
|
|
var interceptor = function(value2) {
|
|
var result3 = lodashFunc.apply(wrapperLodash_default, arrayPush_default([value2], args));
|
|
return isTaker && chainAll ? result3[0] : result3;
|
|
};
|
|
if (useLazy && checkIteratee && typeof iteratee2 == "function" && iteratee2.length != 1) {
|
|
isLazy = useLazy = false;
|
|
}
|
|
var chainAll = this.__chain__, isHybrid = !!this.__actions__.length, isUnwrapped = retUnwrapped && !chainAll, onlyLazy = isLazy && !isHybrid;
|
|
if (!retUnwrapped && useLazy) {
|
|
value = onlyLazy ? value : new LazyWrapper_default(this);
|
|
var result2 = func.apply(value, args);
|
|
result2.__actions__.push({ "func": thru_default, "args": [interceptor], "thisArg": void 0 });
|
|
return new LodashWrapper_default(result2, chainAll);
|
|
}
|
|
if (isUnwrapped && onlyLazy) {
|
|
return func.apply(this, args);
|
|
}
|
|
result2 = this.thru(interceptor);
|
|
return isUnwrapped ? isTaker ? result2.value()[0] : result2.value() : result2;
|
|
};
|
|
});
|
|
arrayEach_default(["pop", "push", "shift", "sort", "splice", "unshift"], function(methodName) {
|
|
var func = arrayProto6[methodName], chainName = /^(?:push|sort|unshift)$/.test(methodName) ? "tap" : "thru", retUnwrapped = /^(?:pop|shift)$/.test(methodName);
|
|
wrapperLodash_default.prototype[methodName] = function() {
|
|
var args = arguments;
|
|
if (retUnwrapped && !this.__chain__) {
|
|
var value = this.value();
|
|
return func.apply(isArray_default(value) ? value : [], args);
|
|
}
|
|
return this[chainName](function(value2) {
|
|
return func.apply(isArray_default(value2) ? value2 : [], args);
|
|
});
|
|
};
|
|
});
|
|
baseForOwn_default(LazyWrapper_default.prototype, function(func, methodName) {
|
|
var lodashFunc = wrapperLodash_default[methodName];
|
|
if (lodashFunc) {
|
|
var key = lodashFunc.name + "";
|
|
if (!hasOwnProperty25.call(realNames_default, key)) {
|
|
realNames_default[key] = [];
|
|
}
|
|
realNames_default[key].push({ "name": methodName, "func": lodashFunc });
|
|
}
|
|
});
|
|
realNames_default[createHybrid_default(void 0, WRAP_BIND_KEY_FLAG7).name] = [{
|
|
"name": "wrapper",
|
|
"func": void 0
|
|
}];
|
|
LazyWrapper_default.prototype.clone = lazyClone_default;
|
|
LazyWrapper_default.prototype.reverse = lazyReverse_default;
|
|
LazyWrapper_default.prototype.value = lazyValue_default;
|
|
wrapperLodash_default.prototype.at = seq_default_default.at;
|
|
wrapperLodash_default.prototype.chain = seq_default_default.wrapperChain;
|
|
wrapperLodash_default.prototype.commit = seq_default_default.commit;
|
|
wrapperLodash_default.prototype.next = seq_default_default.next;
|
|
wrapperLodash_default.prototype.plant = seq_default_default.plant;
|
|
wrapperLodash_default.prototype.reverse = seq_default_default.reverse;
|
|
wrapperLodash_default.prototype.toJSON = wrapperLodash_default.prototype.valueOf = wrapperLodash_default.prototype.value = seq_default_default.value;
|
|
wrapperLodash_default.prototype.first = wrapperLodash_default.prototype.head;
|
|
if (symIterator2) {
|
|
wrapperLodash_default.prototype[symIterator2] = seq_default_default.toIterator;
|
|
}
|
|
|
|
// node_modules/element-plus/es/utils/types.mjs
|
|
var isUndefined2 = (val) => val === void 0;
|
|
var isBoolean2 = (val) => typeof val === "boolean";
|
|
var isNumber2 = (val) => typeof val === "number";
|
|
var isEmpty2 = (val) => !val && val !== 0 || isArray(val) && val.length === 0 || isObject(val) && !Object.keys(val).length;
|
|
var isElement2 = (e) => {
|
|
if (typeof Element === "undefined")
|
|
return false;
|
|
return e instanceof Element;
|
|
};
|
|
var isPropAbsent = (prop) => isNil_default(prop);
|
|
var isStringNumber = (val) => {
|
|
if (!isString(val)) {
|
|
return false;
|
|
}
|
|
return !Number.isNaN(Number(val));
|
|
};
|
|
var isWindow = (val) => val === window;
|
|
|
|
// node_modules/@vueuse/shared/index.mjs
|
|
var __defProp$9 = Object.defineProperty;
|
|
var __defProps$6 = Object.defineProperties;
|
|
var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
|
|
var __getOwnPropSymbols$b = Object.getOwnPropertySymbols;
|
|
var __hasOwnProp$b = Object.prototype.hasOwnProperty;
|
|
var __propIsEnum$b = Object.prototype.propertyIsEnumerable;
|
|
var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
var __spreadValues$9 = (a2, b2) => {
|
|
for (var prop in b2 || (b2 = {}))
|
|
if (__hasOwnProp$b.call(b2, prop))
|
|
__defNormalProp$9(a2, prop, b2[prop]);
|
|
if (__getOwnPropSymbols$b)
|
|
for (var prop of __getOwnPropSymbols$b(b2)) {
|
|
if (__propIsEnum$b.call(b2, prop))
|
|
__defNormalProp$9(a2, prop, b2[prop]);
|
|
}
|
|
return a2;
|
|
};
|
|
var __spreadProps$6 = (a2, b2) => __defProps$6(a2, __getOwnPropDescs$6(b2));
|
|
function computedEager(fn2, options) {
|
|
var _a2;
|
|
const result2 = shallowRef();
|
|
watchEffect(() => {
|
|
result2.value = fn2();
|
|
}, __spreadProps$6(__spreadValues$9({}, options), {
|
|
flush: (_a2 = options == null ? void 0 : options.flush) != null ? _a2 : "sync"
|
|
}));
|
|
return readonly(result2);
|
|
}
|
|
var _a;
|
|
var isClient = typeof window !== "undefined";
|
|
var isDef = (val) => typeof val !== "undefined";
|
|
var isFunction3 = (val) => typeof val === "function";
|
|
var isString3 = (val) => typeof val === "string";
|
|
var noop2 = () => {
|
|
};
|
|
var isIOS = isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && /iP(ad|hone|od)/.test(window.navigator.userAgent);
|
|
function resolveUnref(r) {
|
|
return typeof r === "function" ? r() : unref(r);
|
|
}
|
|
function createFilterWrapper(filter2, fn2) {
|
|
function wrapper(...args) {
|
|
return new Promise((resolve, reject2) => {
|
|
Promise.resolve(filter2(() => fn2.apply(this, args), { fn: fn2, thisArg: this, args })).then(resolve).catch(reject2);
|
|
});
|
|
}
|
|
return wrapper;
|
|
}
|
|
function debounceFilter(ms, options = {}) {
|
|
let timer;
|
|
let maxTimer;
|
|
let lastRejector = noop2;
|
|
const _clearTimeout = (timer2) => {
|
|
clearTimeout(timer2);
|
|
lastRejector();
|
|
lastRejector = noop2;
|
|
};
|
|
const filter2 = (invoke2) => {
|
|
const duration = resolveUnref(ms);
|
|
const maxDuration = resolveUnref(options.maxWait);
|
|
if (timer)
|
|
_clearTimeout(timer);
|
|
if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
|
|
if (maxTimer) {
|
|
_clearTimeout(maxTimer);
|
|
maxTimer = null;
|
|
}
|
|
return Promise.resolve(invoke2());
|
|
}
|
|
return new Promise((resolve, reject2) => {
|
|
lastRejector = options.rejectOnCancel ? reject2 : resolve;
|
|
if (maxDuration && !maxTimer) {
|
|
maxTimer = setTimeout(() => {
|
|
if (timer)
|
|
_clearTimeout(timer);
|
|
maxTimer = null;
|
|
resolve(invoke2());
|
|
}, maxDuration);
|
|
}
|
|
timer = setTimeout(() => {
|
|
if (maxTimer)
|
|
_clearTimeout(maxTimer);
|
|
maxTimer = null;
|
|
resolve(invoke2());
|
|
}, duration);
|
|
});
|
|
};
|
|
return filter2;
|
|
}
|
|
function throttleFilter(ms, trailing = true, leading = true, rejectOnCancel = false) {
|
|
let lastExec = 0;
|
|
let timer;
|
|
let isLeading = true;
|
|
let lastRejector = noop2;
|
|
let lastValue;
|
|
const clear = () => {
|
|
if (timer) {
|
|
clearTimeout(timer);
|
|
timer = void 0;
|
|
lastRejector();
|
|
lastRejector = noop2;
|
|
}
|
|
};
|
|
const filter2 = (_invoke) => {
|
|
const duration = resolveUnref(ms);
|
|
const elapsed = Date.now() - lastExec;
|
|
const invoke2 = () => {
|
|
return lastValue = _invoke();
|
|
};
|
|
clear();
|
|
if (duration <= 0) {
|
|
lastExec = Date.now();
|
|
return invoke2();
|
|
}
|
|
if (elapsed > duration && (leading || !isLeading)) {
|
|
lastExec = Date.now();
|
|
invoke2();
|
|
} else if (trailing) {
|
|
lastValue = new Promise((resolve, reject2) => {
|
|
lastRejector = rejectOnCancel ? reject2 : resolve;
|
|
timer = setTimeout(() => {
|
|
lastExec = Date.now();
|
|
isLeading = true;
|
|
resolve(invoke2());
|
|
clear();
|
|
}, Math.max(0, duration - elapsed));
|
|
});
|
|
}
|
|
if (!leading && !timer)
|
|
timer = setTimeout(() => isLeading = true, duration);
|
|
isLeading = false;
|
|
return lastValue;
|
|
};
|
|
return filter2;
|
|
}
|
|
function identity2(arg) {
|
|
return arg;
|
|
}
|
|
function computedWithControl(source, fn2) {
|
|
let v2 = void 0;
|
|
let track;
|
|
let trigger;
|
|
const dirty = ref(true);
|
|
const update2 = () => {
|
|
dirty.value = true;
|
|
trigger();
|
|
};
|
|
watch(source, update2, { flush: "sync" });
|
|
const get2 = isFunction3(fn2) ? fn2 : fn2.get;
|
|
const set4 = isFunction3(fn2) ? void 0 : fn2.set;
|
|
const result2 = customRef((_track, _trigger) => {
|
|
track = _track;
|
|
trigger = _trigger;
|
|
return {
|
|
get() {
|
|
if (dirty.value) {
|
|
v2 = get2();
|
|
dirty.value = false;
|
|
}
|
|
track();
|
|
return v2;
|
|
},
|
|
set(v22) {
|
|
set4 == null ? void 0 : set4(v22);
|
|
}
|
|
};
|
|
});
|
|
if (Object.isExtensible(result2))
|
|
result2.trigger = update2;
|
|
return result2;
|
|
}
|
|
function tryOnScopeDispose(fn2) {
|
|
if (getCurrentScope()) {
|
|
onScopeDispose(fn2);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function useDebounceFn(fn2, ms = 200, options = {}) {
|
|
return createFilterWrapper(debounceFilter(ms, options), fn2);
|
|
}
|
|
function refDebounced(value, ms = 200, options = {}) {
|
|
const debounced = ref(value.value);
|
|
const updater = useDebounceFn(() => {
|
|
debounced.value = value.value;
|
|
}, ms, options);
|
|
watch(value, () => updater());
|
|
return debounced;
|
|
}
|
|
function useThrottleFn(fn2, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
|
|
return createFilterWrapper(throttleFilter(ms, trailing, leading, rejectOnCancel), fn2);
|
|
}
|
|
function tryOnMounted(fn2, sync = true) {
|
|
if (getCurrentInstance())
|
|
onMounted(fn2);
|
|
else if (sync)
|
|
fn2();
|
|
else
|
|
nextTick(fn2);
|
|
}
|
|
function useTimeoutFn(cb, interval, options = {}) {
|
|
const {
|
|
immediate = true
|
|
} = options;
|
|
const isPending = ref(false);
|
|
let timer = null;
|
|
function clear() {
|
|
if (timer) {
|
|
clearTimeout(timer);
|
|
timer = null;
|
|
}
|
|
}
|
|
function stop() {
|
|
isPending.value = false;
|
|
clear();
|
|
}
|
|
function start(...args) {
|
|
clear();
|
|
isPending.value = true;
|
|
timer = setTimeout(() => {
|
|
isPending.value = false;
|
|
timer = null;
|
|
cb(...args);
|
|
}, resolveUnref(interval));
|
|
}
|
|
if (immediate) {
|
|
isPending.value = true;
|
|
if (isClient)
|
|
start();
|
|
}
|
|
tryOnScopeDispose(stop);
|
|
return {
|
|
isPending: readonly(isPending),
|
|
start,
|
|
stop
|
|
};
|
|
}
|
|
|
|
// node_modules/@vueuse/core/node_modules/vue-demi/lib/index.mjs
|
|
var isVue22 = false;
|
|
|
|
// node_modules/@vueuse/core/index.mjs
|
|
function unrefElement(elRef) {
|
|
var _a2;
|
|
const plain = resolveUnref(elRef);
|
|
return (_a2 = plain == null ? void 0 : plain.$el) != null ? _a2 : plain;
|
|
}
|
|
var defaultWindow = isClient ? window : void 0;
|
|
var defaultDocument = isClient ? window.document : void 0;
|
|
var defaultNavigator = isClient ? window.navigator : void 0;
|
|
var defaultLocation = isClient ? window.location : void 0;
|
|
function useEventListener(...args) {
|
|
let target2;
|
|
let events2;
|
|
let listeners;
|
|
let options;
|
|
if (isString3(args[0]) || Array.isArray(args[0])) {
|
|
[events2, listeners, options] = args;
|
|
target2 = defaultWindow;
|
|
} else {
|
|
[target2, events2, listeners, options] = args;
|
|
}
|
|
if (!target2)
|
|
return noop2;
|
|
if (!Array.isArray(events2))
|
|
events2 = [events2];
|
|
if (!Array.isArray(listeners))
|
|
listeners = [listeners];
|
|
const cleanups = [];
|
|
const cleanup = () => {
|
|
cleanups.forEach((fn2) => fn2());
|
|
cleanups.length = 0;
|
|
};
|
|
const register2 = (el, event, listener, options2) => {
|
|
el.addEventListener(event, listener, options2);
|
|
return () => el.removeEventListener(event, listener, options2);
|
|
};
|
|
const stopWatch = watch(() => [unrefElement(target2), resolveUnref(options)], ([el, options2]) => {
|
|
cleanup();
|
|
if (!el)
|
|
return;
|
|
cleanups.push(...events2.flatMap((event) => {
|
|
return listeners.map((listener) => register2(el, event, listener, options2));
|
|
}));
|
|
}, { immediate: true, flush: "post" });
|
|
const stop = () => {
|
|
stopWatch();
|
|
cleanup();
|
|
};
|
|
tryOnScopeDispose(stop);
|
|
return stop;
|
|
}
|
|
var _iOSWorkaround = false;
|
|
function onClickOutside(target2, handler, options = {}) {
|
|
const { window: window2 = defaultWindow, ignore = [], capture = true, detectIframe = false } = options;
|
|
if (!window2)
|
|
return;
|
|
if (isIOS && !_iOSWorkaround) {
|
|
_iOSWorkaround = true;
|
|
Array.from(window2.document.body.children).forEach((el) => el.addEventListener("click", noop2));
|
|
}
|
|
let shouldListen = true;
|
|
const shouldIgnore = (event) => {
|
|
return ignore.some((target22) => {
|
|
if (typeof target22 === "string") {
|
|
return Array.from(window2.document.querySelectorAll(target22)).some((el) => el === event.target || event.composedPath().includes(el));
|
|
} else {
|
|
const el = unrefElement(target22);
|
|
return el && (event.target === el || event.composedPath().includes(el));
|
|
}
|
|
});
|
|
};
|
|
const listener = (event) => {
|
|
const el = unrefElement(target2);
|
|
if (!el || el === event.target || event.composedPath().includes(el))
|
|
return;
|
|
if (event.detail === 0)
|
|
shouldListen = !shouldIgnore(event);
|
|
if (!shouldListen) {
|
|
shouldListen = true;
|
|
return;
|
|
}
|
|
handler(event);
|
|
};
|
|
const cleanup = [
|
|
useEventListener(window2, "click", listener, { passive: true, capture }),
|
|
useEventListener(window2, "pointerdown", (e) => {
|
|
const el = unrefElement(target2);
|
|
if (el)
|
|
shouldListen = !e.composedPath().includes(el) && !shouldIgnore(e);
|
|
}, { passive: true }),
|
|
detectIframe && useEventListener(window2, "blur", (event) => {
|
|
var _a2;
|
|
const el = unrefElement(target2);
|
|
if (((_a2 = window2.document.activeElement) == null ? void 0 : _a2.tagName) === "IFRAME" && !(el == null ? void 0 : el.contains(window2.document.activeElement)))
|
|
handler(event);
|
|
})
|
|
].filter(Boolean);
|
|
const stop = () => cleanup.forEach((fn2) => fn2());
|
|
return stop;
|
|
}
|
|
function useActiveElement(options = {}) {
|
|
var _a2;
|
|
const { window: window2 = defaultWindow } = options;
|
|
const document2 = (_a2 = options.document) != null ? _a2 : window2 == null ? void 0 : window2.document;
|
|
const activeElement = computedWithControl(() => null, () => document2 == null ? void 0 : document2.activeElement);
|
|
if (window2) {
|
|
useEventListener(window2, "blur", (event) => {
|
|
if (event.relatedTarget !== null)
|
|
return;
|
|
activeElement.trigger();
|
|
}, true);
|
|
useEventListener(window2, "focus", activeElement.trigger, true);
|
|
}
|
|
return activeElement;
|
|
}
|
|
function useSupported(callback, sync = false) {
|
|
const isSupported = ref();
|
|
const update2 = () => isSupported.value = Boolean(callback());
|
|
update2();
|
|
tryOnMounted(update2, sync);
|
|
return isSupported;
|
|
}
|
|
function cloneFnJSON(source) {
|
|
return JSON.parse(JSON.stringify(source));
|
|
}
|
|
var _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
|
|
var globalKey = "__vueuse_ssr_handlers__";
|
|
_global[globalKey] = _global[globalKey] || {};
|
|
var handlers = _global[globalKey];
|
|
function useCssVar(prop, target2, { window: window2 = defaultWindow, initialValue = "" } = {}) {
|
|
const variable = ref(initialValue);
|
|
const elRef = computed(() => {
|
|
var _a2;
|
|
return unrefElement(target2) || ((_a2 = window2 == null ? void 0 : window2.document) == null ? void 0 : _a2.documentElement);
|
|
});
|
|
watch([elRef, () => resolveUnref(prop)], ([el, prop2]) => {
|
|
var _a2;
|
|
if (el && window2) {
|
|
const value = (_a2 = window2.getComputedStyle(el).getPropertyValue(prop2)) == null ? void 0 : _a2.trim();
|
|
variable.value = value || initialValue;
|
|
}
|
|
}, { immediate: true });
|
|
watch(variable, (val) => {
|
|
var _a2;
|
|
if ((_a2 = elRef.value) == null ? void 0 : _a2.style)
|
|
elRef.value.style.setProperty(resolveUnref(prop), val);
|
|
});
|
|
return variable;
|
|
}
|
|
function useDocumentVisibility({ document: document2 = defaultDocument } = {}) {
|
|
if (!document2)
|
|
return ref("visible");
|
|
const visibility = ref(document2.visibilityState);
|
|
useEventListener(document2, "visibilitychange", () => {
|
|
visibility.value = document2.visibilityState;
|
|
});
|
|
return visibility;
|
|
}
|
|
var __getOwnPropSymbols$g = Object.getOwnPropertySymbols;
|
|
var __hasOwnProp$g = Object.prototype.hasOwnProperty;
|
|
var __propIsEnum$g = Object.prototype.propertyIsEnumerable;
|
|
var __objRest$2 = (source, exclude) => {
|
|
var target2 = {};
|
|
for (var prop in source)
|
|
if (__hasOwnProp$g.call(source, prop) && exclude.indexOf(prop) < 0)
|
|
target2[prop] = source[prop];
|
|
if (source != null && __getOwnPropSymbols$g)
|
|
for (var prop of __getOwnPropSymbols$g(source)) {
|
|
if (exclude.indexOf(prop) < 0 && __propIsEnum$g.call(source, prop))
|
|
target2[prop] = source[prop];
|
|
}
|
|
return target2;
|
|
};
|
|
function useResizeObserver(target2, callback, options = {}) {
|
|
const _a2 = options, { window: window2 = defaultWindow } = _a2, observerOptions = __objRest$2(_a2, ["window"]);
|
|
let observer;
|
|
const isSupported = useSupported(() => window2 && "ResizeObserver" in window2);
|
|
const cleanup = () => {
|
|
if (observer) {
|
|
observer.disconnect();
|
|
observer = void 0;
|
|
}
|
|
};
|
|
const stopWatch = watch(() => unrefElement(target2), (el) => {
|
|
cleanup();
|
|
if (isSupported.value && window2 && el) {
|
|
observer = new ResizeObserver(callback);
|
|
observer.observe(el, observerOptions);
|
|
}
|
|
}, { immediate: true, flush: "post" });
|
|
const stop = () => {
|
|
cleanup();
|
|
stopWatch();
|
|
};
|
|
tryOnScopeDispose(stop);
|
|
return {
|
|
isSupported,
|
|
stop
|
|
};
|
|
}
|
|
function useElementBounding(target2, options = {}) {
|
|
const {
|
|
reset = true,
|
|
windowResize = true,
|
|
windowScroll = true,
|
|
immediate = true
|
|
} = options;
|
|
const height = ref(0);
|
|
const bottom = ref(0);
|
|
const left = ref(0);
|
|
const right = ref(0);
|
|
const top = ref(0);
|
|
const width = ref(0);
|
|
const x2 = ref(0);
|
|
const y = ref(0);
|
|
function update2() {
|
|
const el = unrefElement(target2);
|
|
if (!el) {
|
|
if (reset) {
|
|
height.value = 0;
|
|
bottom.value = 0;
|
|
left.value = 0;
|
|
right.value = 0;
|
|
top.value = 0;
|
|
width.value = 0;
|
|
x2.value = 0;
|
|
y.value = 0;
|
|
}
|
|
return;
|
|
}
|
|
const rect = el.getBoundingClientRect();
|
|
height.value = rect.height;
|
|
bottom.value = rect.bottom;
|
|
left.value = rect.left;
|
|
right.value = rect.right;
|
|
top.value = rect.top;
|
|
width.value = rect.width;
|
|
x2.value = rect.x;
|
|
y.value = rect.y;
|
|
}
|
|
useResizeObserver(target2, update2);
|
|
watch(() => unrefElement(target2), (ele) => !ele && update2());
|
|
if (windowScroll)
|
|
useEventListener("scroll", update2, { capture: true, passive: true });
|
|
if (windowResize)
|
|
useEventListener("resize", update2, { passive: true });
|
|
tryOnMounted(() => {
|
|
if (immediate)
|
|
update2();
|
|
});
|
|
return {
|
|
height,
|
|
bottom,
|
|
left,
|
|
right,
|
|
top,
|
|
width,
|
|
x: x2,
|
|
y,
|
|
update: update2
|
|
};
|
|
}
|
|
var events = new Map();
|
|
var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
|
|
var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
|
|
var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
|
|
var __objRest$1 = (source, exclude) => {
|
|
var target2 = {};
|
|
for (var prop in source)
|
|
if (__hasOwnProp$8.call(source, prop) && exclude.indexOf(prop) < 0)
|
|
target2[prop] = source[prop];
|
|
if (source != null && __getOwnPropSymbols$8)
|
|
for (var prop of __getOwnPropSymbols$8(source)) {
|
|
if (exclude.indexOf(prop) < 0 && __propIsEnum$8.call(source, prop))
|
|
target2[prop] = source[prop];
|
|
}
|
|
return target2;
|
|
};
|
|
function useMutationObserver(target2, callback, options = {}) {
|
|
const _a2 = options, { window: window2 = defaultWindow } = _a2, mutationOptions = __objRest$1(_a2, ["window"]);
|
|
let observer;
|
|
const isSupported = useSupported(() => window2 && "MutationObserver" in window2);
|
|
const cleanup = () => {
|
|
if (observer) {
|
|
observer.disconnect();
|
|
observer = void 0;
|
|
}
|
|
};
|
|
const stopWatch = watch(() => unrefElement(target2), (el) => {
|
|
cleanup();
|
|
if (isSupported.value && window2 && el) {
|
|
observer = new MutationObserver(callback);
|
|
observer.observe(el, mutationOptions);
|
|
}
|
|
}, { immediate: true });
|
|
const stop = () => {
|
|
cleanup();
|
|
stopWatch();
|
|
};
|
|
tryOnScopeDispose(stop);
|
|
return {
|
|
isSupported,
|
|
stop
|
|
};
|
|
}
|
|
var defaultState = {
|
|
x: 0,
|
|
y: 0,
|
|
pointerId: 0,
|
|
pressure: 0,
|
|
tiltX: 0,
|
|
tiltY: 0,
|
|
width: 0,
|
|
height: 0,
|
|
twist: 0,
|
|
pointerType: null
|
|
};
|
|
var keys2 = Object.keys(defaultState);
|
|
var SwipeDirection;
|
|
(function(SwipeDirection2) {
|
|
SwipeDirection2["UP"] = "UP";
|
|
SwipeDirection2["RIGHT"] = "RIGHT";
|
|
SwipeDirection2["DOWN"] = "DOWN";
|
|
SwipeDirection2["LEFT"] = "LEFT";
|
|
SwipeDirection2["NONE"] = "NONE";
|
|
})(SwipeDirection || (SwipeDirection = {}));
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __propIsEnum = Object.prototype.propertyIsEnumerable;
|
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
var __spreadValues = (a2, b2) => {
|
|
for (var prop in b2 || (b2 = {}))
|
|
if (__hasOwnProp.call(b2, prop))
|
|
__defNormalProp(a2, prop, b2[prop]);
|
|
if (__getOwnPropSymbols)
|
|
for (var prop of __getOwnPropSymbols(b2)) {
|
|
if (__propIsEnum.call(b2, prop))
|
|
__defNormalProp(a2, prop, b2[prop]);
|
|
}
|
|
return a2;
|
|
};
|
|
var _TransitionPresets = {
|
|
easeInSine: [0.12, 0, 0.39, 0],
|
|
easeOutSine: [0.61, 1, 0.88, 1],
|
|
easeInOutSine: [0.37, 0, 0.63, 1],
|
|
easeInQuad: [0.11, 0, 0.5, 0],
|
|
easeOutQuad: [0.5, 1, 0.89, 1],
|
|
easeInOutQuad: [0.45, 0, 0.55, 1],
|
|
easeInCubic: [0.32, 0, 0.67, 0],
|
|
easeOutCubic: [0.33, 1, 0.68, 1],
|
|
easeInOutCubic: [0.65, 0, 0.35, 1],
|
|
easeInQuart: [0.5, 0, 0.75, 0],
|
|
easeOutQuart: [0.25, 1, 0.5, 1],
|
|
easeInOutQuart: [0.76, 0, 0.24, 1],
|
|
easeInQuint: [0.64, 0, 0.78, 0],
|
|
easeOutQuint: [0.22, 1, 0.36, 1],
|
|
easeInOutQuint: [0.83, 0, 0.17, 1],
|
|
easeInExpo: [0.7, 0, 0.84, 0],
|
|
easeOutExpo: [0.16, 1, 0.3, 1],
|
|
easeInOutExpo: [0.87, 0, 0.13, 1],
|
|
easeInCirc: [0.55, 0, 1, 0.45],
|
|
easeOutCirc: [0, 0.55, 0.45, 1],
|
|
easeInOutCirc: [0.85, 0, 0.15, 1],
|
|
easeInBack: [0.36, 0, 0.66, -0.56],
|
|
easeOutBack: [0.34, 1.56, 0.64, 1],
|
|
easeInOutBack: [0.68, -0.6, 0.32, 1.6]
|
|
};
|
|
var TransitionPresets = __spreadValues({
|
|
linear: identity2
|
|
}, _TransitionPresets);
|
|
function useVModel(props2, key, emit, options = {}) {
|
|
var _a2, _b, _c, _d, _e;
|
|
const {
|
|
clone: clone2 = false,
|
|
passive = false,
|
|
eventName,
|
|
deep = false,
|
|
defaultValue
|
|
} = options;
|
|
const vm = getCurrentInstance();
|
|
const _emit = emit || (vm == null ? void 0 : vm.emit) || ((_a2 = vm == null ? void 0 : vm.$emit) == null ? void 0 : _a2.bind(vm)) || ((_c = (_b = vm == null ? void 0 : vm.proxy) == null ? void 0 : _b.$emit) == null ? void 0 : _c.bind(vm == null ? void 0 : vm.proxy));
|
|
let event = eventName;
|
|
if (!key) {
|
|
if (isVue22) {
|
|
const modelOptions = (_e = (_d = vm == null ? void 0 : vm.proxy) == null ? void 0 : _d.$options) == null ? void 0 : _e.model;
|
|
key = (modelOptions == null ? void 0 : modelOptions.value) || "value";
|
|
if (!eventName)
|
|
event = (modelOptions == null ? void 0 : modelOptions.event) || "input";
|
|
} else {
|
|
key = "modelValue";
|
|
}
|
|
}
|
|
event = eventName || event || `update:${key.toString()}`;
|
|
const cloneFn = (val) => !clone2 ? val : isFunction3(clone2) ? clone2(val) : cloneFnJSON(val);
|
|
const getValue3 = () => isDef(props2[key]) ? cloneFn(props2[key]) : defaultValue;
|
|
if (passive) {
|
|
const initialValue = getValue3();
|
|
const proxy = ref(initialValue);
|
|
watch(() => props2[key], (v2) => proxy.value = cloneFn(v2));
|
|
watch(proxy, (v2) => {
|
|
if (v2 !== props2[key] || deep)
|
|
_emit(event, v2);
|
|
}, { deep });
|
|
return proxy;
|
|
} else {
|
|
return computed({
|
|
get() {
|
|
return getValue3();
|
|
},
|
|
set(value) {
|
|
_emit(event, value);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function useWindowFocus({ window: window2 = defaultWindow } = {}) {
|
|
if (!window2)
|
|
return ref(false);
|
|
const focused = ref(window2.document.hasFocus());
|
|
useEventListener(window2, "blur", () => {
|
|
focused.value = false;
|
|
});
|
|
useEventListener(window2, "focus", () => {
|
|
focused.value = true;
|
|
});
|
|
return focused;
|
|
}
|
|
function useWindowSize(options = {}) {
|
|
const {
|
|
window: window2 = defaultWindow,
|
|
initialWidth = Infinity,
|
|
initialHeight = Infinity,
|
|
listenOrientation = true,
|
|
includeScrollbar = true
|
|
} = options;
|
|
const width = ref(initialWidth);
|
|
const height = ref(initialHeight);
|
|
const update2 = () => {
|
|
if (window2) {
|
|
if (includeScrollbar) {
|
|
width.value = window2.innerWidth;
|
|
height.value = window2.innerHeight;
|
|
} else {
|
|
width.value = window2.document.documentElement.clientWidth;
|
|
height.value = window2.document.documentElement.clientHeight;
|
|
}
|
|
}
|
|
};
|
|
update2();
|
|
tryOnMounted(update2);
|
|
useEventListener("resize", update2, { passive: true });
|
|
if (listenOrientation)
|
|
useEventListener("orientationchange", update2, { passive: true });
|
|
return { width, height };
|
|
}
|
|
|
|
// node_modules/element-plus/es/utils/error.mjs
|
|
var ElementPlusError = class extends Error {
|
|
constructor(m2) {
|
|
super(m2);
|
|
this.name = "ElementPlusError";
|
|
}
|
|
};
|
|
function throwError(scope, m2) {
|
|
throw new ElementPlusError(`[${scope}] ${m2}`);
|
|
}
|
|
function debugWarn(scope, message2) {
|
|
if (true) {
|
|
const error = isString(scope) ? new ElementPlusError(`[${scope}] ${message2}`) : scope;
|
|
console.warn(error);
|
|
}
|
|
}
|
|
|
|
// node_modules/element-plus/es/hooks/use-z-index/index.mjs
|
|
var initial2 = {
|
|
current: 0
|
|
};
|
|
var zIndex = ref(0);
|
|
var defaultInitialZIndex = 2e3;
|
|
var ZINDEX_INJECTION_KEY = Symbol("elZIndexContextKey");
|
|
var zIndexContextKey = Symbol("zIndexContextKey");
|
|
var useZIndex = (zIndexOverrides) => {
|
|
const increasingInjection = getCurrentInstance() ? inject(ZINDEX_INJECTION_KEY, initial2) : initial2;
|
|
const zIndexInjection = zIndexOverrides || (getCurrentInstance() ? inject(zIndexContextKey, void 0) : void 0);
|
|
const initialZIndex = computed(() => {
|
|
const zIndexFromInjection = unref(zIndexInjection);
|
|
return isNumber2(zIndexFromInjection) ? zIndexFromInjection : defaultInitialZIndex;
|
|
});
|
|
const currentZIndex = computed(() => initialZIndex.value + zIndex.value);
|
|
const nextZIndex = () => {
|
|
increasingInjection.current++;
|
|
zIndex.value = increasingInjection.current;
|
|
return currentZIndex.value;
|
|
};
|
|
if (!isClient && !inject(ZINDEX_INJECTION_KEY)) {
|
|
debugWarn("ZIndexInjection", `Looks like you are using server rendering, you must provide a z-index provider to ensure the hydration process to be succeed
|
|
usage: app.provide(ZINDEX_INJECTION_KEY, { current: 0 })`);
|
|
}
|
|
return {
|
|
initialZIndex,
|
|
currentZIndex,
|
|
nextZIndex
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/locale/lang/en.mjs
|
|
var English = {
|
|
name: "en",
|
|
el: {
|
|
breadcrumb: {
|
|
label: "Breadcrumb"
|
|
},
|
|
colorpicker: {
|
|
confirm: "OK",
|
|
clear: "Clear",
|
|
defaultLabel: "color picker",
|
|
description: "current color is {color}. press enter to select a new color.",
|
|
alphaLabel: "pick alpha value"
|
|
},
|
|
datepicker: {
|
|
now: "Now",
|
|
today: "Today",
|
|
cancel: "Cancel",
|
|
clear: "Clear",
|
|
confirm: "OK",
|
|
dateTablePrompt: "Use the arrow keys and enter to select the day of the month",
|
|
monthTablePrompt: "Use the arrow keys and enter to select the month",
|
|
yearTablePrompt: "Use the arrow keys and enter to select the year",
|
|
selectedDate: "Selected date",
|
|
selectDate: "Select date",
|
|
selectTime: "Select time",
|
|
startDate: "Start Date",
|
|
startTime: "Start Time",
|
|
endDate: "End Date",
|
|
endTime: "End Time",
|
|
prevYear: "Previous Year",
|
|
nextYear: "Next Year",
|
|
prevMonth: "Previous Month",
|
|
nextMonth: "Next Month",
|
|
year: "",
|
|
month1: "January",
|
|
month2: "February",
|
|
month3: "March",
|
|
month4: "April",
|
|
month5: "May",
|
|
month6: "June",
|
|
month7: "July",
|
|
month8: "August",
|
|
month9: "September",
|
|
month10: "October",
|
|
month11: "November",
|
|
month12: "December",
|
|
week: "week",
|
|
weeks: {
|
|
sun: "Sun",
|
|
mon: "Mon",
|
|
tue: "Tue",
|
|
wed: "Wed",
|
|
thu: "Thu",
|
|
fri: "Fri",
|
|
sat: "Sat"
|
|
},
|
|
weeksFull: {
|
|
sun: "Sunday",
|
|
mon: "Monday",
|
|
tue: "Tuesday",
|
|
wed: "Wednesday",
|
|
thu: "Thursday",
|
|
fri: "Friday",
|
|
sat: "Saturday"
|
|
},
|
|
months: {
|
|
jan: "Jan",
|
|
feb: "Feb",
|
|
mar: "Mar",
|
|
apr: "Apr",
|
|
may: "May",
|
|
jun: "Jun",
|
|
jul: "Jul",
|
|
aug: "Aug",
|
|
sep: "Sep",
|
|
oct: "Oct",
|
|
nov: "Nov",
|
|
dec: "Dec"
|
|
}
|
|
},
|
|
inputNumber: {
|
|
decrease: "decrease number",
|
|
increase: "increase number"
|
|
},
|
|
select: {
|
|
loading: "Loading",
|
|
noMatch: "No matching data",
|
|
noData: "No data",
|
|
placeholder: "Select"
|
|
},
|
|
mention: {
|
|
loading: "Loading"
|
|
},
|
|
dropdown: {
|
|
toggleDropdown: "Toggle Dropdown"
|
|
},
|
|
cascader: {
|
|
noMatch: "No matching data",
|
|
loading: "Loading",
|
|
placeholder: "Select",
|
|
noData: "No data"
|
|
},
|
|
pagination: {
|
|
goto: "Go to",
|
|
pagesize: "/page",
|
|
total: "Total {total}",
|
|
pageClassifier: "",
|
|
page: "Page",
|
|
prev: "Go to previous page",
|
|
next: "Go to next page",
|
|
currentPage: "page {pager}",
|
|
prevPages: "Previous {pager} pages",
|
|
nextPages: "Next {pager} pages",
|
|
deprecationWarning: "Deprecated usages detected, please refer to the el-pagination documentation for more details"
|
|
},
|
|
dialog: {
|
|
close: "Close this dialog"
|
|
},
|
|
drawer: {
|
|
close: "Close this dialog"
|
|
},
|
|
messagebox: {
|
|
title: "Message",
|
|
confirm: "OK",
|
|
cancel: "Cancel",
|
|
error: "Illegal input",
|
|
close: "Close this dialog"
|
|
},
|
|
upload: {
|
|
deleteTip: "press delete to remove",
|
|
delete: "Delete",
|
|
preview: "Preview",
|
|
continue: "Continue"
|
|
},
|
|
slider: {
|
|
defaultLabel: "slider between {min} and {max}",
|
|
defaultRangeStartLabel: "pick start value",
|
|
defaultRangeEndLabel: "pick end value"
|
|
},
|
|
table: {
|
|
emptyText: "No Data",
|
|
confirmFilter: "Confirm",
|
|
resetFilter: "Reset",
|
|
clearFilter: "All",
|
|
sumText: "Sum"
|
|
},
|
|
tour: {
|
|
next: "Next",
|
|
previous: "Previous",
|
|
finish: "Finish"
|
|
},
|
|
tree: {
|
|
emptyText: "No Data"
|
|
},
|
|
transfer: {
|
|
noMatch: "No matching data",
|
|
noData: "No data",
|
|
titles: ["List 1", "List 2"],
|
|
filterPlaceholder: "Enter keyword",
|
|
noCheckedFormat: "{total} items",
|
|
hasCheckedFormat: "{checked}/{total} checked"
|
|
},
|
|
image: {
|
|
error: "FAILED"
|
|
},
|
|
pageHeader: {
|
|
title: "Back"
|
|
},
|
|
popconfirm: {
|
|
confirmButtonText: "Yes",
|
|
cancelButtonText: "No"
|
|
},
|
|
carousel: {
|
|
leftArrow: "Carousel arrow left",
|
|
rightArrow: "Carousel arrow right",
|
|
indicator: "Carousel switch to index {index}"
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/hooks/use-locale/index.mjs
|
|
var buildTranslator = (locale) => (path, option) => translate(path, option, unref(locale));
|
|
var translate = (path, option, locale) => get_default(locale, path, path).replace(/\{(\w+)\}/g, (_2, key) => {
|
|
var _a2;
|
|
return `${(_a2 = option == null ? void 0 : option[key]) != null ? _a2 : `{${key}}`}`;
|
|
});
|
|
var buildLocaleContext = (locale) => {
|
|
const lang = computed(() => unref(locale).name);
|
|
const localeRef = isRef(locale) ? locale : ref(locale);
|
|
return {
|
|
lang,
|
|
locale: localeRef,
|
|
t: buildTranslator(locale)
|
|
};
|
|
};
|
|
var localeContextKey = Symbol("localeContextKey");
|
|
var useLocale = (localeOverrides) => {
|
|
const locale = localeOverrides || inject(localeContextKey, ref());
|
|
return buildLocaleContext(computed(() => locale.value || English));
|
|
};
|
|
|
|
// node_modules/element-plus/es/constants/size.mjs
|
|
var componentSizes = ["", "default", "small", "large"];
|
|
var componentSizeMap = {
|
|
large: 40,
|
|
default: 32,
|
|
small: 24
|
|
};
|
|
|
|
// node_modules/element-plus/es/utils/vue/props/runtime.mjs
|
|
var epPropKey = "__epPropKey";
|
|
var definePropType = (val) => val;
|
|
var isEpProp = (val) => isObject(val) && !!val[epPropKey];
|
|
var buildProp = (prop, key) => {
|
|
if (!isObject(prop) || isEpProp(prop))
|
|
return prop;
|
|
const { values: values2, required: required4, default: defaultValue, type: type4, validator } = prop;
|
|
const _validator = values2 || validator ? (val) => {
|
|
let valid = false;
|
|
let allowedValues = [];
|
|
if (values2) {
|
|
allowedValues = Array.from(values2);
|
|
if (hasOwn(prop, "default")) {
|
|
allowedValues.push(defaultValue);
|
|
}
|
|
valid || (valid = allowedValues.includes(val));
|
|
}
|
|
if (validator)
|
|
valid || (valid = validator(val));
|
|
if (!valid && allowedValues.length > 0) {
|
|
const allowValuesText = [...new Set(allowedValues)].map((value) => JSON.stringify(value)).join(", ");
|
|
warn(`Invalid prop: validation failed${key ? ` for prop "${key}"` : ""}. Expected one of [${allowValuesText}], got value ${JSON.stringify(val)}.`);
|
|
}
|
|
return valid;
|
|
} : void 0;
|
|
const epProp = {
|
|
type: type4,
|
|
required: !!required4,
|
|
validator: _validator,
|
|
[epPropKey]: true
|
|
};
|
|
if (hasOwn(prop, "default"))
|
|
epProp.default = defaultValue;
|
|
return epProp;
|
|
};
|
|
var buildProps = (props2) => fromPairs_default(Object.entries(props2).map(([key, option]) => [
|
|
key,
|
|
buildProp(option, key)
|
|
]));
|
|
|
|
// node_modules/element-plus/es/hooks/use-size/index.mjs
|
|
var useSizeProp = buildProp({
|
|
type: String,
|
|
values: componentSizes,
|
|
required: false
|
|
});
|
|
var useSizeProps = {
|
|
size: useSizeProp
|
|
};
|
|
var SIZE_INJECTION_KEY = Symbol("size");
|
|
var useGlobalSize = () => {
|
|
const injectedSize = inject(SIZE_INJECTION_KEY, {});
|
|
return computed(() => {
|
|
return unref(injectedSize.size) || "";
|
|
});
|
|
};
|
|
|
|
// node_modules/element-plus/es/hooks/use-empty-values/index.mjs
|
|
var emptyValuesContextKey = Symbol("emptyValuesContextKey");
|
|
var SCOPE = "use-empty-values";
|
|
var DEFAULT_EMPTY_VALUES = ["", void 0, null];
|
|
var DEFAULT_VALUE_ON_CLEAR = void 0;
|
|
var useEmptyValuesProps = buildProps({
|
|
emptyValues: Array,
|
|
valueOnClear: {
|
|
type: [String, Number, Boolean, Function],
|
|
default: void 0,
|
|
validator: (val) => isFunction(val) ? !val() : !val
|
|
}
|
|
});
|
|
var useEmptyValues = (props2, defaultValue) => {
|
|
const config = getCurrentInstance() ? inject(emptyValuesContextKey, ref({})) : ref({});
|
|
const emptyValues = computed(() => props2.emptyValues || config.value.emptyValues || DEFAULT_EMPTY_VALUES);
|
|
const valueOnClear = computed(() => {
|
|
if (isFunction(props2.valueOnClear)) {
|
|
return props2.valueOnClear();
|
|
} else if (props2.valueOnClear !== void 0) {
|
|
return props2.valueOnClear;
|
|
} else if (isFunction(config.value.valueOnClear)) {
|
|
return config.value.valueOnClear();
|
|
} else if (config.value.valueOnClear !== void 0) {
|
|
return config.value.valueOnClear;
|
|
}
|
|
return defaultValue !== void 0 ? defaultValue : DEFAULT_VALUE_ON_CLEAR;
|
|
});
|
|
const isEmptyValue2 = (value) => {
|
|
return emptyValues.value.includes(value);
|
|
};
|
|
if (!emptyValues.value.includes(valueOnClear.value)) {
|
|
debugWarn(SCOPE, "value-on-clear should be a value of empty-values");
|
|
}
|
|
return {
|
|
emptyValues,
|
|
valueOnClear,
|
|
isEmptyValue: isEmptyValue2
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/utils/objects.mjs
|
|
var keysOf = (arr) => Object.keys(arr);
|
|
var entriesOf = (arr) => Object.entries(arr);
|
|
var getProp = (obj, path, defaultValue) => {
|
|
return {
|
|
get value() {
|
|
return get_default(obj, path, defaultValue);
|
|
},
|
|
set value(val) {
|
|
set_default(obj, path, val);
|
|
}
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/config-provider/src/hooks/use-global-config.mjs
|
|
var globalConfig = ref();
|
|
function useGlobalConfig(key, defaultValue = void 0) {
|
|
const config = getCurrentInstance() ? inject(configProviderContextKey, globalConfig) : globalConfig;
|
|
if (key) {
|
|
return computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = config.value) == null ? void 0 : _a2[key]) != null ? _b : defaultValue;
|
|
});
|
|
} else {
|
|
return config;
|
|
}
|
|
}
|
|
function useGlobalComponentSettings(block, sizeFallback) {
|
|
const config = useGlobalConfig();
|
|
const ns = useNamespace(block, computed(() => {
|
|
var _a2;
|
|
return ((_a2 = config.value) == null ? void 0 : _a2.namespace) || defaultNamespace;
|
|
}));
|
|
const locale = useLocale(computed(() => {
|
|
var _a2;
|
|
return (_a2 = config.value) == null ? void 0 : _a2.locale;
|
|
}));
|
|
const zIndex2 = useZIndex(computed(() => {
|
|
var _a2;
|
|
return ((_a2 = config.value) == null ? void 0 : _a2.zIndex) || defaultInitialZIndex;
|
|
}));
|
|
const size3 = computed(() => {
|
|
var _a2;
|
|
return unref(sizeFallback) || ((_a2 = config.value) == null ? void 0 : _a2.size) || "";
|
|
});
|
|
provideGlobalConfig(computed(() => unref(config) || {}));
|
|
return {
|
|
ns,
|
|
locale,
|
|
zIndex: zIndex2,
|
|
size: size3
|
|
};
|
|
}
|
|
var provideGlobalConfig = (config, app, global2 = false) => {
|
|
var _a2;
|
|
const inSetup = !!getCurrentInstance();
|
|
const oldConfig = inSetup ? useGlobalConfig() : void 0;
|
|
const provideFn = (_a2 = app == null ? void 0 : app.provide) != null ? _a2 : inSetup ? provide : void 0;
|
|
if (!provideFn) {
|
|
debugWarn("provideGlobalConfig", "provideGlobalConfig() can only be used inside setup().");
|
|
return;
|
|
}
|
|
const context = computed(() => {
|
|
const cfg = unref(config);
|
|
if (!(oldConfig == null ? void 0 : oldConfig.value))
|
|
return cfg;
|
|
return mergeConfig(oldConfig.value, cfg);
|
|
});
|
|
provideFn(configProviderContextKey, context);
|
|
provideFn(localeContextKey, computed(() => context.value.locale));
|
|
provideFn(namespaceContextKey, computed(() => context.value.namespace));
|
|
provideFn(zIndexContextKey, computed(() => context.value.zIndex));
|
|
provideFn(SIZE_INJECTION_KEY, {
|
|
size: computed(() => context.value.size || "")
|
|
});
|
|
provideFn(emptyValuesContextKey, computed(() => ({
|
|
emptyValues: context.value.emptyValues,
|
|
valueOnClear: context.value.valueOnClear
|
|
})));
|
|
if (global2 || !globalConfig.value) {
|
|
globalConfig.value = context.value;
|
|
}
|
|
return context;
|
|
};
|
|
var mergeConfig = (a2, b2) => {
|
|
const keys3 = [...new Set([...keysOf(a2), ...keysOf(b2)])];
|
|
const obj = {};
|
|
for (const key of keys3) {
|
|
obj[key] = b2[key] !== void 0 ? b2[key] : a2[key];
|
|
}
|
|
return obj;
|
|
};
|
|
|
|
// node_modules/element-plus/es/version.mjs
|
|
var version2 = "2.9.11";
|
|
|
|
// node_modules/element-plus/es/make-installer.mjs
|
|
var makeInstaller = (components = []) => {
|
|
const install2 = (app, options) => {
|
|
if (app[INSTALLED_KEY])
|
|
return;
|
|
app[INSTALLED_KEY] = true;
|
|
components.forEach((c2) => app.use(c2));
|
|
if (options)
|
|
provideGlobalConfig(options, app, true);
|
|
};
|
|
return {
|
|
version: version2,
|
|
install: install2
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/constants/event.mjs
|
|
var UPDATE_MODEL_EVENT = "update:modelValue";
|
|
var CHANGE_EVENT = "change";
|
|
var INPUT_EVENT = "input";
|
|
|
|
// node_modules/element-plus/es/components/affix/src/affix.mjs
|
|
var affixProps = buildProps({
|
|
zIndex: {
|
|
type: definePropType([Number, String]),
|
|
default: 100
|
|
},
|
|
target: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
offset: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
position: {
|
|
type: String,
|
|
values: ["top", "bottom"],
|
|
default: "top"
|
|
}
|
|
});
|
|
var affixEmits = {
|
|
scroll: ({ scrollTop, fixed }) => isNumber2(scrollTop) && isBoolean2(fixed),
|
|
[CHANGE_EVENT]: (fixed) => isBoolean2(fixed)
|
|
};
|
|
|
|
// node_modules/element-plus/es/_virtual/plugin-vue_export-helper.mjs
|
|
var _export_sfc = (sfc, props2) => {
|
|
const target2 = sfc.__vccOpts || sfc;
|
|
for (const [key, val] of props2) {
|
|
target2[key] = val;
|
|
}
|
|
return target2;
|
|
};
|
|
|
|
// node_modules/element-plus/es/utils/easings.mjs
|
|
function easeInOutCubic(t, b2, c2, d2) {
|
|
const cc = c2 - b2;
|
|
t /= d2 / 2;
|
|
if (t < 1) {
|
|
return cc / 2 * t * t * t + b2;
|
|
}
|
|
return cc / 2 * ((t -= 2) * t * t + 2) + b2;
|
|
}
|
|
|
|
// node_modules/element-plus/es/utils/raf.mjs
|
|
var rAF = (fn2) => isClient ? window.requestAnimationFrame(fn2) : setTimeout(fn2, 16);
|
|
var cAF = (handle) => isClient ? window.cancelAnimationFrame(handle) : clearTimeout(handle);
|
|
|
|
// node_modules/element-plus/es/utils/dom/style.mjs
|
|
var SCOPE2 = "utils/dom/style";
|
|
var classNameToArray = (cls = "") => cls.split(" ").filter((item) => !!item.trim());
|
|
var hasClass = (el, cls) => {
|
|
if (!el || !cls)
|
|
return false;
|
|
if (cls.includes(" "))
|
|
throw new Error("className should not contain space.");
|
|
return el.classList.contains(cls);
|
|
};
|
|
var addClass = (el, cls) => {
|
|
if (!el || !cls.trim())
|
|
return;
|
|
el.classList.add(...classNameToArray(cls));
|
|
};
|
|
var removeClass = (el, cls) => {
|
|
if (!el || !cls.trim())
|
|
return;
|
|
el.classList.remove(...classNameToArray(cls));
|
|
};
|
|
var getStyle = (element, styleName) => {
|
|
var _a2;
|
|
if (!isClient || !element || !styleName)
|
|
return "";
|
|
let key = camelize(styleName);
|
|
if (key === "float")
|
|
key = "cssFloat";
|
|
try {
|
|
const style = element.style[key];
|
|
if (style)
|
|
return style;
|
|
const computed2 = (_a2 = document.defaultView) == null ? void 0 : _a2.getComputedStyle(element, "");
|
|
return computed2 ? computed2[key] : "";
|
|
} catch (e) {
|
|
return element.style[key];
|
|
}
|
|
};
|
|
var setStyle = (element, styleName, value) => {
|
|
if (!element || !styleName)
|
|
return;
|
|
if (isObject(styleName)) {
|
|
entriesOf(styleName).forEach(([prop, value2]) => setStyle(element, prop, value2));
|
|
} else {
|
|
const key = camelize(styleName);
|
|
element.style[key] = value;
|
|
}
|
|
};
|
|
function addUnit(value, defaultUnit = "px") {
|
|
if (!value)
|
|
return "";
|
|
if (isNumber2(value) || isStringNumber(value)) {
|
|
return `${value}${defaultUnit}`;
|
|
} else if (isString(value)) {
|
|
return value;
|
|
}
|
|
debugWarn(SCOPE2, "binding value must be a string or number");
|
|
}
|
|
|
|
// node_modules/element-plus/es/utils/dom/scroll.mjs
|
|
var isScroll = (el, isVertical) => {
|
|
if (!isClient)
|
|
return false;
|
|
const key = {
|
|
undefined: "overflow",
|
|
true: "overflow-y",
|
|
false: "overflow-x"
|
|
}[String(isVertical)];
|
|
const overflow = getStyle(el, key);
|
|
return ["scroll", "auto", "overlay"].some((s2) => overflow.includes(s2));
|
|
};
|
|
var getScrollContainer = (el, isVertical) => {
|
|
if (!isClient)
|
|
return;
|
|
let parent2 = el;
|
|
while (parent2) {
|
|
if ([window, document, document.documentElement].includes(parent2))
|
|
return window;
|
|
if (isScroll(parent2, isVertical))
|
|
return parent2;
|
|
parent2 = parent2.parentNode;
|
|
}
|
|
return parent2;
|
|
};
|
|
var scrollBarWidth;
|
|
var getScrollBarWidth = (namespace) => {
|
|
var _a2;
|
|
if (!isClient)
|
|
return 0;
|
|
if (scrollBarWidth !== void 0)
|
|
return scrollBarWidth;
|
|
const outer = document.createElement("div");
|
|
outer.className = `${namespace}-scrollbar__wrap`;
|
|
outer.style.visibility = "hidden";
|
|
outer.style.width = "100px";
|
|
outer.style.position = "absolute";
|
|
outer.style.top = "-9999px";
|
|
document.body.appendChild(outer);
|
|
const widthNoScroll = outer.offsetWidth;
|
|
outer.style.overflow = "scroll";
|
|
const inner = document.createElement("div");
|
|
inner.style.width = "100%";
|
|
outer.appendChild(inner);
|
|
const widthWithScroll = inner.offsetWidth;
|
|
(_a2 = outer.parentNode) == null ? void 0 : _a2.removeChild(outer);
|
|
scrollBarWidth = widthNoScroll - widthWithScroll;
|
|
return scrollBarWidth;
|
|
};
|
|
function scrollIntoView(container, selected) {
|
|
if (!isClient)
|
|
return;
|
|
if (!selected) {
|
|
container.scrollTop = 0;
|
|
return;
|
|
}
|
|
const offsetParents = [];
|
|
let pointer = selected.offsetParent;
|
|
while (pointer !== null && container !== pointer && container.contains(pointer)) {
|
|
offsetParents.push(pointer);
|
|
pointer = pointer.offsetParent;
|
|
}
|
|
const top = selected.offsetTop + offsetParents.reduce((prev, curr) => prev + curr.offsetTop, 0);
|
|
const bottom = top + selected.offsetHeight;
|
|
const viewRectTop = container.scrollTop;
|
|
const viewRectBottom = viewRectTop + container.clientHeight;
|
|
if (top < viewRectTop) {
|
|
container.scrollTop = top;
|
|
} else if (bottom > viewRectBottom) {
|
|
container.scrollTop = bottom - container.clientHeight;
|
|
}
|
|
}
|
|
function animateScrollTo(container, from, to, duration, callback) {
|
|
const startTime = Date.now();
|
|
let handle;
|
|
const scroll = () => {
|
|
const timestamp2 = Date.now();
|
|
const time = timestamp2 - startTime;
|
|
const nextScrollTop = easeInOutCubic(time > duration ? duration : time, from, to, duration);
|
|
if (isWindow(container)) {
|
|
container.scrollTo(window.pageXOffset, nextScrollTop);
|
|
} else {
|
|
container.scrollTop = nextScrollTop;
|
|
}
|
|
if (time < duration) {
|
|
handle = rAF(scroll);
|
|
} else if (isFunction(callback)) {
|
|
callback();
|
|
}
|
|
};
|
|
scroll();
|
|
return () => {
|
|
handle && cAF(handle);
|
|
};
|
|
}
|
|
var getScrollElement = (target2, container) => {
|
|
if (isWindow(container)) {
|
|
return target2.ownerDocument.documentElement;
|
|
}
|
|
return container;
|
|
};
|
|
var getScrollTop = (container) => {
|
|
if (isWindow(container)) {
|
|
return window.scrollY;
|
|
}
|
|
return container.scrollTop;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/affix/src/affix2.mjs
|
|
var COMPONENT_NAME = "ElAffix";
|
|
var __default__ = defineComponent({
|
|
name: COMPONENT_NAME
|
|
});
|
|
var _sfc_main = defineComponent({
|
|
...__default__,
|
|
props: affixProps,
|
|
emits: affixEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("affix");
|
|
const target2 = shallowRef();
|
|
const root2 = shallowRef();
|
|
const scrollContainer = shallowRef();
|
|
const { height: windowHeight } = useWindowSize();
|
|
const {
|
|
height: rootHeight,
|
|
width: rootWidth,
|
|
top: rootTop,
|
|
bottom: rootBottom,
|
|
update: updateRoot
|
|
} = useElementBounding(root2, { windowScroll: false });
|
|
const targetRect = useElementBounding(target2);
|
|
const fixed = ref(false);
|
|
const scrollTop = ref(0);
|
|
const transform2 = ref(0);
|
|
const rootStyle = computed(() => {
|
|
return {
|
|
height: fixed.value ? `${rootHeight.value}px` : "",
|
|
width: fixed.value ? `${rootWidth.value}px` : ""
|
|
};
|
|
});
|
|
const affixStyle = computed(() => {
|
|
if (!fixed.value)
|
|
return {};
|
|
const offset3 = props2.offset ? addUnit(props2.offset) : 0;
|
|
return {
|
|
height: `${rootHeight.value}px`,
|
|
width: `${rootWidth.value}px`,
|
|
top: props2.position === "top" ? offset3 : "",
|
|
bottom: props2.position === "bottom" ? offset3 : "",
|
|
transform: transform2.value ? `translateY(${transform2.value}px)` : "",
|
|
zIndex: props2.zIndex
|
|
};
|
|
});
|
|
const update2 = () => {
|
|
if (!scrollContainer.value)
|
|
return;
|
|
scrollTop.value = scrollContainer.value instanceof Window ? document.documentElement.scrollTop : scrollContainer.value.scrollTop || 0;
|
|
const { position, target: target22, offset: offset3 } = props2;
|
|
const rootHeightOffset = offset3 + rootHeight.value;
|
|
if (position === "top") {
|
|
if (target22) {
|
|
const difference2 = targetRect.bottom.value - rootHeightOffset;
|
|
fixed.value = offset3 > rootTop.value && targetRect.bottom.value > 0;
|
|
transform2.value = difference2 < 0 ? difference2 : 0;
|
|
} else {
|
|
fixed.value = offset3 > rootTop.value;
|
|
}
|
|
} else if (target22) {
|
|
const difference2 = windowHeight.value - targetRect.top.value - rootHeightOffset;
|
|
fixed.value = windowHeight.value - offset3 < rootBottom.value && windowHeight.value > targetRect.top.value;
|
|
transform2.value = difference2 < 0 ? -difference2 : 0;
|
|
} else {
|
|
fixed.value = windowHeight.value - offset3 < rootBottom.value;
|
|
}
|
|
};
|
|
const handleScroll2 = async () => {
|
|
updateRoot();
|
|
await nextTick();
|
|
emit("scroll", {
|
|
scrollTop: scrollTop.value,
|
|
fixed: fixed.value
|
|
});
|
|
};
|
|
watch(fixed, (val) => emit(CHANGE_EVENT, val));
|
|
onMounted(() => {
|
|
var _a2;
|
|
if (props2.target) {
|
|
target2.value = (_a2 = document.querySelector(props2.target)) != null ? _a2 : void 0;
|
|
if (!target2.value)
|
|
throwError(COMPONENT_NAME, `Target does not exist: ${props2.target}`);
|
|
} else {
|
|
target2.value = document.documentElement;
|
|
}
|
|
scrollContainer.value = getScrollContainer(root2.value, true);
|
|
updateRoot();
|
|
});
|
|
useEventListener(scrollContainer, "scroll", handleScroll2);
|
|
watchEffect(update2);
|
|
expose({
|
|
update: update2,
|
|
updateRoot
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "root",
|
|
ref: root2,
|
|
class: normalizeClass(unref(ns).b()),
|
|
style: normalizeStyle(unref(rootStyle))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass({ [unref(ns).m("fixed")]: fixed.value }),
|
|
style: normalizeStyle(unref(affixStyle))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 6)
|
|
], 6);
|
|
};
|
|
}
|
|
});
|
|
var Affix = _export_sfc(_sfc_main, [["__file", "affix.vue"]]);
|
|
|
|
// node_modules/element-plus/es/utils/vue/install.mjs
|
|
var withInstall = (main, extra) => {
|
|
main.install = (app) => {
|
|
for (const comp of [main, ...Object.values(extra != null ? extra : {})]) {
|
|
app.component(comp.name, comp);
|
|
}
|
|
};
|
|
if (extra) {
|
|
for (const [key, comp] of Object.entries(extra)) {
|
|
main[key] = comp;
|
|
}
|
|
}
|
|
return main;
|
|
};
|
|
var withInstallFunction = (fn2, name) => {
|
|
fn2.install = (app) => {
|
|
fn2._context = app._context;
|
|
app.config.globalProperties[name] = fn2;
|
|
};
|
|
return fn2;
|
|
};
|
|
var withInstallDirective = (directive, name) => {
|
|
directive.install = (app) => {
|
|
app.directive(name, directive);
|
|
};
|
|
return directive;
|
|
};
|
|
var withNoopInstall = (component2) => {
|
|
component2.install = NOOP;
|
|
return component2;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/affix/index.mjs
|
|
var ElAffix = withInstall(Affix);
|
|
|
|
// node_modules/element-plus/es/components/icon/src/icon.mjs
|
|
var iconProps = buildProps({
|
|
size: {
|
|
type: definePropType([Number, String])
|
|
},
|
|
color: {
|
|
type: String
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/icon/src/icon2.mjs
|
|
var __default__2 = defineComponent({
|
|
name: "ElIcon",
|
|
inheritAttrs: false
|
|
});
|
|
var _sfc_main2 = defineComponent({
|
|
...__default__2,
|
|
props: iconProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("icon");
|
|
const style = computed(() => {
|
|
const { size: size3, color } = props2;
|
|
if (!size3 && !color)
|
|
return {};
|
|
return {
|
|
fontSize: isUndefined2(size3) ? void 0 : addUnit(size3),
|
|
"--color": color
|
|
};
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("i", mergeProps({
|
|
class: unref(ns).b(),
|
|
style: unref(style)
|
|
}, _ctx.$attrs), [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 16);
|
|
};
|
|
}
|
|
});
|
|
var Icon = _export_sfc(_sfc_main2, [["__file", "icon.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/icon/index.mjs
|
|
var ElIcon = withInstall(Icon);
|
|
|
|
// node_modules/element-plus/es/utils/vue/icon.mjs
|
|
var iconPropType = definePropType([
|
|
String,
|
|
Object,
|
|
Function
|
|
]);
|
|
var CloseComponents = {
|
|
Close: close_default
|
|
};
|
|
var TypeComponents = {
|
|
Close: close_default,
|
|
SuccessFilled: success_filled_default,
|
|
InfoFilled: info_filled_default,
|
|
WarningFilled: warning_filled_default,
|
|
CircleCloseFilled: circle_close_filled_default
|
|
};
|
|
var TypeComponentsMap = {
|
|
primary: info_filled_default,
|
|
success: success_filled_default,
|
|
warning: warning_filled_default,
|
|
error: circle_close_filled_default,
|
|
info: info_filled_default
|
|
};
|
|
var ValidateComponentsMap = {
|
|
validating: loading_default,
|
|
success: circle_check_default,
|
|
error: circle_close_default
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/alert/src/alert2.mjs
|
|
var alertEffects = ["light", "dark"];
|
|
var alertProps = buildProps({
|
|
title: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
description: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
type: {
|
|
type: String,
|
|
values: keysOf(TypeComponentsMap),
|
|
default: "info"
|
|
},
|
|
closable: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
closeText: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
showIcon: Boolean,
|
|
center: Boolean,
|
|
effect: {
|
|
type: String,
|
|
values: alertEffects,
|
|
default: "light"
|
|
}
|
|
});
|
|
var alertEmits = {
|
|
close: (evt) => evt instanceof MouseEvent
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/alert/src/alert.mjs
|
|
var __default__3 = defineComponent({
|
|
name: "ElAlert"
|
|
});
|
|
var _sfc_main3 = defineComponent({
|
|
...__default__3,
|
|
props: alertProps,
|
|
emits: alertEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const { Close } = TypeComponents;
|
|
const slots = useSlots();
|
|
const ns = useNamespace("alert");
|
|
const visible = ref(true);
|
|
const iconComponent = computed(() => TypeComponentsMap[props2.type]);
|
|
const hasDesc = computed(() => !!(props2.description || slots.default));
|
|
const close2 = (evt) => {
|
|
visible.value = false;
|
|
emit("close", evt);
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(Transition, {
|
|
name: unref(ns).b("fade"),
|
|
persisted: ""
|
|
}, {
|
|
default: withCtx(() => [
|
|
withDirectives(createBaseVNode("div", {
|
|
class: normalizeClass([unref(ns).b(), unref(ns).m(_ctx.type), unref(ns).is("center", _ctx.center), unref(ns).is(_ctx.effect)]),
|
|
role: "alert"
|
|
}, [
|
|
_ctx.showIcon && (_ctx.$slots.icon || unref(iconComponent)) ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("icon"), { [unref(ns).is("big")]: unref(hasDesc) }])
|
|
}, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "icon", {}, () => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(unref(iconComponent))))
|
|
])
|
|
]),
|
|
_: 3
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("content"))
|
|
}, [
|
|
_ctx.title || _ctx.$slots.title ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("title"), { "with-description": unref(hasDesc) }])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "title", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.title), 1)
|
|
])
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
unref(hasDesc) ? (openBlock(), createElementBlock("p", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("description"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.description), 1)
|
|
])
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
_ctx.closable ? (openBlock(), createElementBlock(Fragment, { key: 2 }, [
|
|
_ctx.closeText ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("close-btn"), unref(ns).is("customed")]),
|
|
onClick: close2
|
|
}, toDisplayString(_ctx.closeText), 3)) : (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("close-btn")),
|
|
onClick: close2
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(Close))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"]))
|
|
], 64)) : createCommentVNode("v-if", true)
|
|
], 2)
|
|
], 2), [
|
|
[vShow, visible.value]
|
|
])
|
|
]),
|
|
_: 3
|
|
}, 8, ["name"]);
|
|
};
|
|
}
|
|
});
|
|
var Alert = _export_sfc(_sfc_main3, [["__file", "alert.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/alert/index.mjs
|
|
var ElAlert = withInstall(Alert);
|
|
|
|
// node_modules/element-plus/es/hooks/use-aria/index.mjs
|
|
var ariaProps = buildProps({
|
|
ariaLabel: String,
|
|
ariaOrientation: {
|
|
type: String,
|
|
values: ["horizontal", "vertical", "undefined"]
|
|
},
|
|
ariaControls: String
|
|
});
|
|
var useAriaProps = (arias) => {
|
|
return pick_default(ariaProps, arias);
|
|
};
|
|
|
|
// node_modules/element-plus/es/utils/typescript.mjs
|
|
var mutable = (val) => val;
|
|
|
|
// node_modules/element-plus/es/components/input/src/input.mjs
|
|
var inputProps = buildProps({
|
|
id: {
|
|
type: String,
|
|
default: void 0
|
|
},
|
|
size: useSizeProp,
|
|
disabled: Boolean,
|
|
modelValue: {
|
|
type: definePropType([
|
|
String,
|
|
Number,
|
|
Object
|
|
]),
|
|
default: ""
|
|
},
|
|
maxlength: {
|
|
type: [String, Number]
|
|
},
|
|
minlength: {
|
|
type: [String, Number]
|
|
},
|
|
type: {
|
|
type: String,
|
|
default: "text"
|
|
},
|
|
resize: {
|
|
type: String,
|
|
values: ["none", "both", "horizontal", "vertical"]
|
|
},
|
|
autosize: {
|
|
type: definePropType([Boolean, Object]),
|
|
default: false
|
|
},
|
|
autocomplete: {
|
|
type: String,
|
|
default: "off"
|
|
},
|
|
formatter: {
|
|
type: Function
|
|
},
|
|
parser: {
|
|
type: Function
|
|
},
|
|
placeholder: {
|
|
type: String
|
|
},
|
|
form: {
|
|
type: String
|
|
},
|
|
readonly: Boolean,
|
|
clearable: Boolean,
|
|
showPassword: Boolean,
|
|
showWordLimit: Boolean,
|
|
suffixIcon: {
|
|
type: iconPropType
|
|
},
|
|
prefixIcon: {
|
|
type: iconPropType
|
|
},
|
|
containerRole: {
|
|
type: String,
|
|
default: void 0
|
|
},
|
|
tabindex: {
|
|
type: [String, Number],
|
|
default: 0
|
|
},
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
inputStyle: {
|
|
type: definePropType([Object, Array, String]),
|
|
default: () => mutable({})
|
|
},
|
|
autofocus: Boolean,
|
|
rows: {
|
|
type: Number,
|
|
default: 2
|
|
},
|
|
...useAriaProps(["ariaLabel"])
|
|
});
|
|
var inputEmits = {
|
|
[UPDATE_MODEL_EVENT]: (value) => isString(value),
|
|
input: (value) => isString(value),
|
|
change: (value) => isString(value),
|
|
focus: (evt) => evt instanceof FocusEvent,
|
|
blur: (evt) => evt instanceof FocusEvent,
|
|
clear: () => true,
|
|
mouseleave: (evt) => evt instanceof MouseEvent,
|
|
mouseenter: (evt) => evt instanceof MouseEvent,
|
|
keydown: (evt) => evt instanceof Event,
|
|
compositionstart: (evt) => evt instanceof CompositionEvent,
|
|
compositionupdate: (evt) => evt instanceof CompositionEvent,
|
|
compositionend: (evt) => evt instanceof CompositionEvent
|
|
};
|
|
|
|
// node_modules/element-plus/es/hooks/use-attrs/index.mjs
|
|
var DEFAULT_EXCLUDE_KEYS = ["class", "style"];
|
|
var LISTENER_PREFIX = /^on[A-Z]/;
|
|
var useAttrs2 = (params = {}) => {
|
|
const { excludeListeners = false, excludeKeys } = params;
|
|
const allExcludeKeys = computed(() => {
|
|
return ((excludeKeys == null ? void 0 : excludeKeys.value) || []).concat(DEFAULT_EXCLUDE_KEYS);
|
|
});
|
|
const instance = getCurrentInstance();
|
|
if (!instance) {
|
|
debugWarn("use-attrs", "getCurrentInstance() returned null. useAttrs() must be called at the top of a setup function");
|
|
return computed(() => ({}));
|
|
}
|
|
return computed(() => {
|
|
var _a2;
|
|
return fromPairs_default(Object.entries((_a2 = instance.proxy) == null ? void 0 : _a2.$attrs).filter(([key]) => !allExcludeKeys.value.includes(key) && !(excludeListeners && LISTENER_PREFIX.test(key))));
|
|
});
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/form/src/constants.mjs
|
|
var formContextKey = Symbol("formContextKey");
|
|
var formItemContextKey = Symbol("formItemContextKey");
|
|
|
|
// node_modules/element-plus/es/hooks/use-id/index.mjs
|
|
var defaultIdInjection = {
|
|
prefix: Math.floor(Math.random() * 1e4),
|
|
current: 0
|
|
};
|
|
var ID_INJECTION_KEY = Symbol("elIdInjection");
|
|
var useIdInjection = () => {
|
|
return getCurrentInstance() ? inject(ID_INJECTION_KEY, defaultIdInjection) : defaultIdInjection;
|
|
};
|
|
var useId = (deterministicId) => {
|
|
const idInjection = useIdInjection();
|
|
if (!isClient && idInjection === defaultIdInjection) {
|
|
debugWarn("IdInjection", `Looks like you are using server rendering, you must provide a id provider to ensure the hydration process to be succeed
|
|
usage: app.provide(ID_INJECTION_KEY, {
|
|
prefix: number,
|
|
current: number,
|
|
})`);
|
|
}
|
|
const namespace = useGetDerivedNamespace();
|
|
const idRef = computedEager(() => unref(deterministicId) || `${namespace.value}-id-${idInjection.prefix}-${idInjection.current++}`);
|
|
return idRef;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/form/src/hooks/use-form-item.mjs
|
|
var useFormItem = () => {
|
|
const form = inject(formContextKey, void 0);
|
|
const formItem = inject(formItemContextKey, void 0);
|
|
return {
|
|
form,
|
|
formItem
|
|
};
|
|
};
|
|
var useFormItemInputId = (props2, {
|
|
formItemContext,
|
|
disableIdGeneration,
|
|
disableIdManagement
|
|
}) => {
|
|
if (!disableIdGeneration) {
|
|
disableIdGeneration = ref(false);
|
|
}
|
|
if (!disableIdManagement) {
|
|
disableIdManagement = ref(false);
|
|
}
|
|
const inputId = ref();
|
|
let idUnwatch = void 0;
|
|
const isLabeledByFormItem = computed(() => {
|
|
var _a2;
|
|
return !!(!(props2.label || props2.ariaLabel) && formItemContext && formItemContext.inputIds && ((_a2 = formItemContext.inputIds) == null ? void 0 : _a2.length) <= 1);
|
|
});
|
|
onMounted(() => {
|
|
idUnwatch = watch([toRef(props2, "id"), disableIdGeneration], ([id, disableIdGeneration2]) => {
|
|
const newId = id != null ? id : !disableIdGeneration2 ? useId().value : void 0;
|
|
if (newId !== inputId.value) {
|
|
if (formItemContext == null ? void 0 : formItemContext.removeInputId) {
|
|
inputId.value && formItemContext.removeInputId(inputId.value);
|
|
if (!(disableIdManagement == null ? void 0 : disableIdManagement.value) && !disableIdGeneration2 && newId) {
|
|
formItemContext.addInputId(newId);
|
|
}
|
|
}
|
|
inputId.value = newId;
|
|
}
|
|
}, { immediate: true });
|
|
});
|
|
onUnmounted(() => {
|
|
idUnwatch && idUnwatch();
|
|
if (formItemContext == null ? void 0 : formItemContext.removeInputId) {
|
|
inputId.value && formItemContext.removeInputId(inputId.value);
|
|
}
|
|
});
|
|
return {
|
|
isLabeledByFormItem,
|
|
inputId
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/hooks/use-prop/index.mjs
|
|
var useProp = (name) => {
|
|
const vm = getCurrentInstance();
|
|
return computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = vm == null ? void 0 : vm.proxy) == null ? void 0 : _a2.$props) == null ? void 0 : _b[name];
|
|
});
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/form/src/hooks/use-form-common-props.mjs
|
|
var useFormSize = (fallback, ignore = {}) => {
|
|
const emptyRef = ref(void 0);
|
|
const size3 = ignore.prop ? emptyRef : useProp("size");
|
|
const globalConfig2 = ignore.global ? emptyRef : useGlobalSize();
|
|
const form = ignore.form ? { size: void 0 } : inject(formContextKey, void 0);
|
|
const formItem = ignore.formItem ? { size: void 0 } : inject(formItemContextKey, void 0);
|
|
return computed(() => size3.value || unref(fallback) || (formItem == null ? void 0 : formItem.size) || (form == null ? void 0 : form.size) || globalConfig2.value || "");
|
|
};
|
|
var useFormDisabled = (fallback) => {
|
|
const disabled = useProp("disabled");
|
|
const form = inject(formContextKey, void 0);
|
|
return computed(() => disabled.value || unref(fallback) || (form == null ? void 0 : form.disabled) || false);
|
|
};
|
|
var useSize = useFormSize;
|
|
var useDisabled = useFormDisabled;
|
|
|
|
// node_modules/element-plus/es/hooks/use-focus-controller/index.mjs
|
|
function useFocusController(target2, {
|
|
beforeFocus,
|
|
afterFocus,
|
|
beforeBlur,
|
|
afterBlur
|
|
} = {}) {
|
|
const instance = getCurrentInstance();
|
|
const { emit } = instance;
|
|
const wrapperRef = shallowRef();
|
|
const disabled = useProp("disabled");
|
|
const isFocused = ref(false);
|
|
const handleFocus = (event) => {
|
|
const cancelFocus = isFunction(beforeFocus) ? beforeFocus(event) : false;
|
|
if (cancelFocus || isFocused.value)
|
|
return;
|
|
isFocused.value = true;
|
|
emit("focus", event);
|
|
afterFocus == null ? void 0 : afterFocus();
|
|
};
|
|
const handleBlur = (event) => {
|
|
var _a2;
|
|
const cancelBlur = isFunction(beforeBlur) ? beforeBlur(event) : false;
|
|
if (cancelBlur || event.relatedTarget && ((_a2 = wrapperRef.value) == null ? void 0 : _a2.contains(event.relatedTarget)))
|
|
return;
|
|
isFocused.value = false;
|
|
emit("blur", event);
|
|
afterBlur == null ? void 0 : afterBlur();
|
|
};
|
|
const handleClick = () => {
|
|
var _a2, _b;
|
|
if (((_a2 = wrapperRef.value) == null ? void 0 : _a2.contains(document.activeElement)) && wrapperRef.value !== document.activeElement || disabled.value)
|
|
return;
|
|
(_b = target2.value) == null ? void 0 : _b.focus();
|
|
};
|
|
watch([wrapperRef, disabled], ([el, disabled2]) => {
|
|
if (!el)
|
|
return;
|
|
if (disabled2) {
|
|
el.removeAttribute("tabindex");
|
|
} else {
|
|
el.setAttribute("tabindex", "-1");
|
|
}
|
|
});
|
|
useEventListener(wrapperRef, "focus", handleFocus, true);
|
|
useEventListener(wrapperRef, "blur", handleBlur, true);
|
|
useEventListener(wrapperRef, "click", handleClick, true);
|
|
if (false) {
|
|
onMounted(() => {
|
|
const targetEl = isElement2(target2.value) ? target2.value : document.querySelector("input,textarea");
|
|
if (targetEl) {
|
|
useEventListener(targetEl, "focus", handleFocus, true);
|
|
useEventListener(targetEl, "blur", handleBlur, true);
|
|
}
|
|
});
|
|
}
|
|
return {
|
|
isFocused,
|
|
wrapperRef,
|
|
handleFocus,
|
|
handleBlur
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/utils/i18n.mjs
|
|
var isKorean = (text) => /([\uAC00-\uD7AF\u3130-\u318F])+/gi.test(text);
|
|
|
|
// node_modules/element-plus/es/hooks/use-composition/index.mjs
|
|
function useComposition({
|
|
afterComposition,
|
|
emit
|
|
}) {
|
|
const isComposing = ref(false);
|
|
const handleCompositionStart = (event) => {
|
|
emit == null ? void 0 : emit("compositionstart", event);
|
|
isComposing.value = true;
|
|
};
|
|
const handleCompositionUpdate = (event) => {
|
|
var _a2;
|
|
emit == null ? void 0 : emit("compositionupdate", event);
|
|
const text = (_a2 = event.target) == null ? void 0 : _a2.value;
|
|
const lastCharacter = text[text.length - 1] || "";
|
|
isComposing.value = !isKorean(lastCharacter);
|
|
};
|
|
const handleCompositionEnd = (event) => {
|
|
emit == null ? void 0 : emit("compositionend", event);
|
|
if (isComposing.value) {
|
|
isComposing.value = false;
|
|
nextTick(() => afterComposition(event));
|
|
}
|
|
};
|
|
const handleComposition = (event) => {
|
|
event.type === "compositionend" ? handleCompositionEnd(event) : handleCompositionUpdate(event);
|
|
};
|
|
return {
|
|
isComposing,
|
|
handleComposition,
|
|
handleCompositionStart,
|
|
handleCompositionUpdate,
|
|
handleCompositionEnd
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/hooks/use-cursor/index.mjs
|
|
function useCursor(input) {
|
|
let selectionInfo;
|
|
function recordCursor() {
|
|
if (input.value == void 0)
|
|
return;
|
|
const { selectionStart, selectionEnd, value } = input.value;
|
|
if (selectionStart == null || selectionEnd == null)
|
|
return;
|
|
const beforeTxt = value.slice(0, Math.max(0, selectionStart));
|
|
const afterTxt = value.slice(Math.max(0, selectionEnd));
|
|
selectionInfo = {
|
|
selectionStart,
|
|
selectionEnd,
|
|
value,
|
|
beforeTxt,
|
|
afterTxt
|
|
};
|
|
}
|
|
function setCursor() {
|
|
if (input.value == void 0 || selectionInfo == void 0)
|
|
return;
|
|
const { value } = input.value;
|
|
const { beforeTxt, afterTxt, selectionStart } = selectionInfo;
|
|
if (beforeTxt == void 0 || afterTxt == void 0 || selectionStart == void 0)
|
|
return;
|
|
let startPos = value.length;
|
|
if (value.endsWith(afterTxt)) {
|
|
startPos = value.length - afterTxt.length;
|
|
} else if (value.startsWith(beforeTxt)) {
|
|
startPos = beforeTxt.length;
|
|
} else {
|
|
const beforeLastChar = beforeTxt[selectionStart - 1];
|
|
const newIndex = value.indexOf(beforeLastChar, selectionStart - 1);
|
|
if (newIndex !== -1) {
|
|
startPos = newIndex + 1;
|
|
}
|
|
}
|
|
input.value.setSelectionRange(startPos, startPos);
|
|
}
|
|
return [recordCursor, setCursor];
|
|
}
|
|
|
|
// node_modules/element-plus/es/utils/browser.mjs
|
|
var isFirefox = () => isClient && /firefox/i.test(window.navigator.userAgent);
|
|
|
|
// node_modules/element-plus/es/components/input/src/utils.mjs
|
|
var hiddenTextarea = void 0;
|
|
var HIDDEN_STYLE = {
|
|
height: "0",
|
|
visibility: "hidden",
|
|
overflow: isFirefox() ? "" : "hidden",
|
|
position: "absolute",
|
|
"z-index": "-1000",
|
|
top: "0",
|
|
right: "0"
|
|
};
|
|
var CONTEXT_STYLE = [
|
|
"letter-spacing",
|
|
"line-height",
|
|
"padding-top",
|
|
"padding-bottom",
|
|
"font-family",
|
|
"font-weight",
|
|
"font-size",
|
|
"text-rendering",
|
|
"text-transform",
|
|
"width",
|
|
"text-indent",
|
|
"padding-left",
|
|
"padding-right",
|
|
"border-width",
|
|
"box-sizing"
|
|
];
|
|
function calculateNodeStyling(targetElement) {
|
|
const style = window.getComputedStyle(targetElement);
|
|
const boxSizing = style.getPropertyValue("box-sizing");
|
|
const paddingSize = Number.parseFloat(style.getPropertyValue("padding-bottom")) + Number.parseFloat(style.getPropertyValue("padding-top"));
|
|
const borderSize = Number.parseFloat(style.getPropertyValue("border-bottom-width")) + Number.parseFloat(style.getPropertyValue("border-top-width"));
|
|
const contextStyle = CONTEXT_STYLE.map((name) => [
|
|
name,
|
|
style.getPropertyValue(name)
|
|
]);
|
|
return { contextStyle, paddingSize, borderSize, boxSizing };
|
|
}
|
|
function calcTextareaHeight(targetElement, minRows = 1, maxRows) {
|
|
var _a2;
|
|
if (!hiddenTextarea) {
|
|
hiddenTextarea = document.createElement("textarea");
|
|
document.body.appendChild(hiddenTextarea);
|
|
}
|
|
const { paddingSize, borderSize, boxSizing, contextStyle } = calculateNodeStyling(targetElement);
|
|
contextStyle.forEach(([key, value]) => hiddenTextarea == null ? void 0 : hiddenTextarea.style.setProperty(key, value));
|
|
Object.entries(HIDDEN_STYLE).forEach(([key, value]) => hiddenTextarea == null ? void 0 : hiddenTextarea.style.setProperty(key, value, "important"));
|
|
hiddenTextarea.value = targetElement.value || targetElement.placeholder || "";
|
|
let height = hiddenTextarea.scrollHeight;
|
|
const result2 = {};
|
|
if (boxSizing === "border-box") {
|
|
height = height + borderSize;
|
|
} else if (boxSizing === "content-box") {
|
|
height = height - paddingSize;
|
|
}
|
|
hiddenTextarea.value = "";
|
|
const singleRowHeight = hiddenTextarea.scrollHeight - paddingSize;
|
|
if (isNumber2(minRows)) {
|
|
let minHeight = singleRowHeight * minRows;
|
|
if (boxSizing === "border-box") {
|
|
minHeight = minHeight + paddingSize + borderSize;
|
|
}
|
|
height = Math.max(minHeight, height);
|
|
result2.minHeight = `${minHeight}px`;
|
|
}
|
|
if (isNumber2(maxRows)) {
|
|
let maxHeight = singleRowHeight * maxRows;
|
|
if (boxSizing === "border-box") {
|
|
maxHeight = maxHeight + paddingSize + borderSize;
|
|
}
|
|
height = Math.min(maxHeight, height);
|
|
}
|
|
result2.height = `${height}px`;
|
|
(_a2 = hiddenTextarea.parentNode) == null ? void 0 : _a2.removeChild(hiddenTextarea);
|
|
hiddenTextarea = void 0;
|
|
return result2;
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/input/src/input2.mjs
|
|
var COMPONENT_NAME2 = "ElInput";
|
|
var __default__4 = defineComponent({
|
|
name: COMPONENT_NAME2,
|
|
inheritAttrs: false
|
|
});
|
|
var _sfc_main4 = defineComponent({
|
|
...__default__4,
|
|
props: inputProps,
|
|
emits: inputEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const rawAttrs = useAttrs();
|
|
const attrs = useAttrs2();
|
|
const slots = useSlots();
|
|
const containerKls = computed(() => [
|
|
props2.type === "textarea" ? nsTextarea.b() : nsInput.b(),
|
|
nsInput.m(inputSize.value),
|
|
nsInput.is("disabled", inputDisabled.value),
|
|
nsInput.is("exceed", inputExceed.value),
|
|
{
|
|
[nsInput.b("group")]: slots.prepend || slots.append,
|
|
[nsInput.m("prefix")]: slots.prefix || props2.prefixIcon,
|
|
[nsInput.m("suffix")]: slots.suffix || props2.suffixIcon || props2.clearable || props2.showPassword,
|
|
[nsInput.bm("suffix", "password-clear")]: showClear.value && showPwdVisible.value,
|
|
[nsInput.b("hidden")]: props2.type === "hidden"
|
|
},
|
|
rawAttrs.class
|
|
]);
|
|
const wrapperKls = computed(() => [
|
|
nsInput.e("wrapper"),
|
|
nsInput.is("focus", isFocused.value)
|
|
]);
|
|
const { form: elForm, formItem: elFormItem } = useFormItem();
|
|
const { inputId } = useFormItemInputId(props2, {
|
|
formItemContext: elFormItem
|
|
});
|
|
const inputSize = useFormSize();
|
|
const inputDisabled = useFormDisabled();
|
|
const nsInput = useNamespace("input");
|
|
const nsTextarea = useNamespace("textarea");
|
|
const input = shallowRef();
|
|
const textarea = shallowRef();
|
|
const hovering = ref(false);
|
|
const passwordVisible = ref(false);
|
|
const countStyle = ref();
|
|
const textareaCalcStyle = shallowRef(props2.inputStyle);
|
|
const _ref = computed(() => input.value || textarea.value);
|
|
const { wrapperRef, isFocused, handleFocus, handleBlur } = useFocusController(_ref, {
|
|
beforeFocus() {
|
|
return inputDisabled.value;
|
|
},
|
|
afterBlur() {
|
|
var _a2;
|
|
if (props2.validateEvent) {
|
|
(_a2 = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a2.call(elFormItem, "blur").catch((err) => debugWarn(err));
|
|
}
|
|
}
|
|
});
|
|
const needStatusIcon = computed(() => {
|
|
var _a2;
|
|
return (_a2 = elForm == null ? void 0 : elForm.statusIcon) != null ? _a2 : false;
|
|
});
|
|
const validateState = computed(() => (elFormItem == null ? void 0 : elFormItem.validateState) || "");
|
|
const validateIcon = computed(() => validateState.value && ValidateComponentsMap[validateState.value]);
|
|
const passwordIcon = computed(() => passwordVisible.value ? view_default : hide_default);
|
|
const containerStyle = computed(() => [
|
|
rawAttrs.style
|
|
]);
|
|
const textareaStyle = computed(() => [
|
|
props2.inputStyle,
|
|
textareaCalcStyle.value,
|
|
{ resize: props2.resize }
|
|
]);
|
|
const nativeInputValue = computed(() => isNil_default(props2.modelValue) ? "" : String(props2.modelValue));
|
|
const showClear = computed(() => props2.clearable && !inputDisabled.value && !props2.readonly && !!nativeInputValue.value && (isFocused.value || hovering.value));
|
|
const showPwdVisible = computed(() => props2.showPassword && !inputDisabled.value && !!nativeInputValue.value);
|
|
const isWordLimitVisible = computed(() => props2.showWordLimit && !!props2.maxlength && (props2.type === "text" || props2.type === "textarea") && !inputDisabled.value && !props2.readonly && !props2.showPassword);
|
|
const textLength = computed(() => nativeInputValue.value.length);
|
|
const inputExceed = computed(() => !!isWordLimitVisible.value && textLength.value > Number(props2.maxlength));
|
|
const suffixVisible = computed(() => !!slots.suffix || !!props2.suffixIcon || showClear.value || props2.showPassword || isWordLimitVisible.value || !!validateState.value && needStatusIcon.value);
|
|
const [recordCursor, setCursor] = useCursor(input);
|
|
useResizeObserver(textarea, (entries) => {
|
|
onceInitSizeTextarea();
|
|
if (!isWordLimitVisible.value || props2.resize !== "both")
|
|
return;
|
|
const entry = entries[0];
|
|
const { width } = entry.contentRect;
|
|
countStyle.value = {
|
|
right: `calc(100% - ${width + 15 + 6}px)`
|
|
};
|
|
});
|
|
const resizeTextarea = () => {
|
|
const { type: type4, autosize } = props2;
|
|
if (!isClient || type4 !== "textarea" || !textarea.value)
|
|
return;
|
|
if (autosize) {
|
|
const minRows = isObject(autosize) ? autosize.minRows : void 0;
|
|
const maxRows = isObject(autosize) ? autosize.maxRows : void 0;
|
|
const textareaStyle2 = calcTextareaHeight(textarea.value, minRows, maxRows);
|
|
textareaCalcStyle.value = {
|
|
overflowY: "hidden",
|
|
...textareaStyle2
|
|
};
|
|
nextTick(() => {
|
|
textarea.value.offsetHeight;
|
|
textareaCalcStyle.value = textareaStyle2;
|
|
});
|
|
} else {
|
|
textareaCalcStyle.value = {
|
|
minHeight: calcTextareaHeight(textarea.value).minHeight
|
|
};
|
|
}
|
|
};
|
|
const createOnceInitResize = (resizeTextarea2) => {
|
|
let isInit = false;
|
|
return () => {
|
|
var _a2;
|
|
if (isInit || !props2.autosize)
|
|
return;
|
|
const isElHidden = ((_a2 = textarea.value) == null ? void 0 : _a2.offsetParent) === null;
|
|
if (!isElHidden) {
|
|
resizeTextarea2();
|
|
isInit = true;
|
|
}
|
|
};
|
|
};
|
|
const onceInitSizeTextarea = createOnceInitResize(resizeTextarea);
|
|
const setNativeInputValue = () => {
|
|
const input2 = _ref.value;
|
|
const formatterValue = props2.formatter ? props2.formatter(nativeInputValue.value) : nativeInputValue.value;
|
|
if (!input2 || input2.value === formatterValue)
|
|
return;
|
|
input2.value = formatterValue;
|
|
};
|
|
const handleInput = async (event) => {
|
|
recordCursor();
|
|
let { value } = event.target;
|
|
if (props2.formatter && props2.parser) {
|
|
value = props2.parser(value);
|
|
}
|
|
if (isComposing.value)
|
|
return;
|
|
if (value === nativeInputValue.value) {
|
|
setNativeInputValue();
|
|
return;
|
|
}
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emit(INPUT_EVENT, value);
|
|
await nextTick();
|
|
setNativeInputValue();
|
|
setCursor();
|
|
};
|
|
const handleChange = (event) => {
|
|
let { value } = event.target;
|
|
if (props2.formatter && props2.parser) {
|
|
value = props2.parser(value);
|
|
}
|
|
emit(CHANGE_EVENT, value);
|
|
};
|
|
const {
|
|
isComposing,
|
|
handleCompositionStart,
|
|
handleCompositionUpdate,
|
|
handleCompositionEnd
|
|
} = useComposition({ emit, afterComposition: handleInput });
|
|
const handlePasswordVisible = () => {
|
|
recordCursor();
|
|
passwordVisible.value = !passwordVisible.value;
|
|
setTimeout(setCursor);
|
|
};
|
|
const focus = () => {
|
|
var _a2;
|
|
return (_a2 = _ref.value) == null ? void 0 : _a2.focus();
|
|
};
|
|
const blur = () => {
|
|
var _a2;
|
|
return (_a2 = _ref.value) == null ? void 0 : _a2.blur();
|
|
};
|
|
const handleMouseLeave = (evt) => {
|
|
hovering.value = false;
|
|
emit("mouseleave", evt);
|
|
};
|
|
const handleMouseEnter = (evt) => {
|
|
hovering.value = true;
|
|
emit("mouseenter", evt);
|
|
};
|
|
const handleKeydown = (evt) => {
|
|
emit("keydown", evt);
|
|
};
|
|
const select = () => {
|
|
var _a2;
|
|
(_a2 = _ref.value) == null ? void 0 : _a2.select();
|
|
};
|
|
const clear = () => {
|
|
emit(UPDATE_MODEL_EVENT, "");
|
|
emit(CHANGE_EVENT, "");
|
|
emit("clear");
|
|
emit(INPUT_EVENT, "");
|
|
};
|
|
watch(() => props2.modelValue, () => {
|
|
var _a2;
|
|
nextTick(() => resizeTextarea());
|
|
if (props2.validateEvent) {
|
|
(_a2 = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a2.call(elFormItem, "change").catch((err) => debugWarn(err));
|
|
}
|
|
});
|
|
watch(nativeInputValue, () => setNativeInputValue());
|
|
watch(() => props2.type, async () => {
|
|
await nextTick();
|
|
setNativeInputValue();
|
|
resizeTextarea();
|
|
});
|
|
onMounted(() => {
|
|
if (!props2.formatter && props2.parser) {
|
|
debugWarn(COMPONENT_NAME2, "If you set the parser, you also need to set the formatter.");
|
|
}
|
|
setNativeInputValue();
|
|
nextTick(resizeTextarea);
|
|
});
|
|
expose({
|
|
input,
|
|
textarea,
|
|
ref: _ref,
|
|
textareaStyle,
|
|
autosize: toRef(props2, "autosize"),
|
|
isComposing,
|
|
focus,
|
|
blur,
|
|
select,
|
|
clear,
|
|
resizeTextarea
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([
|
|
unref(containerKls),
|
|
{
|
|
[unref(nsInput).bm("group", "append")]: _ctx.$slots.append,
|
|
[unref(nsInput).bm("group", "prepend")]: _ctx.$slots.prepend
|
|
}
|
|
]),
|
|
style: normalizeStyle(unref(containerStyle)),
|
|
onMouseenter: handleMouseEnter,
|
|
onMouseleave: handleMouseLeave
|
|
}, [
|
|
createCommentVNode(" input "),
|
|
_ctx.type !== "textarea" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
|
|
createCommentVNode(" prepend slot "),
|
|
_ctx.$slots.prepend ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(nsInput).be("group", "prepend"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "prepend")
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
ref_key: "wrapperRef",
|
|
ref: wrapperRef,
|
|
class: normalizeClass(unref(wrapperKls))
|
|
}, [
|
|
createCommentVNode(" prefix slot "),
|
|
_ctx.$slots.prefix || _ctx.prefixIcon ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
class: normalizeClass(unref(nsInput).e("prefix"))
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(nsInput).e("prefix-inner"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "prefix"),
|
|
_ctx.prefixIcon ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(nsInput).e("icon"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.prefixIcon)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true)
|
|
], 2)
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("input", mergeProps({
|
|
id: unref(inputId),
|
|
ref_key: "input",
|
|
ref: input,
|
|
class: unref(nsInput).e("inner")
|
|
}, unref(attrs), {
|
|
minlength: _ctx.minlength,
|
|
maxlength: _ctx.maxlength,
|
|
type: _ctx.showPassword ? passwordVisible.value ? "text" : "password" : _ctx.type,
|
|
disabled: unref(inputDisabled),
|
|
readonly: _ctx.readonly,
|
|
autocomplete: _ctx.autocomplete,
|
|
tabindex: _ctx.tabindex,
|
|
"aria-label": _ctx.ariaLabel,
|
|
placeholder: _ctx.placeholder,
|
|
style: _ctx.inputStyle,
|
|
form: _ctx.form,
|
|
autofocus: _ctx.autofocus,
|
|
role: _ctx.containerRole,
|
|
onCompositionstart: unref(handleCompositionStart),
|
|
onCompositionupdate: unref(handleCompositionUpdate),
|
|
onCompositionend: unref(handleCompositionEnd),
|
|
onInput: handleInput,
|
|
onChange: handleChange,
|
|
onKeydown: handleKeydown
|
|
}), null, 16, ["id", "minlength", "maxlength", "type", "disabled", "readonly", "autocomplete", "tabindex", "aria-label", "placeholder", "form", "autofocus", "role", "onCompositionstart", "onCompositionupdate", "onCompositionend"]),
|
|
createCommentVNode(" suffix slot "),
|
|
unref(suffixVisible) ? (openBlock(), createElementBlock("span", {
|
|
key: 1,
|
|
class: normalizeClass(unref(nsInput).e("suffix"))
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(nsInput).e("suffix-inner"))
|
|
}, [
|
|
!unref(showClear) || !unref(showPwdVisible) || !unref(isWordLimitVisible) ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
|
|
renderSlot(_ctx.$slots, "suffix"),
|
|
_ctx.suffixIcon ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(nsInput).e("icon"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.suffixIcon)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true)
|
|
], 64)) : createCommentVNode("v-if", true),
|
|
unref(showClear) ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 1,
|
|
class: normalizeClass([unref(nsInput).e("icon"), unref(nsInput).e("clear")]),
|
|
onMousedown: withModifiers(unref(NOOP), ["prevent"]),
|
|
onClick: clear
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(circle_close_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "onMousedown"])) : createCommentVNode("v-if", true),
|
|
unref(showPwdVisible) ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 2,
|
|
class: normalizeClass([unref(nsInput).e("icon"), unref(nsInput).e("password")]),
|
|
onClick: handlePasswordVisible
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(unref(passwordIcon))))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true),
|
|
unref(isWordLimitVisible) ? (openBlock(), createElementBlock("span", {
|
|
key: 3,
|
|
class: normalizeClass(unref(nsInput).e("count"))
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(nsInput).e("count-inner"))
|
|
}, toDisplayString(unref(textLength)) + " / " + toDisplayString(_ctx.maxlength), 3)
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
unref(validateState) && unref(validateIcon) && unref(needStatusIcon) ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 4,
|
|
class: normalizeClass([
|
|
unref(nsInput).e("icon"),
|
|
unref(nsInput).e("validateIcon"),
|
|
unref(nsInput).is("loading", unref(validateState) === "validating")
|
|
])
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(unref(validateIcon))))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true)
|
|
], 2)
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 2),
|
|
createCommentVNode(" append slot "),
|
|
_ctx.$slots.append ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(nsInput).be("group", "append"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "append")
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 64)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
|
|
createCommentVNode(" textarea "),
|
|
createBaseVNode("textarea", mergeProps({
|
|
id: unref(inputId),
|
|
ref_key: "textarea",
|
|
ref: textarea,
|
|
class: [unref(nsTextarea).e("inner"), unref(nsInput).is("focus", unref(isFocused))]
|
|
}, unref(attrs), {
|
|
minlength: _ctx.minlength,
|
|
maxlength: _ctx.maxlength,
|
|
tabindex: _ctx.tabindex,
|
|
disabled: unref(inputDisabled),
|
|
readonly: _ctx.readonly,
|
|
autocomplete: _ctx.autocomplete,
|
|
style: unref(textareaStyle),
|
|
"aria-label": _ctx.ariaLabel,
|
|
placeholder: _ctx.placeholder,
|
|
form: _ctx.form,
|
|
autofocus: _ctx.autofocus,
|
|
rows: _ctx.rows,
|
|
role: _ctx.containerRole,
|
|
onCompositionstart: unref(handleCompositionStart),
|
|
onCompositionupdate: unref(handleCompositionUpdate),
|
|
onCompositionend: unref(handleCompositionEnd),
|
|
onInput: handleInput,
|
|
onFocus: unref(handleFocus),
|
|
onBlur: unref(handleBlur),
|
|
onChange: handleChange,
|
|
onKeydown: handleKeydown
|
|
}), null, 16, ["id", "minlength", "maxlength", "tabindex", "disabled", "readonly", "autocomplete", "aria-label", "placeholder", "form", "autofocus", "rows", "role", "onCompositionstart", "onCompositionupdate", "onCompositionend", "onFocus", "onBlur"]),
|
|
unref(isWordLimitVisible) ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
style: normalizeStyle(countStyle.value),
|
|
class: normalizeClass(unref(nsInput).e("count"))
|
|
}, toDisplayString(unref(textLength)) + " / " + toDisplayString(_ctx.maxlength), 7)) : createCommentVNode("v-if", true)
|
|
], 64))
|
|
], 38);
|
|
};
|
|
}
|
|
});
|
|
var Input = _export_sfc(_sfc_main4, [["__file", "input.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/input/index.mjs
|
|
var ElInput = withInstall(Input);
|
|
|
|
// node_modules/element-plus/es/components/scrollbar/src/util.mjs
|
|
var GAP = 4;
|
|
var BAR_MAP = {
|
|
vertical: {
|
|
offset: "offsetHeight",
|
|
scroll: "scrollTop",
|
|
scrollSize: "scrollHeight",
|
|
size: "height",
|
|
key: "vertical",
|
|
axis: "Y",
|
|
client: "clientY",
|
|
direction: "top"
|
|
},
|
|
horizontal: {
|
|
offset: "offsetWidth",
|
|
scroll: "scrollLeft",
|
|
scrollSize: "scrollWidth",
|
|
size: "width",
|
|
key: "horizontal",
|
|
axis: "X",
|
|
client: "clientX",
|
|
direction: "left"
|
|
}
|
|
};
|
|
var renderThumbStyle = ({
|
|
move,
|
|
size: size3,
|
|
bar
|
|
}) => ({
|
|
[bar.size]: size3,
|
|
transform: `translate${bar.axis}(${move}%)`
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/scrollbar/src/constants.mjs
|
|
var scrollbarContextKey = Symbol("scrollbarContextKey");
|
|
|
|
// node_modules/element-plus/es/components/scrollbar/src/thumb.mjs
|
|
var thumbProps = buildProps({
|
|
vertical: Boolean,
|
|
size: String,
|
|
move: Number,
|
|
ratio: {
|
|
type: Number,
|
|
required: true
|
|
},
|
|
always: Boolean
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/scrollbar/src/scrollbar.mjs
|
|
var scrollbarProps = buildProps({
|
|
height: {
|
|
type: [String, Number],
|
|
default: ""
|
|
},
|
|
maxHeight: {
|
|
type: [String, Number],
|
|
default: ""
|
|
},
|
|
native: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
wrapStyle: {
|
|
type: definePropType([String, Object, Array]),
|
|
default: ""
|
|
},
|
|
wrapClass: {
|
|
type: [String, Array],
|
|
default: ""
|
|
},
|
|
viewClass: {
|
|
type: [String, Array],
|
|
default: ""
|
|
},
|
|
viewStyle: {
|
|
type: [String, Array, Object],
|
|
default: ""
|
|
},
|
|
noresize: Boolean,
|
|
tag: {
|
|
type: String,
|
|
default: "div"
|
|
},
|
|
always: Boolean,
|
|
minSize: {
|
|
type: Number,
|
|
default: 20
|
|
},
|
|
tabindex: {
|
|
type: [String, Number],
|
|
default: void 0
|
|
},
|
|
id: String,
|
|
role: String,
|
|
...useAriaProps(["ariaLabel", "ariaOrientation"])
|
|
});
|
|
var scrollbarEmits = {
|
|
scroll: ({
|
|
scrollTop,
|
|
scrollLeft
|
|
}) => [scrollTop, scrollLeft].every(isNumber2)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/scrollbar/src/thumb2.mjs
|
|
var COMPONENT_NAME3 = "Thumb";
|
|
var _sfc_main5 = defineComponent({
|
|
__name: "thumb",
|
|
props: thumbProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const scrollbar = inject(scrollbarContextKey);
|
|
const ns = useNamespace("scrollbar");
|
|
if (!scrollbar)
|
|
throwError(COMPONENT_NAME3, "can not inject scrollbar context");
|
|
const instance = ref();
|
|
const thumb = ref();
|
|
const thumbState = ref({});
|
|
const visible = ref(false);
|
|
let cursorDown = false;
|
|
let cursorLeave = false;
|
|
let originalOnSelectStart = isClient ? document.onselectstart : null;
|
|
const bar = computed(() => BAR_MAP[props2.vertical ? "vertical" : "horizontal"]);
|
|
const thumbStyle = computed(() => renderThumbStyle({
|
|
size: props2.size,
|
|
move: props2.move,
|
|
bar: bar.value
|
|
}));
|
|
const offsetRatio = computed(() => instance.value[bar.value.offset] ** 2 / scrollbar.wrapElement[bar.value.scrollSize] / props2.ratio / thumb.value[bar.value.offset]);
|
|
const clickThumbHandler = (e) => {
|
|
var _a2;
|
|
e.stopPropagation();
|
|
if (e.ctrlKey || [1, 2].includes(e.button))
|
|
return;
|
|
(_a2 = window.getSelection()) == null ? void 0 : _a2.removeAllRanges();
|
|
startDrag(e);
|
|
const el = e.currentTarget;
|
|
if (!el)
|
|
return;
|
|
thumbState.value[bar.value.axis] = el[bar.value.offset] - (e[bar.value.client] - el.getBoundingClientRect()[bar.value.direction]);
|
|
};
|
|
const clickTrackHandler = (e) => {
|
|
if (!thumb.value || !instance.value || !scrollbar.wrapElement)
|
|
return;
|
|
const offset3 = Math.abs(e.target.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]);
|
|
const thumbHalf = thumb.value[bar.value.offset] / 2;
|
|
const thumbPositionPercentage = (offset3 - thumbHalf) * 100 * offsetRatio.value / instance.value[bar.value.offset];
|
|
scrollbar.wrapElement[bar.value.scroll] = thumbPositionPercentage * scrollbar.wrapElement[bar.value.scrollSize] / 100;
|
|
};
|
|
const startDrag = (e) => {
|
|
e.stopImmediatePropagation();
|
|
cursorDown = true;
|
|
document.addEventListener("mousemove", mouseMoveDocumentHandler);
|
|
document.addEventListener("mouseup", mouseUpDocumentHandler);
|
|
originalOnSelectStart = document.onselectstart;
|
|
document.onselectstart = () => false;
|
|
};
|
|
const mouseMoveDocumentHandler = (e) => {
|
|
if (!instance.value || !thumb.value)
|
|
return;
|
|
if (cursorDown === false)
|
|
return;
|
|
const prevPage = thumbState.value[bar.value.axis];
|
|
if (!prevPage)
|
|
return;
|
|
const offset3 = (instance.value.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) * -1;
|
|
const thumbClickPosition = thumb.value[bar.value.offset] - prevPage;
|
|
const thumbPositionPercentage = (offset3 - thumbClickPosition) * 100 * offsetRatio.value / instance.value[bar.value.offset];
|
|
scrollbar.wrapElement[bar.value.scroll] = thumbPositionPercentage * scrollbar.wrapElement[bar.value.scrollSize] / 100;
|
|
};
|
|
const mouseUpDocumentHandler = () => {
|
|
cursorDown = false;
|
|
thumbState.value[bar.value.axis] = 0;
|
|
document.removeEventListener("mousemove", mouseMoveDocumentHandler);
|
|
document.removeEventListener("mouseup", mouseUpDocumentHandler);
|
|
restoreOnselectstart();
|
|
if (cursorLeave)
|
|
visible.value = false;
|
|
};
|
|
const mouseMoveScrollbarHandler = () => {
|
|
cursorLeave = false;
|
|
visible.value = !!props2.size;
|
|
};
|
|
const mouseLeaveScrollbarHandler = () => {
|
|
cursorLeave = true;
|
|
visible.value = cursorDown;
|
|
};
|
|
onBeforeUnmount(() => {
|
|
restoreOnselectstart();
|
|
document.removeEventListener("mouseup", mouseUpDocumentHandler);
|
|
});
|
|
const restoreOnselectstart = () => {
|
|
if (document.onselectstart !== originalOnSelectStart)
|
|
document.onselectstart = originalOnSelectStart;
|
|
};
|
|
useEventListener(toRef(scrollbar, "scrollbarElement"), "mousemove", mouseMoveScrollbarHandler);
|
|
useEventListener(toRef(scrollbar, "scrollbarElement"), "mouseleave", mouseLeaveScrollbarHandler);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(Transition, {
|
|
name: unref(ns).b("fade"),
|
|
persisted: ""
|
|
}, {
|
|
default: withCtx(() => [
|
|
withDirectives(createBaseVNode("div", {
|
|
ref_key: "instance",
|
|
ref: instance,
|
|
class: normalizeClass([unref(ns).e("bar"), unref(ns).is(unref(bar).key)]),
|
|
onMousedown: clickTrackHandler,
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, [
|
|
createBaseVNode("div", {
|
|
ref_key: "thumb",
|
|
ref: thumb,
|
|
class: normalizeClass(unref(ns).e("thumb")),
|
|
style: normalizeStyle(unref(thumbStyle)),
|
|
onMousedown: clickThumbHandler
|
|
}, null, 38)
|
|
], 42, ["onClick"]), [
|
|
[vShow, _ctx.always || visible.value]
|
|
])
|
|
]),
|
|
_: 1
|
|
}, 8, ["name"]);
|
|
};
|
|
}
|
|
});
|
|
var Thumb = _export_sfc(_sfc_main5, [["__file", "thumb.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/scrollbar/src/bar.mjs
|
|
var barProps = buildProps({
|
|
always: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
minSize: {
|
|
type: Number,
|
|
required: true
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/scrollbar/src/bar2.mjs
|
|
var _sfc_main6 = defineComponent({
|
|
__name: "bar",
|
|
props: barProps,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const scrollbar = inject(scrollbarContextKey);
|
|
const moveX = ref(0);
|
|
const moveY = ref(0);
|
|
const sizeWidth = ref("");
|
|
const sizeHeight = ref("");
|
|
const ratioY = ref(1);
|
|
const ratioX = ref(1);
|
|
const handleScroll2 = (wrap2) => {
|
|
if (wrap2) {
|
|
const offsetHeight = wrap2.offsetHeight - GAP;
|
|
const offsetWidth = wrap2.offsetWidth - GAP;
|
|
moveY.value = wrap2.scrollTop * 100 / offsetHeight * ratioY.value;
|
|
moveX.value = wrap2.scrollLeft * 100 / offsetWidth * ratioX.value;
|
|
}
|
|
};
|
|
const update2 = () => {
|
|
const wrap2 = scrollbar == null ? void 0 : scrollbar.wrapElement;
|
|
if (!wrap2)
|
|
return;
|
|
const offsetHeight = wrap2.offsetHeight - GAP;
|
|
const offsetWidth = wrap2.offsetWidth - GAP;
|
|
const originalHeight = offsetHeight ** 2 / wrap2.scrollHeight;
|
|
const originalWidth = offsetWidth ** 2 / wrap2.scrollWidth;
|
|
const height = Math.max(originalHeight, props2.minSize);
|
|
const width = Math.max(originalWidth, props2.minSize);
|
|
ratioY.value = originalHeight / (offsetHeight - originalHeight) / (height / (offsetHeight - height));
|
|
ratioX.value = originalWidth / (offsetWidth - originalWidth) / (width / (offsetWidth - width));
|
|
sizeHeight.value = height + GAP < offsetHeight ? `${height}px` : "";
|
|
sizeWidth.value = width + GAP < offsetWidth ? `${width}px` : "";
|
|
};
|
|
expose({
|
|
handleScroll: handleScroll2,
|
|
update: update2
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock(Fragment, null, [
|
|
createVNode(Thumb, {
|
|
move: moveX.value,
|
|
ratio: ratioX.value,
|
|
size: sizeWidth.value,
|
|
always: _ctx.always
|
|
}, null, 8, ["move", "ratio", "size", "always"]),
|
|
createVNode(Thumb, {
|
|
move: moveY.value,
|
|
ratio: ratioY.value,
|
|
size: sizeHeight.value,
|
|
vertical: "",
|
|
always: _ctx.always
|
|
}, null, 8, ["move", "ratio", "size", "always"])
|
|
], 64);
|
|
};
|
|
}
|
|
});
|
|
var Bar = _export_sfc(_sfc_main6, [["__file", "bar.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/scrollbar/src/scrollbar2.mjs
|
|
var COMPONENT_NAME4 = "ElScrollbar";
|
|
var __default__5 = defineComponent({
|
|
name: COMPONENT_NAME4
|
|
});
|
|
var _sfc_main7 = defineComponent({
|
|
...__default__5,
|
|
props: scrollbarProps,
|
|
emits: scrollbarEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("scrollbar");
|
|
let stopResizeObserver = void 0;
|
|
let stopResizeListener = void 0;
|
|
let wrapScrollTop = 0;
|
|
let wrapScrollLeft = 0;
|
|
const scrollbarRef = ref();
|
|
const wrapRef = ref();
|
|
const resizeRef = ref();
|
|
const barRef = ref();
|
|
const wrapStyle = computed(() => {
|
|
const style = {};
|
|
if (props2.height)
|
|
style.height = addUnit(props2.height);
|
|
if (props2.maxHeight)
|
|
style.maxHeight = addUnit(props2.maxHeight);
|
|
return [props2.wrapStyle, style];
|
|
});
|
|
const wrapKls = computed(() => {
|
|
return [
|
|
props2.wrapClass,
|
|
ns.e("wrap"),
|
|
{ [ns.em("wrap", "hidden-default")]: !props2.native }
|
|
];
|
|
});
|
|
const resizeKls = computed(() => {
|
|
return [ns.e("view"), props2.viewClass];
|
|
});
|
|
const handleScroll2 = () => {
|
|
var _a2;
|
|
if (wrapRef.value) {
|
|
(_a2 = barRef.value) == null ? void 0 : _a2.handleScroll(wrapRef.value);
|
|
wrapScrollTop = wrapRef.value.scrollTop;
|
|
wrapScrollLeft = wrapRef.value.scrollLeft;
|
|
emit("scroll", {
|
|
scrollTop: wrapRef.value.scrollTop,
|
|
scrollLeft: wrapRef.value.scrollLeft
|
|
});
|
|
}
|
|
};
|
|
function scrollTo(arg1, arg2) {
|
|
if (isObject(arg1)) {
|
|
wrapRef.value.scrollTo(arg1);
|
|
} else if (isNumber2(arg1) && isNumber2(arg2)) {
|
|
wrapRef.value.scrollTo(arg1, arg2);
|
|
}
|
|
}
|
|
const setScrollTop = (value) => {
|
|
if (!isNumber2(value)) {
|
|
debugWarn(COMPONENT_NAME4, "value must be a number");
|
|
return;
|
|
}
|
|
wrapRef.value.scrollTop = value;
|
|
};
|
|
const setScrollLeft = (value) => {
|
|
if (!isNumber2(value)) {
|
|
debugWarn(COMPONENT_NAME4, "value must be a number");
|
|
return;
|
|
}
|
|
wrapRef.value.scrollLeft = value;
|
|
};
|
|
const update2 = () => {
|
|
var _a2;
|
|
(_a2 = barRef.value) == null ? void 0 : _a2.update();
|
|
};
|
|
watch(() => props2.noresize, (noresize) => {
|
|
if (noresize) {
|
|
stopResizeObserver == null ? void 0 : stopResizeObserver();
|
|
stopResizeListener == null ? void 0 : stopResizeListener();
|
|
} else {
|
|
({ stop: stopResizeObserver } = useResizeObserver(resizeRef, update2));
|
|
stopResizeListener = useEventListener("resize", update2);
|
|
}
|
|
}, { immediate: true });
|
|
watch(() => [props2.maxHeight, props2.height], () => {
|
|
if (!props2.native)
|
|
nextTick(() => {
|
|
var _a2;
|
|
update2();
|
|
if (wrapRef.value) {
|
|
(_a2 = barRef.value) == null ? void 0 : _a2.handleScroll(wrapRef.value);
|
|
}
|
|
});
|
|
});
|
|
provide(scrollbarContextKey, reactive({
|
|
scrollbarElement: scrollbarRef,
|
|
wrapElement: wrapRef
|
|
}));
|
|
onActivated(() => {
|
|
if (wrapRef.value) {
|
|
wrapRef.value.scrollTop = wrapScrollTop;
|
|
wrapRef.value.scrollLeft = wrapScrollLeft;
|
|
}
|
|
});
|
|
onMounted(() => {
|
|
if (!props2.native)
|
|
nextTick(() => {
|
|
update2();
|
|
});
|
|
});
|
|
onUpdated(() => update2());
|
|
expose({
|
|
wrapRef,
|
|
update: update2,
|
|
scrollTo,
|
|
setScrollTop,
|
|
setScrollLeft,
|
|
handleScroll: handleScroll2
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "scrollbarRef",
|
|
ref: scrollbarRef,
|
|
class: normalizeClass(unref(ns).b())
|
|
}, [
|
|
createBaseVNode("div", {
|
|
ref_key: "wrapRef",
|
|
ref: wrapRef,
|
|
class: normalizeClass(unref(wrapKls)),
|
|
style: normalizeStyle(unref(wrapStyle)),
|
|
tabindex: _ctx.tabindex,
|
|
onScroll: handleScroll2
|
|
}, [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.tag), {
|
|
id: _ctx.id,
|
|
ref_key: "resizeRef",
|
|
ref: resizeRef,
|
|
class: normalizeClass(unref(resizeKls)),
|
|
style: normalizeStyle(_ctx.viewStyle),
|
|
role: _ctx.role,
|
|
"aria-label": _ctx.ariaLabel,
|
|
"aria-orientation": _ctx.ariaOrientation
|
|
}, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 8, ["id", "class", "style", "role", "aria-label", "aria-orientation"]))
|
|
], 46, ["tabindex"]),
|
|
!_ctx.native ? (openBlock(), createBlock(Bar, {
|
|
key: 0,
|
|
ref_key: "barRef",
|
|
ref: barRef,
|
|
always: _ctx.always,
|
|
"min-size": _ctx.minSize
|
|
}, null, 8, ["always", "min-size"])) : createCommentVNode("v-if", true)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Scrollbar = _export_sfc(_sfc_main7, [["__file", "scrollbar.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/scrollbar/index.mjs
|
|
var ElScrollbar = withInstall(Scrollbar);
|
|
|
|
// node_modules/element-plus/es/components/popper/src/constants.mjs
|
|
var POPPER_INJECTION_KEY = Symbol("popper");
|
|
var POPPER_CONTENT_INJECTION_KEY = Symbol("popperContent");
|
|
|
|
// node_modules/element-plus/es/components/popper/src/popper.mjs
|
|
var Effect = {
|
|
LIGHT: "light",
|
|
DARK: "dark"
|
|
};
|
|
var roleTypes = [
|
|
"dialog",
|
|
"grid",
|
|
"group",
|
|
"listbox",
|
|
"menu",
|
|
"navigation",
|
|
"tooltip",
|
|
"tree"
|
|
];
|
|
var popperProps = buildProps({
|
|
role: {
|
|
type: String,
|
|
values: roleTypes,
|
|
default: "tooltip"
|
|
}
|
|
});
|
|
var usePopperProps = popperProps;
|
|
|
|
// node_modules/element-plus/es/components/popper/src/arrow2.mjs
|
|
var __default__6 = defineComponent({
|
|
name: "ElPopperArrow",
|
|
inheritAttrs: false
|
|
});
|
|
var _sfc_main8 = defineComponent({
|
|
...__default__6,
|
|
setup(__props, { expose }) {
|
|
const ns = useNamespace("popper");
|
|
const { arrowRef, arrowStyle } = inject(POPPER_CONTENT_INJECTION_KEY, void 0);
|
|
onBeforeUnmount(() => {
|
|
arrowRef.value = void 0;
|
|
});
|
|
expose({
|
|
arrowRef
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("span", {
|
|
ref_key: "arrowRef",
|
|
ref: arrowRef,
|
|
class: normalizeClass(unref(ns).e("arrow")),
|
|
style: normalizeStyle(unref(arrowStyle)),
|
|
"data-popper-arrow": ""
|
|
}, null, 6);
|
|
};
|
|
}
|
|
});
|
|
var ElPopperArrow = _export_sfc(_sfc_main8, [["__file", "arrow.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/popper/src/trigger.mjs
|
|
var popperTriggerProps = buildProps({
|
|
virtualRef: {
|
|
type: definePropType(Object)
|
|
},
|
|
virtualTriggering: Boolean,
|
|
onMouseenter: {
|
|
type: definePropType(Function)
|
|
},
|
|
onMouseleave: {
|
|
type: definePropType(Function)
|
|
},
|
|
onClick: {
|
|
type: definePropType(Function)
|
|
},
|
|
onKeydown: {
|
|
type: definePropType(Function)
|
|
},
|
|
onFocus: {
|
|
type: definePropType(Function)
|
|
},
|
|
onBlur: {
|
|
type: definePropType(Function)
|
|
},
|
|
onContextmenu: {
|
|
type: definePropType(Function)
|
|
},
|
|
id: String,
|
|
open: Boolean
|
|
});
|
|
var usePopperTriggerProps = popperTriggerProps;
|
|
|
|
// node_modules/element-plus/es/hooks/use-forward-ref/index.mjs
|
|
var FORWARD_REF_INJECTION_KEY = Symbol("elForwardRef");
|
|
var useForwardRef = (forwardRef) => {
|
|
const setForwardRef = (el) => {
|
|
forwardRef.value = el;
|
|
};
|
|
provide(FORWARD_REF_INJECTION_KEY, {
|
|
setForwardRef
|
|
});
|
|
};
|
|
var useForwardRefDirective = (setForwardRef) => {
|
|
return {
|
|
mounted(el) {
|
|
setForwardRef(el);
|
|
},
|
|
updated(el) {
|
|
setForwardRef(el);
|
|
},
|
|
unmounted() {
|
|
setForwardRef(null);
|
|
}
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/utils/dom/aria.mjs
|
|
var FOCUSABLE_ELEMENT_SELECTORS = `a[href],button:not([disabled]),button:not([hidden]),:not([tabindex="-1"]),input:not([disabled]),input:not([type="hidden"]),select:not([disabled]),textarea:not([disabled])`;
|
|
var isVisible = (element) => {
|
|
if (false)
|
|
return true;
|
|
const computed2 = getComputedStyle(element);
|
|
return computed2.position === "fixed" ? false : element.offsetParent !== null;
|
|
};
|
|
var obtainAllFocusableElements = (element) => {
|
|
return Array.from(element.querySelectorAll(FOCUSABLE_ELEMENT_SELECTORS)).filter((item) => isFocusable(item) && isVisible(item));
|
|
};
|
|
var isFocusable = (element) => {
|
|
if (element.tabIndex > 0 || element.tabIndex === 0 && element.getAttribute("tabIndex") !== null) {
|
|
return true;
|
|
}
|
|
if (element.tabIndex < 0 || element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true") {
|
|
return false;
|
|
}
|
|
switch (element.nodeName) {
|
|
case "A": {
|
|
return !!element.href && element.rel !== "ignore";
|
|
}
|
|
case "INPUT": {
|
|
return !(element.type === "hidden" || element.type === "file");
|
|
}
|
|
case "BUTTON":
|
|
case "SELECT":
|
|
case "TEXTAREA": {
|
|
return true;
|
|
}
|
|
default: {
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
var triggerEvent = function(elm, name, ...opts) {
|
|
let eventName;
|
|
if (name.includes("mouse") || name.includes("click")) {
|
|
eventName = "MouseEvents";
|
|
} else if (name.includes("key")) {
|
|
eventName = "KeyboardEvent";
|
|
} else {
|
|
eventName = "HTMLEvents";
|
|
}
|
|
const evt = document.createEvent(eventName);
|
|
evt.initEvent(name, ...opts);
|
|
elm.dispatchEvent(evt);
|
|
return elm;
|
|
};
|
|
var isLeaf = (el) => !el.getAttribute("aria-owns");
|
|
var getSibling = (el, distance, elClass) => {
|
|
const { parentNode } = el;
|
|
if (!parentNode)
|
|
return null;
|
|
const siblings = parentNode.querySelectorAll(elClass);
|
|
const index = Array.prototype.indexOf.call(siblings, el);
|
|
return siblings[index + distance] || null;
|
|
};
|
|
var focusNode = (el) => {
|
|
if (!el)
|
|
return;
|
|
el.focus();
|
|
!isLeaf(el) && el.click();
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/slot/src/only-child.mjs
|
|
var NAME = "ElOnlyChild";
|
|
var OnlyChild = defineComponent({
|
|
name: NAME,
|
|
setup(_2, {
|
|
slots,
|
|
attrs
|
|
}) {
|
|
var _a2;
|
|
const forwardRefInjection = inject(FORWARD_REF_INJECTION_KEY);
|
|
const forwardRefDirective = useForwardRefDirective((_a2 = forwardRefInjection == null ? void 0 : forwardRefInjection.setForwardRef) != null ? _a2 : NOOP);
|
|
return () => {
|
|
var _a22;
|
|
const defaultSlot = (_a22 = slots.default) == null ? void 0 : _a22.call(slots, attrs);
|
|
if (!defaultSlot)
|
|
return null;
|
|
if (defaultSlot.length > 1) {
|
|
debugWarn(NAME, "requires exact only one valid child.");
|
|
return null;
|
|
}
|
|
const firstLegitNode = findFirstLegitChild(defaultSlot);
|
|
if (!firstLegitNode) {
|
|
debugWarn(NAME, "no valid child node found");
|
|
return null;
|
|
}
|
|
return withDirectives(cloneVNode(firstLegitNode, attrs), [[forwardRefDirective]]);
|
|
};
|
|
}
|
|
});
|
|
function findFirstLegitChild(node) {
|
|
if (!node)
|
|
return null;
|
|
const children = node;
|
|
for (const child of children) {
|
|
if (isObject(child)) {
|
|
switch (child.type) {
|
|
case Comment:
|
|
continue;
|
|
case Text:
|
|
case "svg":
|
|
return wrapTextContent(child);
|
|
case Fragment:
|
|
return findFirstLegitChild(child.children);
|
|
default:
|
|
return child;
|
|
}
|
|
}
|
|
return wrapTextContent(child);
|
|
}
|
|
return null;
|
|
}
|
|
function wrapTextContent(s2) {
|
|
const ns = useNamespace("only-child");
|
|
return createVNode("span", {
|
|
"class": ns.e("content")
|
|
}, [s2]);
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/popper/src/trigger2.mjs
|
|
var __default__7 = defineComponent({
|
|
name: "ElPopperTrigger",
|
|
inheritAttrs: false
|
|
});
|
|
var _sfc_main9 = defineComponent({
|
|
...__default__7,
|
|
props: popperTriggerProps,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const { role, triggerRef } = inject(POPPER_INJECTION_KEY, void 0);
|
|
useForwardRef(triggerRef);
|
|
const ariaControls = computed(() => {
|
|
return ariaHaspopup.value ? props2.id : void 0;
|
|
});
|
|
const ariaDescribedby = computed(() => {
|
|
if (role && role.value === "tooltip") {
|
|
return props2.open && props2.id ? props2.id : void 0;
|
|
}
|
|
return void 0;
|
|
});
|
|
const ariaHaspopup = computed(() => {
|
|
if (role && role.value !== "tooltip") {
|
|
return role.value;
|
|
}
|
|
return void 0;
|
|
});
|
|
const ariaExpanded = computed(() => {
|
|
return ariaHaspopup.value ? `${props2.open}` : void 0;
|
|
});
|
|
let virtualTriggerAriaStopWatch = void 0;
|
|
const TRIGGER_ELE_EVENTS = [
|
|
"onMouseenter",
|
|
"onMouseleave",
|
|
"onClick",
|
|
"onKeydown",
|
|
"onFocus",
|
|
"onBlur",
|
|
"onContextmenu"
|
|
];
|
|
onMounted(() => {
|
|
watch(() => props2.virtualRef, (virtualEl) => {
|
|
if (virtualEl) {
|
|
triggerRef.value = unrefElement(virtualEl);
|
|
}
|
|
}, {
|
|
immediate: true
|
|
});
|
|
watch(triggerRef, (el, prevEl) => {
|
|
virtualTriggerAriaStopWatch == null ? void 0 : virtualTriggerAriaStopWatch();
|
|
virtualTriggerAriaStopWatch = void 0;
|
|
if (isElement2(el)) {
|
|
TRIGGER_ELE_EVENTS.forEach((eventName) => {
|
|
var _a2;
|
|
const handler = props2[eventName];
|
|
if (handler) {
|
|
el.addEventListener(eventName.slice(2).toLowerCase(), handler);
|
|
(_a2 = prevEl == null ? void 0 : prevEl.removeEventListener) == null ? void 0 : _a2.call(prevEl, eventName.slice(2).toLowerCase(), handler);
|
|
}
|
|
});
|
|
if (isFocusable(el)) {
|
|
virtualTriggerAriaStopWatch = watch([ariaControls, ariaDescribedby, ariaHaspopup, ariaExpanded], (watches) => {
|
|
[
|
|
"aria-controls",
|
|
"aria-describedby",
|
|
"aria-haspopup",
|
|
"aria-expanded"
|
|
].forEach((key, idx) => {
|
|
isNil_default(watches[idx]) ? el.removeAttribute(key) : el.setAttribute(key, watches[idx]);
|
|
});
|
|
}, { immediate: true });
|
|
}
|
|
}
|
|
if (isElement2(prevEl) && isFocusable(prevEl)) {
|
|
[
|
|
"aria-controls",
|
|
"aria-describedby",
|
|
"aria-haspopup",
|
|
"aria-expanded"
|
|
].forEach((key) => prevEl.removeAttribute(key));
|
|
}
|
|
}, {
|
|
immediate: true
|
|
});
|
|
});
|
|
onBeforeUnmount(() => {
|
|
virtualTriggerAriaStopWatch == null ? void 0 : virtualTriggerAriaStopWatch();
|
|
virtualTriggerAriaStopWatch = void 0;
|
|
if (triggerRef.value && isElement2(triggerRef.value)) {
|
|
const el = triggerRef.value;
|
|
TRIGGER_ELE_EVENTS.forEach((eventName) => {
|
|
const handler = props2[eventName];
|
|
if (handler) {
|
|
el.removeEventListener(eventName.slice(2).toLowerCase(), handler);
|
|
}
|
|
});
|
|
triggerRef.value = void 0;
|
|
}
|
|
});
|
|
expose({
|
|
triggerRef
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return !_ctx.virtualTriggering ? (openBlock(), createBlock(unref(OnlyChild), mergeProps({ key: 0 }, _ctx.$attrs, {
|
|
"aria-controls": unref(ariaControls),
|
|
"aria-describedby": unref(ariaDescribedby),
|
|
"aria-expanded": unref(ariaExpanded),
|
|
"aria-haspopup": unref(ariaHaspopup)
|
|
}), {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 16, ["aria-controls", "aria-describedby", "aria-expanded", "aria-haspopup"])) : createCommentVNode("v-if", true);
|
|
};
|
|
}
|
|
});
|
|
var ElPopperTrigger = _export_sfc(_sfc_main9, [["__file", "trigger.vue"]]);
|
|
|
|
// node_modules/element-plus/es/constants/aria.mjs
|
|
var EVENT_CODE = {
|
|
tab: "Tab",
|
|
enter: "Enter",
|
|
space: "Space",
|
|
left: "ArrowLeft",
|
|
up: "ArrowUp",
|
|
right: "ArrowRight",
|
|
down: "ArrowDown",
|
|
esc: "Escape",
|
|
delete: "Delete",
|
|
backspace: "Backspace",
|
|
numpadEnter: "NumpadEnter",
|
|
pageUp: "PageUp",
|
|
pageDown: "PageDown",
|
|
home: "Home",
|
|
end: "End"
|
|
};
|
|
|
|
// node_modules/element-plus/es/hooks/use-escape-keydown/index.mjs
|
|
var registeredEscapeHandlers = [];
|
|
var cachedHandler = (event) => {
|
|
if (event.code === EVENT_CODE.esc) {
|
|
registeredEscapeHandlers.forEach((registeredHandler) => registeredHandler(event));
|
|
}
|
|
};
|
|
var useEscapeKeydown = (handler) => {
|
|
onMounted(() => {
|
|
if (registeredEscapeHandlers.length === 0) {
|
|
document.addEventListener("keydown", cachedHandler);
|
|
}
|
|
if (isClient)
|
|
registeredEscapeHandlers.push(handler);
|
|
});
|
|
onBeforeUnmount(() => {
|
|
registeredEscapeHandlers = registeredEscapeHandlers.filter((registeredHandler) => registeredHandler !== handler);
|
|
if (registeredEscapeHandlers.length === 0) {
|
|
if (isClient)
|
|
document.removeEventListener("keydown", cachedHandler);
|
|
}
|
|
});
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/popper/src/arrow.mjs
|
|
var popperArrowProps = buildProps({
|
|
arrowOffset: {
|
|
type: Number,
|
|
default: 5
|
|
}
|
|
});
|
|
var usePopperArrowProps = popperArrowProps;
|
|
|
|
// node_modules/@popperjs/core/dist/index.mjs
|
|
var E = "top";
|
|
var R = "bottom";
|
|
var W = "right";
|
|
var P = "left";
|
|
var me = "auto";
|
|
var G = [E, R, W, P];
|
|
var U = "start";
|
|
var J = "end";
|
|
var Xe = "clippingParents";
|
|
var je = "viewport";
|
|
var K = "popper";
|
|
var Ye = "reference";
|
|
var De = G.reduce(function(t, e) {
|
|
return t.concat([e + "-" + U, e + "-" + J]);
|
|
}, []);
|
|
var Ee = [].concat(G, [me]).reduce(function(t, e) {
|
|
return t.concat([e, e + "-" + U, e + "-" + J]);
|
|
}, []);
|
|
var Ge = "beforeRead";
|
|
var Je = "read";
|
|
var Ke = "afterRead";
|
|
var Qe = "beforeMain";
|
|
var Ze = "main";
|
|
var et = "afterMain";
|
|
var tt = "beforeWrite";
|
|
var nt = "write";
|
|
var rt = "afterWrite";
|
|
var ot = [Ge, Je, Ke, Qe, Ze, et, tt, nt, rt];
|
|
function C(t) {
|
|
return t ? (t.nodeName || "").toLowerCase() : null;
|
|
}
|
|
function H(t) {
|
|
if (t == null)
|
|
return window;
|
|
if (t.toString() !== "[object Window]") {
|
|
var e = t.ownerDocument;
|
|
return e && e.defaultView || window;
|
|
}
|
|
return t;
|
|
}
|
|
function Q(t) {
|
|
var e = H(t).Element;
|
|
return t instanceof e || t instanceof Element;
|
|
}
|
|
function B(t) {
|
|
var e = H(t).HTMLElement;
|
|
return t instanceof e || t instanceof HTMLElement;
|
|
}
|
|
function Pe(t) {
|
|
if (typeof ShadowRoot == "undefined")
|
|
return false;
|
|
var e = H(t).ShadowRoot;
|
|
return t instanceof e || t instanceof ShadowRoot;
|
|
}
|
|
function Mt(t) {
|
|
var e = t.state;
|
|
Object.keys(e.elements).forEach(function(n) {
|
|
var r = e.styles[n] || {}, o2 = e.attributes[n] || {}, i = e.elements[n];
|
|
!B(i) || !C(i) || (Object.assign(i.style, r), Object.keys(o2).forEach(function(a2) {
|
|
var s2 = o2[a2];
|
|
s2 === false ? i.removeAttribute(a2) : i.setAttribute(a2, s2 === true ? "" : s2);
|
|
}));
|
|
});
|
|
}
|
|
function Rt(t) {
|
|
var e = t.state, n = { popper: { position: e.options.strategy, left: "0", top: "0", margin: "0" }, arrow: { position: "absolute" }, reference: {} };
|
|
return Object.assign(e.elements.popper.style, n.popper), e.styles = n, e.elements.arrow && Object.assign(e.elements.arrow.style, n.arrow), function() {
|
|
Object.keys(e.elements).forEach(function(r) {
|
|
var o2 = e.elements[r], i = e.attributes[r] || {}, a2 = Object.keys(e.styles.hasOwnProperty(r) ? e.styles[r] : n[r]), s2 = a2.reduce(function(f2, c2) {
|
|
return f2[c2] = "", f2;
|
|
}, {});
|
|
!B(o2) || !C(o2) || (Object.assign(o2.style, s2), Object.keys(i).forEach(function(f2) {
|
|
o2.removeAttribute(f2);
|
|
}));
|
|
});
|
|
};
|
|
}
|
|
var Ae = { name: "applyStyles", enabled: true, phase: "write", fn: Mt, effect: Rt, requires: ["computeStyles"] };
|
|
function q(t) {
|
|
return t.split("-")[0];
|
|
}
|
|
var X = Math.max;
|
|
var ve = Math.min;
|
|
var Z = Math.round;
|
|
function ee(t, e) {
|
|
e === void 0 && (e = false);
|
|
var n = t.getBoundingClientRect(), r = 1, o2 = 1;
|
|
if (B(t) && e) {
|
|
var i = t.offsetHeight, a2 = t.offsetWidth;
|
|
a2 > 0 && (r = Z(n.width) / a2 || 1), i > 0 && (o2 = Z(n.height) / i || 1);
|
|
}
|
|
return { width: n.width / r, height: n.height / o2, top: n.top / o2, right: n.right / r, bottom: n.bottom / o2, left: n.left / r, x: n.left / r, y: n.top / o2 };
|
|
}
|
|
function ke(t) {
|
|
var e = ee(t), n = t.offsetWidth, r = t.offsetHeight;
|
|
return Math.abs(e.width - n) <= 1 && (n = e.width), Math.abs(e.height - r) <= 1 && (r = e.height), { x: t.offsetLeft, y: t.offsetTop, width: n, height: r };
|
|
}
|
|
function it(t, e) {
|
|
var n = e.getRootNode && e.getRootNode();
|
|
if (t.contains(e))
|
|
return true;
|
|
if (n && Pe(n)) {
|
|
var r = e;
|
|
do {
|
|
if (r && t.isSameNode(r))
|
|
return true;
|
|
r = r.parentNode || r.host;
|
|
} while (r);
|
|
}
|
|
return false;
|
|
}
|
|
function N(t) {
|
|
return H(t).getComputedStyle(t);
|
|
}
|
|
function Wt(t) {
|
|
return ["table", "td", "th"].indexOf(C(t)) >= 0;
|
|
}
|
|
function I(t) {
|
|
return ((Q(t) ? t.ownerDocument : t.document) || window.document).documentElement;
|
|
}
|
|
function ge(t) {
|
|
return C(t) === "html" ? t : t.assignedSlot || t.parentNode || (Pe(t) ? t.host : null) || I(t);
|
|
}
|
|
function at2(t) {
|
|
return !B(t) || N(t).position === "fixed" ? null : t.offsetParent;
|
|
}
|
|
function Bt(t) {
|
|
var e = navigator.userAgent.toLowerCase().indexOf("firefox") !== -1, n = navigator.userAgent.indexOf("Trident") !== -1;
|
|
if (n && B(t)) {
|
|
var r = N(t);
|
|
if (r.position === "fixed")
|
|
return null;
|
|
}
|
|
var o2 = ge(t);
|
|
for (Pe(o2) && (o2 = o2.host); B(o2) && ["html", "body"].indexOf(C(o2)) < 0; ) {
|
|
var i = N(o2);
|
|
if (i.transform !== "none" || i.perspective !== "none" || i.contain === "paint" || ["transform", "perspective"].indexOf(i.willChange) !== -1 || e && i.willChange === "filter" || e && i.filter && i.filter !== "none")
|
|
return o2;
|
|
o2 = o2.parentNode;
|
|
}
|
|
return null;
|
|
}
|
|
function se(t) {
|
|
for (var e = H(t), n = at2(t); n && Wt(n) && N(n).position === "static"; )
|
|
n = at2(n);
|
|
return n && (C(n) === "html" || C(n) === "body" && N(n).position === "static") ? e : n || Bt(t) || e;
|
|
}
|
|
function Le(t) {
|
|
return ["top", "bottom"].indexOf(t) >= 0 ? "x" : "y";
|
|
}
|
|
function fe(t, e, n) {
|
|
return X(t, ve(e, n));
|
|
}
|
|
function St(t, e, n) {
|
|
var r = fe(t, e, n);
|
|
return r > n ? n : r;
|
|
}
|
|
function st() {
|
|
return { top: 0, right: 0, bottom: 0, left: 0 };
|
|
}
|
|
function ft(t) {
|
|
return Object.assign({}, st(), t);
|
|
}
|
|
function ct(t, e) {
|
|
return e.reduce(function(n, r) {
|
|
return n[r] = t, n;
|
|
}, {});
|
|
}
|
|
var Tt = function(t, e) {
|
|
return t = typeof t == "function" ? t(Object.assign({}, e.rects, { placement: e.placement })) : t, ft(typeof t != "number" ? t : ct(t, G));
|
|
};
|
|
function Ht(t) {
|
|
var e, n = t.state, r = t.name, o2 = t.options, i = n.elements.arrow, a2 = n.modifiersData.popperOffsets, s2 = q(n.placement), f2 = Le(s2), c2 = [P, W].indexOf(s2) >= 0, u2 = c2 ? "height" : "width";
|
|
if (!(!i || !a2)) {
|
|
var m2 = Tt(o2.padding, n), v2 = ke(i), l2 = f2 === "y" ? E : P, h3 = f2 === "y" ? R : W, p2 = n.rects.reference[u2] + n.rects.reference[f2] - a2[f2] - n.rects.popper[u2], g = a2[f2] - n.rects.reference[f2], x2 = se(i), y = x2 ? f2 === "y" ? x2.clientHeight || 0 : x2.clientWidth || 0 : 0, $ = p2 / 2 - g / 2, d2 = m2[l2], b2 = y - v2[u2] - m2[h3], w2 = y / 2 - v2[u2] / 2 + $, O2 = fe(d2, w2, b2), j = f2;
|
|
n.modifiersData[r] = (e = {}, e[j] = O2, e.centerOffset = O2 - w2, e);
|
|
}
|
|
}
|
|
function Ct(t) {
|
|
var e = t.state, n = t.options, r = n.element, o2 = r === void 0 ? "[data-popper-arrow]" : r;
|
|
o2 != null && (typeof o2 == "string" && (o2 = e.elements.popper.querySelector(o2), !o2) || !it(e.elements.popper, o2) || (e.elements.arrow = o2));
|
|
}
|
|
var pt = { name: "arrow", enabled: true, phase: "main", fn: Ht, effect: Ct, requires: ["popperOffsets"], requiresIfExists: ["preventOverflow"] };
|
|
function te(t) {
|
|
return t.split("-")[1];
|
|
}
|
|
var qt = { top: "auto", right: "auto", bottom: "auto", left: "auto" };
|
|
function Vt(t) {
|
|
var e = t.x, n = t.y, r = window, o2 = r.devicePixelRatio || 1;
|
|
return { x: Z(e * o2) / o2 || 0, y: Z(n * o2) / o2 || 0 };
|
|
}
|
|
function ut(t) {
|
|
var e, n = t.popper, r = t.popperRect, o2 = t.placement, i = t.variation, a2 = t.offsets, s2 = t.position, f2 = t.gpuAcceleration, c2 = t.adaptive, u2 = t.roundOffsets, m2 = t.isFixed, v2 = a2.x, l2 = v2 === void 0 ? 0 : v2, h3 = a2.y, p2 = h3 === void 0 ? 0 : h3, g = typeof u2 == "function" ? u2({ x: l2, y: p2 }) : { x: l2, y: p2 };
|
|
l2 = g.x, p2 = g.y;
|
|
var x2 = a2.hasOwnProperty("x"), y = a2.hasOwnProperty("y"), $ = P, d2 = E, b2 = window;
|
|
if (c2) {
|
|
var w2 = se(n), O2 = "clientHeight", j = "clientWidth";
|
|
if (w2 === H(n) && (w2 = I(n), N(w2).position !== "static" && s2 === "absolute" && (O2 = "scrollHeight", j = "scrollWidth")), w2 = w2, o2 === E || (o2 === P || o2 === W) && i === J) {
|
|
d2 = R;
|
|
var A2 = m2 && w2 === b2 && b2.visualViewport ? b2.visualViewport.height : w2[O2];
|
|
p2 -= A2 - r.height, p2 *= f2 ? 1 : -1;
|
|
}
|
|
if (o2 === P || (o2 === E || o2 === R) && i === J) {
|
|
$ = W;
|
|
var k = m2 && w2 === b2 && b2.visualViewport ? b2.visualViewport.width : w2[j];
|
|
l2 -= k - r.width, l2 *= f2 ? 1 : -1;
|
|
}
|
|
}
|
|
var D2 = Object.assign({ position: s2 }, c2 && qt), S2 = u2 === true ? Vt({ x: l2, y: p2 }) : { x: l2, y: p2 };
|
|
if (l2 = S2.x, p2 = S2.y, f2) {
|
|
var L;
|
|
return Object.assign({}, D2, (L = {}, L[d2] = y ? "0" : "", L[$] = x2 ? "0" : "", L.transform = (b2.devicePixelRatio || 1) <= 1 ? "translate(" + l2 + "px, " + p2 + "px)" : "translate3d(" + l2 + "px, " + p2 + "px, 0)", L));
|
|
}
|
|
return Object.assign({}, D2, (e = {}, e[d2] = y ? p2 + "px" : "", e[$] = x2 ? l2 + "px" : "", e.transform = "", e));
|
|
}
|
|
function Nt(t) {
|
|
var e = t.state, n = t.options, r = n.gpuAcceleration, o2 = r === void 0 ? true : r, i = n.adaptive, a2 = i === void 0 ? true : i, s2 = n.roundOffsets, f2 = s2 === void 0 ? true : s2, c2 = { placement: q(e.placement), variation: te(e.placement), popper: e.elements.popper, popperRect: e.rects.popper, gpuAcceleration: o2, isFixed: e.options.strategy === "fixed" };
|
|
e.modifiersData.popperOffsets != null && (e.styles.popper = Object.assign({}, e.styles.popper, ut(Object.assign({}, c2, { offsets: e.modifiersData.popperOffsets, position: e.options.strategy, adaptive: a2, roundOffsets: f2 })))), e.modifiersData.arrow != null && (e.styles.arrow = Object.assign({}, e.styles.arrow, ut(Object.assign({}, c2, { offsets: e.modifiersData.arrow, position: "absolute", adaptive: false, roundOffsets: f2 })))), e.attributes.popper = Object.assign({}, e.attributes.popper, { "data-popper-placement": e.placement });
|
|
}
|
|
var Me = { name: "computeStyles", enabled: true, phase: "beforeWrite", fn: Nt, data: {} };
|
|
var ye = { passive: true };
|
|
function It(t) {
|
|
var e = t.state, n = t.instance, r = t.options, o2 = r.scroll, i = o2 === void 0 ? true : o2, a2 = r.resize, s2 = a2 === void 0 ? true : a2, f2 = H(e.elements.popper), c2 = [].concat(e.scrollParents.reference, e.scrollParents.popper);
|
|
return i && c2.forEach(function(u2) {
|
|
u2.addEventListener("scroll", n.update, ye);
|
|
}), s2 && f2.addEventListener("resize", n.update, ye), function() {
|
|
i && c2.forEach(function(u2) {
|
|
u2.removeEventListener("scroll", n.update, ye);
|
|
}), s2 && f2.removeEventListener("resize", n.update, ye);
|
|
};
|
|
}
|
|
var Re = { name: "eventListeners", enabled: true, phase: "write", fn: function() {
|
|
}, effect: It, data: {} };
|
|
var _t = { left: "right", right: "left", bottom: "top", top: "bottom" };
|
|
function be(t) {
|
|
return t.replace(/left|right|bottom|top/g, function(e) {
|
|
return _t[e];
|
|
});
|
|
}
|
|
var zt = { start: "end", end: "start" };
|
|
function lt2(t) {
|
|
return t.replace(/start|end/g, function(e) {
|
|
return zt[e];
|
|
});
|
|
}
|
|
function We(t) {
|
|
var e = H(t), n = e.pageXOffset, r = e.pageYOffset;
|
|
return { scrollLeft: n, scrollTop: r };
|
|
}
|
|
function Be(t) {
|
|
return ee(I(t)).left + We(t).scrollLeft;
|
|
}
|
|
function Ft(t) {
|
|
var e = H(t), n = I(t), r = e.visualViewport, o2 = n.clientWidth, i = n.clientHeight, a2 = 0, s2 = 0;
|
|
return r && (o2 = r.width, i = r.height, /^((?!chrome|android).)*safari/i.test(navigator.userAgent) || (a2 = r.offsetLeft, s2 = r.offsetTop)), { width: o2, height: i, x: a2 + Be(t), y: s2 };
|
|
}
|
|
function Ut(t) {
|
|
var e, n = I(t), r = We(t), o2 = (e = t.ownerDocument) == null ? void 0 : e.body, i = X(n.scrollWidth, n.clientWidth, o2 ? o2.scrollWidth : 0, o2 ? o2.clientWidth : 0), a2 = X(n.scrollHeight, n.clientHeight, o2 ? o2.scrollHeight : 0, o2 ? o2.clientHeight : 0), s2 = -r.scrollLeft + Be(t), f2 = -r.scrollTop;
|
|
return N(o2 || n).direction === "rtl" && (s2 += X(n.clientWidth, o2 ? o2.clientWidth : 0) - i), { width: i, height: a2, x: s2, y: f2 };
|
|
}
|
|
function Se(t) {
|
|
var e = N(t), n = e.overflow, r = e.overflowX, o2 = e.overflowY;
|
|
return /auto|scroll|overlay|hidden/.test(n + o2 + r);
|
|
}
|
|
function dt(t) {
|
|
return ["html", "body", "#document"].indexOf(C(t)) >= 0 ? t.ownerDocument.body : B(t) && Se(t) ? t : dt(ge(t));
|
|
}
|
|
function ce(t, e) {
|
|
var n;
|
|
e === void 0 && (e = []);
|
|
var r = dt(t), o2 = r === ((n = t.ownerDocument) == null ? void 0 : n.body), i = H(r), a2 = o2 ? [i].concat(i.visualViewport || [], Se(r) ? r : []) : r, s2 = e.concat(a2);
|
|
return o2 ? s2 : s2.concat(ce(ge(a2)));
|
|
}
|
|
function Te(t) {
|
|
return Object.assign({}, t, { left: t.x, top: t.y, right: t.x + t.width, bottom: t.y + t.height });
|
|
}
|
|
function Xt(t) {
|
|
var e = ee(t);
|
|
return e.top = e.top + t.clientTop, e.left = e.left + t.clientLeft, e.bottom = e.top + t.clientHeight, e.right = e.left + t.clientWidth, e.width = t.clientWidth, e.height = t.clientHeight, e.x = e.left, e.y = e.top, e;
|
|
}
|
|
function ht(t, e) {
|
|
return e === je ? Te(Ft(t)) : Q(e) ? Xt(e) : Te(Ut(I(t)));
|
|
}
|
|
function Yt(t) {
|
|
var e = ce(ge(t)), n = ["absolute", "fixed"].indexOf(N(t).position) >= 0, r = n && B(t) ? se(t) : t;
|
|
return Q(r) ? e.filter(function(o2) {
|
|
return Q(o2) && it(o2, r) && C(o2) !== "body";
|
|
}) : [];
|
|
}
|
|
function Gt(t, e, n) {
|
|
var r = e === "clippingParents" ? Yt(t) : [].concat(e), o2 = [].concat(r, [n]), i = o2[0], a2 = o2.reduce(function(s2, f2) {
|
|
var c2 = ht(t, f2);
|
|
return s2.top = X(c2.top, s2.top), s2.right = ve(c2.right, s2.right), s2.bottom = ve(c2.bottom, s2.bottom), s2.left = X(c2.left, s2.left), s2;
|
|
}, ht(t, i));
|
|
return a2.width = a2.right - a2.left, a2.height = a2.bottom - a2.top, a2.x = a2.left, a2.y = a2.top, a2;
|
|
}
|
|
function mt(t) {
|
|
var e = t.reference, n = t.element, r = t.placement, o2 = r ? q(r) : null, i = r ? te(r) : null, a2 = e.x + e.width / 2 - n.width / 2, s2 = e.y + e.height / 2 - n.height / 2, f2;
|
|
switch (o2) {
|
|
case E:
|
|
f2 = { x: a2, y: e.y - n.height };
|
|
break;
|
|
case R:
|
|
f2 = { x: a2, y: e.y + e.height };
|
|
break;
|
|
case W:
|
|
f2 = { x: e.x + e.width, y: s2 };
|
|
break;
|
|
case P:
|
|
f2 = { x: e.x - n.width, y: s2 };
|
|
break;
|
|
default:
|
|
f2 = { x: e.x, y: e.y };
|
|
}
|
|
var c2 = o2 ? Le(o2) : null;
|
|
if (c2 != null) {
|
|
var u2 = c2 === "y" ? "height" : "width";
|
|
switch (i) {
|
|
case U:
|
|
f2[c2] = f2[c2] - (e[u2] / 2 - n[u2] / 2);
|
|
break;
|
|
case J:
|
|
f2[c2] = f2[c2] + (e[u2] / 2 - n[u2] / 2);
|
|
break;
|
|
}
|
|
}
|
|
return f2;
|
|
}
|
|
function ne(t, e) {
|
|
e === void 0 && (e = {});
|
|
var n = e, r = n.placement, o2 = r === void 0 ? t.placement : r, i = n.boundary, a2 = i === void 0 ? Xe : i, s2 = n.rootBoundary, f2 = s2 === void 0 ? je : s2, c2 = n.elementContext, u2 = c2 === void 0 ? K : c2, m2 = n.altBoundary, v2 = m2 === void 0 ? false : m2, l2 = n.padding, h3 = l2 === void 0 ? 0 : l2, p2 = ft(typeof h3 != "number" ? h3 : ct(h3, G)), g = u2 === K ? Ye : K, x2 = t.rects.popper, y = t.elements[v2 ? g : u2], $ = Gt(Q(y) ? y : y.contextElement || I(t.elements.popper), a2, f2), d2 = ee(t.elements.reference), b2 = mt({ reference: d2, element: x2, strategy: "absolute", placement: o2 }), w2 = Te(Object.assign({}, x2, b2)), O2 = u2 === K ? w2 : d2, j = { top: $.top - O2.top + p2.top, bottom: O2.bottom - $.bottom + p2.bottom, left: $.left - O2.left + p2.left, right: O2.right - $.right + p2.right }, A2 = t.modifiersData.offset;
|
|
if (u2 === K && A2) {
|
|
var k = A2[o2];
|
|
Object.keys(j).forEach(function(D2) {
|
|
var S2 = [W, R].indexOf(D2) >= 0 ? 1 : -1, L = [E, R].indexOf(D2) >= 0 ? "y" : "x";
|
|
j[D2] += k[L] * S2;
|
|
});
|
|
}
|
|
return j;
|
|
}
|
|
function Jt(t, e) {
|
|
e === void 0 && (e = {});
|
|
var n = e, r = n.placement, o2 = n.boundary, i = n.rootBoundary, a2 = n.padding, s2 = n.flipVariations, f2 = n.allowedAutoPlacements, c2 = f2 === void 0 ? Ee : f2, u2 = te(r), m2 = u2 ? s2 ? De : De.filter(function(h3) {
|
|
return te(h3) === u2;
|
|
}) : G, v2 = m2.filter(function(h3) {
|
|
return c2.indexOf(h3) >= 0;
|
|
});
|
|
v2.length === 0 && (v2 = m2);
|
|
var l2 = v2.reduce(function(h3, p2) {
|
|
return h3[p2] = ne(t, { placement: p2, boundary: o2, rootBoundary: i, padding: a2 })[q(p2)], h3;
|
|
}, {});
|
|
return Object.keys(l2).sort(function(h3, p2) {
|
|
return l2[h3] - l2[p2];
|
|
});
|
|
}
|
|
function Kt(t) {
|
|
if (q(t) === me)
|
|
return [];
|
|
var e = be(t);
|
|
return [lt2(t), e, lt2(e)];
|
|
}
|
|
function Qt(t) {
|
|
var e = t.state, n = t.options, r = t.name;
|
|
if (!e.modifiersData[r]._skip) {
|
|
for (var o2 = n.mainAxis, i = o2 === void 0 ? true : o2, a2 = n.altAxis, s2 = a2 === void 0 ? true : a2, f2 = n.fallbackPlacements, c2 = n.padding, u2 = n.boundary, m2 = n.rootBoundary, v2 = n.altBoundary, l2 = n.flipVariations, h3 = l2 === void 0 ? true : l2, p2 = n.allowedAutoPlacements, g = e.options.placement, x2 = q(g), y = x2 === g, $ = f2 || (y || !h3 ? [be(g)] : Kt(g)), d2 = [g].concat($).reduce(function(z, V) {
|
|
return z.concat(q(V) === me ? Jt(e, { placement: V, boundary: u2, rootBoundary: m2, padding: c2, flipVariations: h3, allowedAutoPlacements: p2 }) : V);
|
|
}, []), b2 = e.rects.reference, w2 = e.rects.popper, O2 = new Map(), j = true, A2 = d2[0], k = 0; k < d2.length; k++) {
|
|
var D2 = d2[k], S2 = q(D2), L = te(D2) === U, re = [E, R].indexOf(S2) >= 0, oe = re ? "width" : "height", M2 = ne(e, { placement: D2, boundary: u2, rootBoundary: m2, altBoundary: v2, padding: c2 }), T2 = re ? L ? W : P : L ? R : E;
|
|
b2[oe] > w2[oe] && (T2 = be(T2));
|
|
var pe = be(T2), _2 = [];
|
|
if (i && _2.push(M2[S2] <= 0), s2 && _2.push(M2[T2] <= 0, M2[pe] <= 0), _2.every(function(z) {
|
|
return z;
|
|
})) {
|
|
A2 = D2, j = false;
|
|
break;
|
|
}
|
|
O2.set(D2, _2);
|
|
}
|
|
if (j)
|
|
for (var ue = h3 ? 3 : 1, xe = function(z) {
|
|
var V = d2.find(function(de) {
|
|
var ae = O2.get(de);
|
|
if (ae)
|
|
return ae.slice(0, z).every(function(Y2) {
|
|
return Y2;
|
|
});
|
|
});
|
|
if (V)
|
|
return A2 = V, "break";
|
|
}, ie = ue; ie > 0; ie--) {
|
|
var le = xe(ie);
|
|
if (le === "break")
|
|
break;
|
|
}
|
|
e.placement !== A2 && (e.modifiersData[r]._skip = true, e.placement = A2, e.reset = true);
|
|
}
|
|
}
|
|
var vt = { name: "flip", enabled: true, phase: "main", fn: Qt, requiresIfExists: ["offset"], data: { _skip: false } };
|
|
function gt2(t, e, n) {
|
|
return n === void 0 && (n = { x: 0, y: 0 }), { top: t.top - e.height - n.y, right: t.right - e.width + n.x, bottom: t.bottom - e.height + n.y, left: t.left - e.width - n.x };
|
|
}
|
|
function yt(t) {
|
|
return [E, W, R, P].some(function(e) {
|
|
return t[e] >= 0;
|
|
});
|
|
}
|
|
function Zt(t) {
|
|
var e = t.state, n = t.name, r = e.rects.reference, o2 = e.rects.popper, i = e.modifiersData.preventOverflow, a2 = ne(e, { elementContext: "reference" }), s2 = ne(e, { altBoundary: true }), f2 = gt2(a2, r), c2 = gt2(s2, o2, i), u2 = yt(f2), m2 = yt(c2);
|
|
e.modifiersData[n] = { referenceClippingOffsets: f2, popperEscapeOffsets: c2, isReferenceHidden: u2, hasPopperEscaped: m2 }, e.attributes.popper = Object.assign({}, e.attributes.popper, { "data-popper-reference-hidden": u2, "data-popper-escaped": m2 });
|
|
}
|
|
var bt = { name: "hide", enabled: true, phase: "main", requiresIfExists: ["preventOverflow"], fn: Zt };
|
|
function en(t, e, n) {
|
|
var r = q(t), o2 = [P, E].indexOf(r) >= 0 ? -1 : 1, i = typeof n == "function" ? n(Object.assign({}, e, { placement: t })) : n, a2 = i[0], s2 = i[1];
|
|
return a2 = a2 || 0, s2 = (s2 || 0) * o2, [P, W].indexOf(r) >= 0 ? { x: s2, y: a2 } : { x: a2, y: s2 };
|
|
}
|
|
function tn(t) {
|
|
var e = t.state, n = t.options, r = t.name, o2 = n.offset, i = o2 === void 0 ? [0, 0] : o2, a2 = Ee.reduce(function(u2, m2) {
|
|
return u2[m2] = en(m2, e.rects, i), u2;
|
|
}, {}), s2 = a2[e.placement], f2 = s2.x, c2 = s2.y;
|
|
e.modifiersData.popperOffsets != null && (e.modifiersData.popperOffsets.x += f2, e.modifiersData.popperOffsets.y += c2), e.modifiersData[r] = a2;
|
|
}
|
|
var wt = { name: "offset", enabled: true, phase: "main", requires: ["popperOffsets"], fn: tn };
|
|
function nn(t) {
|
|
var e = t.state, n = t.name;
|
|
e.modifiersData[n] = mt({ reference: e.rects.reference, element: e.rects.popper, strategy: "absolute", placement: e.placement });
|
|
}
|
|
var He = { name: "popperOffsets", enabled: true, phase: "read", fn: nn, data: {} };
|
|
function rn(t) {
|
|
return t === "x" ? "y" : "x";
|
|
}
|
|
function on(t) {
|
|
var e = t.state, n = t.options, r = t.name, o2 = n.mainAxis, i = o2 === void 0 ? true : o2, a2 = n.altAxis, s2 = a2 === void 0 ? false : a2, f2 = n.boundary, c2 = n.rootBoundary, u2 = n.altBoundary, m2 = n.padding, v2 = n.tether, l2 = v2 === void 0 ? true : v2, h3 = n.tetherOffset, p2 = h3 === void 0 ? 0 : h3, g = ne(e, { boundary: f2, rootBoundary: c2, padding: m2, altBoundary: u2 }), x2 = q(e.placement), y = te(e.placement), $ = !y, d2 = Le(x2), b2 = rn(d2), w2 = e.modifiersData.popperOffsets, O2 = e.rects.reference, j = e.rects.popper, A2 = typeof p2 == "function" ? p2(Object.assign({}, e.rects, { placement: e.placement })) : p2, k = typeof A2 == "number" ? { mainAxis: A2, altAxis: A2 } : Object.assign({ mainAxis: 0, altAxis: 0 }, A2), D2 = e.modifiersData.offset ? e.modifiersData.offset[e.placement] : null, S2 = { x: 0, y: 0 };
|
|
if (w2) {
|
|
if (i) {
|
|
var L, re = d2 === "y" ? E : P, oe = d2 === "y" ? R : W, M2 = d2 === "y" ? "height" : "width", T2 = w2[d2], pe = T2 + g[re], _2 = T2 - g[oe], ue = l2 ? -j[M2] / 2 : 0, xe = y === U ? O2[M2] : j[M2], ie = y === U ? -j[M2] : -O2[M2], le = e.elements.arrow, z = l2 && le ? ke(le) : { width: 0, height: 0 }, V = e.modifiersData["arrow#persistent"] ? e.modifiersData["arrow#persistent"].padding : st(), de = V[re], ae = V[oe], Y2 = fe(0, O2[M2], z[M2]), jt = $ ? O2[M2] / 2 - ue - Y2 - de - k.mainAxis : xe - Y2 - de - k.mainAxis, Dt = $ ? -O2[M2] / 2 + ue + Y2 + ae + k.mainAxis : ie + Y2 + ae + k.mainAxis, Oe = e.elements.arrow && se(e.elements.arrow), Et = Oe ? d2 === "y" ? Oe.clientTop || 0 : Oe.clientLeft || 0 : 0, Ce = (L = D2 == null ? void 0 : D2[d2]) != null ? L : 0, Pt = T2 + jt - Ce - Et, At = T2 + Dt - Ce, qe = fe(l2 ? ve(pe, Pt) : pe, T2, l2 ? X(_2, At) : _2);
|
|
w2[d2] = qe, S2[d2] = qe - T2;
|
|
}
|
|
if (s2) {
|
|
var Ve, kt = d2 === "x" ? E : P, Lt = d2 === "x" ? R : W, F2 = w2[b2], he = b2 === "y" ? "height" : "width", Ne = F2 + g[kt], Ie = F2 - g[Lt], $e = [E, P].indexOf(x2) !== -1, _e = (Ve = D2 == null ? void 0 : D2[b2]) != null ? Ve : 0, ze = $e ? Ne : F2 - O2[he] - j[he] - _e + k.altAxis, Fe = $e ? F2 + O2[he] + j[he] - _e - k.altAxis : Ie, Ue = l2 && $e ? St(ze, F2, Fe) : fe(l2 ? ze : Ne, F2, l2 ? Fe : Ie);
|
|
w2[b2] = Ue, S2[b2] = Ue - F2;
|
|
}
|
|
e.modifiersData[r] = S2;
|
|
}
|
|
}
|
|
var xt = { name: "preventOverflow", enabled: true, phase: "main", fn: on, requiresIfExists: ["offset"] };
|
|
function an(t) {
|
|
return { scrollLeft: t.scrollLeft, scrollTop: t.scrollTop };
|
|
}
|
|
function sn(t) {
|
|
return t === H(t) || !B(t) ? We(t) : an(t);
|
|
}
|
|
function fn(t) {
|
|
var e = t.getBoundingClientRect(), n = Z(e.width) / t.offsetWidth || 1, r = Z(e.height) / t.offsetHeight || 1;
|
|
return n !== 1 || r !== 1;
|
|
}
|
|
function cn(t, e, n) {
|
|
n === void 0 && (n = false);
|
|
var r = B(e), o2 = B(e) && fn(e), i = I(e), a2 = ee(t, o2), s2 = { scrollLeft: 0, scrollTop: 0 }, f2 = { x: 0, y: 0 };
|
|
return (r || !r && !n) && ((C(e) !== "body" || Se(i)) && (s2 = sn(e)), B(e) ? (f2 = ee(e, true), f2.x += e.clientLeft, f2.y += e.clientTop) : i && (f2.x = Be(i))), { x: a2.left + s2.scrollLeft - f2.x, y: a2.top + s2.scrollTop - f2.y, width: a2.width, height: a2.height };
|
|
}
|
|
function pn(t) {
|
|
var e = new Map(), n = new Set(), r = [];
|
|
t.forEach(function(i) {
|
|
e.set(i.name, i);
|
|
});
|
|
function o2(i) {
|
|
n.add(i.name);
|
|
var a2 = [].concat(i.requires || [], i.requiresIfExists || []);
|
|
a2.forEach(function(s2) {
|
|
if (!n.has(s2)) {
|
|
var f2 = e.get(s2);
|
|
f2 && o2(f2);
|
|
}
|
|
}), r.push(i);
|
|
}
|
|
return t.forEach(function(i) {
|
|
n.has(i.name) || o2(i);
|
|
}), r;
|
|
}
|
|
function un(t) {
|
|
var e = pn(t);
|
|
return ot.reduce(function(n, r) {
|
|
return n.concat(e.filter(function(o2) {
|
|
return o2.phase === r;
|
|
}));
|
|
}, []);
|
|
}
|
|
function ln(t) {
|
|
var e;
|
|
return function() {
|
|
return e || (e = new Promise(function(n) {
|
|
Promise.resolve().then(function() {
|
|
e = void 0, n(t());
|
|
});
|
|
})), e;
|
|
};
|
|
}
|
|
function dn(t) {
|
|
var e = t.reduce(function(n, r) {
|
|
var o2 = n[r.name];
|
|
return n[r.name] = o2 ? Object.assign({}, o2, r, { options: Object.assign({}, o2.options, r.options), data: Object.assign({}, o2.data, r.data) }) : r, n;
|
|
}, {});
|
|
return Object.keys(e).map(function(n) {
|
|
return e[n];
|
|
});
|
|
}
|
|
var Ot = { placement: "bottom", modifiers: [], strategy: "absolute" };
|
|
function $t() {
|
|
for (var t = arguments.length, e = new Array(t), n = 0; n < t; n++)
|
|
e[n] = arguments[n];
|
|
return !e.some(function(r) {
|
|
return !(r && typeof r.getBoundingClientRect == "function");
|
|
});
|
|
}
|
|
function we(t) {
|
|
t === void 0 && (t = {});
|
|
var e = t, n = e.defaultModifiers, r = n === void 0 ? [] : n, o2 = e.defaultOptions, i = o2 === void 0 ? Ot : o2;
|
|
return function(a2, s2, f2) {
|
|
f2 === void 0 && (f2 = i);
|
|
var c2 = { placement: "bottom", orderedModifiers: [], options: Object.assign({}, Ot, i), modifiersData: {}, elements: { reference: a2, popper: s2 }, attributes: {}, styles: {} }, u2 = [], m2 = false, v2 = { state: c2, setOptions: function(p2) {
|
|
var g = typeof p2 == "function" ? p2(c2.options) : p2;
|
|
h3(), c2.options = Object.assign({}, i, c2.options, g), c2.scrollParents = { reference: Q(a2) ? ce(a2) : a2.contextElement ? ce(a2.contextElement) : [], popper: ce(s2) };
|
|
var x2 = un(dn([].concat(r, c2.options.modifiers)));
|
|
return c2.orderedModifiers = x2.filter(function(y) {
|
|
return y.enabled;
|
|
}), l2(), v2.update();
|
|
}, forceUpdate: function() {
|
|
if (!m2) {
|
|
var p2 = c2.elements, g = p2.reference, x2 = p2.popper;
|
|
if ($t(g, x2)) {
|
|
c2.rects = { reference: cn(g, se(x2), c2.options.strategy === "fixed"), popper: ke(x2) }, c2.reset = false, c2.placement = c2.options.placement, c2.orderedModifiers.forEach(function(j) {
|
|
return c2.modifiersData[j.name] = Object.assign({}, j.data);
|
|
});
|
|
for (var y = 0; y < c2.orderedModifiers.length; y++) {
|
|
if (c2.reset === true) {
|
|
c2.reset = false, y = -1;
|
|
continue;
|
|
}
|
|
var $ = c2.orderedModifiers[y], d2 = $.fn, b2 = $.options, w2 = b2 === void 0 ? {} : b2, O2 = $.name;
|
|
typeof d2 == "function" && (c2 = d2({ state: c2, options: w2, name: O2, instance: v2 }) || c2);
|
|
}
|
|
}
|
|
}
|
|
}, update: ln(function() {
|
|
return new Promise(function(p2) {
|
|
v2.forceUpdate(), p2(c2);
|
|
});
|
|
}), destroy: function() {
|
|
h3(), m2 = true;
|
|
} };
|
|
if (!$t(a2, s2))
|
|
return v2;
|
|
v2.setOptions(f2).then(function(p2) {
|
|
!m2 && f2.onFirstUpdate && f2.onFirstUpdate(p2);
|
|
});
|
|
function l2() {
|
|
c2.orderedModifiers.forEach(function(p2) {
|
|
var g = p2.name, x2 = p2.options, y = x2 === void 0 ? {} : x2, $ = p2.effect;
|
|
if (typeof $ == "function") {
|
|
var d2 = $({ state: c2, name: g, instance: v2, options: y }), b2 = function() {
|
|
};
|
|
u2.push(d2 || b2);
|
|
}
|
|
});
|
|
}
|
|
function h3() {
|
|
u2.forEach(function(p2) {
|
|
return p2();
|
|
}), u2 = [];
|
|
}
|
|
return v2;
|
|
};
|
|
}
|
|
var hn = we();
|
|
var mn = [Re, He, Me, Ae];
|
|
var vn = we({ defaultModifiers: mn });
|
|
var gn = [Re, He, Me, Ae, wt, vt, xt, pt, bt];
|
|
var yn = we({ defaultModifiers: gn });
|
|
|
|
// node_modules/element-plus/es/components/popper/src/content.mjs
|
|
var POSITIONING_STRATEGIES = ["fixed", "absolute"];
|
|
var popperCoreConfigProps = buildProps({
|
|
boundariesPadding: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
fallbackPlacements: {
|
|
type: definePropType(Array),
|
|
default: void 0
|
|
},
|
|
gpuAcceleration: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
offset: {
|
|
type: Number,
|
|
default: 12
|
|
},
|
|
placement: {
|
|
type: String,
|
|
values: Ee,
|
|
default: "bottom"
|
|
},
|
|
popperOptions: {
|
|
type: definePropType(Object),
|
|
default: () => ({})
|
|
},
|
|
strategy: {
|
|
type: String,
|
|
values: POSITIONING_STRATEGIES,
|
|
default: "absolute"
|
|
}
|
|
});
|
|
var popperContentProps = buildProps({
|
|
...popperCoreConfigProps,
|
|
...popperArrowProps,
|
|
id: String,
|
|
style: {
|
|
type: definePropType([String, Array, Object])
|
|
},
|
|
className: {
|
|
type: definePropType([String, Array, Object])
|
|
},
|
|
effect: {
|
|
type: definePropType(String),
|
|
default: "dark"
|
|
},
|
|
visible: Boolean,
|
|
enterable: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
pure: Boolean,
|
|
focusOnShow: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
trapping: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
popperClass: {
|
|
type: definePropType([String, Array, Object])
|
|
},
|
|
popperStyle: {
|
|
type: definePropType([String, Array, Object])
|
|
},
|
|
referenceEl: {
|
|
type: definePropType(Object)
|
|
},
|
|
triggerTargetEl: {
|
|
type: definePropType(Object)
|
|
},
|
|
stopPopperMouseEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
virtualTriggering: Boolean,
|
|
zIndex: Number,
|
|
...useAriaProps(["ariaLabel"])
|
|
});
|
|
var popperContentEmits = {
|
|
mouseenter: (evt) => evt instanceof MouseEvent,
|
|
mouseleave: (evt) => evt instanceof MouseEvent,
|
|
focus: () => true,
|
|
blur: () => true,
|
|
close: () => true
|
|
};
|
|
var usePopperCoreConfigProps = popperCoreConfigProps;
|
|
var usePopperContentProps = popperContentProps;
|
|
var usePopperContentEmits = popperContentEmits;
|
|
|
|
// node_modules/element-plus/es/hooks/use-popper/index.mjs
|
|
var usePopper = (referenceElementRef, popperElementRef, opts = {}) => {
|
|
const stateUpdater = {
|
|
name: "updateState",
|
|
enabled: true,
|
|
phase: "write",
|
|
fn: ({ state }) => {
|
|
const derivedState = deriveState(state);
|
|
Object.assign(states.value, derivedState);
|
|
},
|
|
requires: ["computeStyles"]
|
|
};
|
|
const options = computed(() => {
|
|
const { onFirstUpdate, placement, strategy, modifiers } = unref(opts);
|
|
return {
|
|
onFirstUpdate,
|
|
placement: placement || "bottom",
|
|
strategy: strategy || "absolute",
|
|
modifiers: [
|
|
...modifiers || [],
|
|
stateUpdater,
|
|
{ name: "applyStyles", enabled: false }
|
|
]
|
|
};
|
|
});
|
|
const instanceRef = shallowRef();
|
|
const states = ref({
|
|
styles: {
|
|
popper: {
|
|
position: unref(options).strategy,
|
|
left: "0",
|
|
top: "0"
|
|
},
|
|
arrow: {
|
|
position: "absolute"
|
|
}
|
|
},
|
|
attributes: {}
|
|
});
|
|
const destroy = () => {
|
|
if (!instanceRef.value)
|
|
return;
|
|
instanceRef.value.destroy();
|
|
instanceRef.value = void 0;
|
|
};
|
|
watch(options, (newOptions) => {
|
|
const instance = unref(instanceRef);
|
|
if (instance) {
|
|
instance.setOptions(newOptions);
|
|
}
|
|
}, {
|
|
deep: true
|
|
});
|
|
watch([referenceElementRef, popperElementRef], ([referenceElement, popperElement]) => {
|
|
destroy();
|
|
if (!referenceElement || !popperElement)
|
|
return;
|
|
instanceRef.value = yn(referenceElement, popperElement, unref(options));
|
|
});
|
|
onBeforeUnmount(() => {
|
|
destroy();
|
|
});
|
|
return {
|
|
state: computed(() => {
|
|
var _a2;
|
|
return { ...((_a2 = unref(instanceRef)) == null ? void 0 : _a2.state) || {} };
|
|
}),
|
|
styles: computed(() => unref(states).styles),
|
|
attributes: computed(() => unref(states).attributes),
|
|
update: () => {
|
|
var _a2;
|
|
return (_a2 = unref(instanceRef)) == null ? void 0 : _a2.update();
|
|
},
|
|
forceUpdate: () => {
|
|
var _a2;
|
|
return (_a2 = unref(instanceRef)) == null ? void 0 : _a2.forceUpdate();
|
|
},
|
|
instanceRef: computed(() => unref(instanceRef))
|
|
};
|
|
};
|
|
function deriveState(state) {
|
|
const elements = Object.keys(state.elements);
|
|
const styles = fromPairs_default(elements.map((element) => [element, state.styles[element] || {}]));
|
|
const attributes2 = fromPairs_default(elements.map((element) => [element, state.attributes[element]]));
|
|
return {
|
|
styles,
|
|
attributes: attributes2
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/focus-trap/src/tokens.mjs
|
|
var FOCUS_AFTER_TRAPPED = "focus-trap.focus-after-trapped";
|
|
var FOCUS_AFTER_RELEASED = "focus-trap.focus-after-released";
|
|
var FOCUSOUT_PREVENTED = "focus-trap.focusout-prevented";
|
|
var FOCUS_AFTER_TRAPPED_OPTS = {
|
|
cancelable: true,
|
|
bubbles: false
|
|
};
|
|
var FOCUSOUT_PREVENTED_OPTS = {
|
|
cancelable: true,
|
|
bubbles: false
|
|
};
|
|
var ON_TRAP_FOCUS_EVT = "focusAfterTrapped";
|
|
var ON_RELEASE_FOCUS_EVT = "focusAfterReleased";
|
|
var FOCUS_TRAP_INJECTION_KEY = Symbol("elFocusTrap");
|
|
|
|
// node_modules/element-plus/es/components/focus-trap/src/utils.mjs
|
|
var focusReason = ref();
|
|
var lastUserFocusTimestamp = ref(0);
|
|
var lastAutomatedFocusTimestamp = ref(0);
|
|
var focusReasonUserCount = 0;
|
|
var obtainAllFocusableElements2 = (element) => {
|
|
const nodes = [];
|
|
const walker = document.createTreeWalker(element, NodeFilter.SHOW_ELEMENT, {
|
|
acceptNode: (node) => {
|
|
const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
|
|
if (node.disabled || node.hidden || isHiddenInput)
|
|
return NodeFilter.FILTER_SKIP;
|
|
return node.tabIndex >= 0 || node === document.activeElement ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
|
|
}
|
|
});
|
|
while (walker.nextNode())
|
|
nodes.push(walker.currentNode);
|
|
return nodes;
|
|
};
|
|
var getVisibleElement = (elements, container) => {
|
|
for (const element of elements) {
|
|
if (!isHidden(element, container))
|
|
return element;
|
|
}
|
|
};
|
|
var isHidden = (element, container) => {
|
|
if (false)
|
|
return false;
|
|
if (getComputedStyle(element).visibility === "hidden")
|
|
return true;
|
|
while (element) {
|
|
if (container && element === container)
|
|
return false;
|
|
if (getComputedStyle(element).display === "none")
|
|
return true;
|
|
element = element.parentElement;
|
|
}
|
|
return false;
|
|
};
|
|
var getEdges = (container) => {
|
|
const focusable = obtainAllFocusableElements2(container);
|
|
const first = getVisibleElement(focusable, container);
|
|
const last2 = getVisibleElement(focusable.reverse(), container);
|
|
return [first, last2];
|
|
};
|
|
var isSelectable = (element) => {
|
|
return element instanceof HTMLInputElement && "select" in element;
|
|
};
|
|
var tryFocus = (element, shouldSelect) => {
|
|
if (element && element.focus) {
|
|
const prevFocusedElement = document.activeElement;
|
|
let cleanup = false;
|
|
if (isElement2(element) && !isFocusable(element) && !element.getAttribute("tabindex")) {
|
|
element.setAttribute("tabindex", "-1");
|
|
cleanup = true;
|
|
}
|
|
element.focus({ preventScroll: true });
|
|
lastAutomatedFocusTimestamp.value = window.performance.now();
|
|
if (element !== prevFocusedElement && isSelectable(element) && shouldSelect) {
|
|
element.select();
|
|
}
|
|
if (isElement2(element) && cleanup) {
|
|
element.removeAttribute("tabindex");
|
|
}
|
|
}
|
|
};
|
|
function removeFromStack(list, item) {
|
|
const copy = [...list];
|
|
const idx = list.indexOf(item);
|
|
if (idx !== -1) {
|
|
copy.splice(idx, 1);
|
|
}
|
|
return copy;
|
|
}
|
|
var createFocusableStack = () => {
|
|
let stack = [];
|
|
const push = (layer) => {
|
|
const currentLayer = stack[0];
|
|
if (currentLayer && layer !== currentLayer) {
|
|
currentLayer.pause();
|
|
}
|
|
stack = removeFromStack(stack, layer);
|
|
stack.unshift(layer);
|
|
};
|
|
const remove2 = (layer) => {
|
|
var _a2, _b;
|
|
stack = removeFromStack(stack, layer);
|
|
(_b = (_a2 = stack[0]) == null ? void 0 : _a2.resume) == null ? void 0 : _b.call(_a2);
|
|
};
|
|
return {
|
|
push,
|
|
remove: remove2
|
|
};
|
|
};
|
|
var focusFirstDescendant = (elements, shouldSelect = false) => {
|
|
const prevFocusedElement = document.activeElement;
|
|
for (const element of elements) {
|
|
tryFocus(element, shouldSelect);
|
|
if (document.activeElement !== prevFocusedElement)
|
|
return;
|
|
}
|
|
};
|
|
var focusableStack = createFocusableStack();
|
|
var isFocusCausedByUserEvent = () => {
|
|
return lastUserFocusTimestamp.value > lastAutomatedFocusTimestamp.value;
|
|
};
|
|
var notifyFocusReasonPointer = () => {
|
|
focusReason.value = "pointer";
|
|
lastUserFocusTimestamp.value = window.performance.now();
|
|
};
|
|
var notifyFocusReasonKeydown = () => {
|
|
focusReason.value = "keyboard";
|
|
lastUserFocusTimestamp.value = window.performance.now();
|
|
};
|
|
var useFocusReason = () => {
|
|
onMounted(() => {
|
|
if (focusReasonUserCount === 0) {
|
|
document.addEventListener("mousedown", notifyFocusReasonPointer);
|
|
document.addEventListener("touchstart", notifyFocusReasonPointer);
|
|
document.addEventListener("keydown", notifyFocusReasonKeydown);
|
|
}
|
|
focusReasonUserCount++;
|
|
});
|
|
onBeforeUnmount(() => {
|
|
focusReasonUserCount--;
|
|
if (focusReasonUserCount <= 0) {
|
|
document.removeEventListener("mousedown", notifyFocusReasonPointer);
|
|
document.removeEventListener("touchstart", notifyFocusReasonPointer);
|
|
document.removeEventListener("keydown", notifyFocusReasonKeydown);
|
|
}
|
|
});
|
|
return {
|
|
focusReason,
|
|
lastUserFocusTimestamp,
|
|
lastAutomatedFocusTimestamp
|
|
};
|
|
};
|
|
var createFocusOutPreventedEvent = (detail) => {
|
|
return new CustomEvent(FOCUSOUT_PREVENTED, {
|
|
...FOCUSOUT_PREVENTED_OPTS,
|
|
detail
|
|
});
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/focus-trap/src/focus-trap.mjs
|
|
var _sfc_main10 = defineComponent({
|
|
name: "ElFocusTrap",
|
|
inheritAttrs: false,
|
|
props: {
|
|
loop: Boolean,
|
|
trapped: Boolean,
|
|
focusTrapEl: Object,
|
|
focusStartEl: {
|
|
type: [Object, String],
|
|
default: "first"
|
|
}
|
|
},
|
|
emits: [
|
|
ON_TRAP_FOCUS_EVT,
|
|
ON_RELEASE_FOCUS_EVT,
|
|
"focusin",
|
|
"focusout",
|
|
"focusout-prevented",
|
|
"release-requested"
|
|
],
|
|
setup(props2, { emit }) {
|
|
const forwardRef = ref();
|
|
let lastFocusBeforeTrapped;
|
|
let lastFocusAfterTrapped;
|
|
const { focusReason: focusReason2 } = useFocusReason();
|
|
useEscapeKeydown((event) => {
|
|
if (props2.trapped && !focusLayer.paused) {
|
|
emit("release-requested", event);
|
|
}
|
|
});
|
|
const focusLayer = {
|
|
paused: false,
|
|
pause() {
|
|
this.paused = true;
|
|
},
|
|
resume() {
|
|
this.paused = false;
|
|
}
|
|
};
|
|
const onKeydown = (e) => {
|
|
if (!props2.loop && !props2.trapped)
|
|
return;
|
|
if (focusLayer.paused)
|
|
return;
|
|
const { code, altKey, ctrlKey, metaKey, currentTarget, shiftKey } = e;
|
|
const { loop } = props2;
|
|
const isTabbing = code === EVENT_CODE.tab && !altKey && !ctrlKey && !metaKey;
|
|
const currentFocusingEl = document.activeElement;
|
|
if (isTabbing && currentFocusingEl) {
|
|
const container = currentTarget;
|
|
const [first, last2] = getEdges(container);
|
|
const isTabbable = first && last2;
|
|
if (!isTabbable) {
|
|
if (currentFocusingEl === container) {
|
|
const focusoutPreventedEvent = createFocusOutPreventedEvent({
|
|
focusReason: focusReason2.value
|
|
});
|
|
emit("focusout-prevented", focusoutPreventedEvent);
|
|
if (!focusoutPreventedEvent.defaultPrevented) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
} else {
|
|
if (!shiftKey && currentFocusingEl === last2) {
|
|
const focusoutPreventedEvent = createFocusOutPreventedEvent({
|
|
focusReason: focusReason2.value
|
|
});
|
|
emit("focusout-prevented", focusoutPreventedEvent);
|
|
if (!focusoutPreventedEvent.defaultPrevented) {
|
|
e.preventDefault();
|
|
if (loop)
|
|
tryFocus(first, true);
|
|
}
|
|
} else if (shiftKey && [first, container].includes(currentFocusingEl)) {
|
|
const focusoutPreventedEvent = createFocusOutPreventedEvent({
|
|
focusReason: focusReason2.value
|
|
});
|
|
emit("focusout-prevented", focusoutPreventedEvent);
|
|
if (!focusoutPreventedEvent.defaultPrevented) {
|
|
e.preventDefault();
|
|
if (loop)
|
|
tryFocus(last2, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
provide(FOCUS_TRAP_INJECTION_KEY, {
|
|
focusTrapRef: forwardRef,
|
|
onKeydown
|
|
});
|
|
watch(() => props2.focusTrapEl, (focusTrapEl) => {
|
|
if (focusTrapEl) {
|
|
forwardRef.value = focusTrapEl;
|
|
}
|
|
}, { immediate: true });
|
|
watch([forwardRef], ([forwardRef2], [oldForwardRef]) => {
|
|
if (forwardRef2) {
|
|
forwardRef2.addEventListener("keydown", onKeydown);
|
|
forwardRef2.addEventListener("focusin", onFocusIn);
|
|
forwardRef2.addEventListener("focusout", onFocusOut);
|
|
}
|
|
if (oldForwardRef) {
|
|
oldForwardRef.removeEventListener("keydown", onKeydown);
|
|
oldForwardRef.removeEventListener("focusin", onFocusIn);
|
|
oldForwardRef.removeEventListener("focusout", onFocusOut);
|
|
}
|
|
});
|
|
const trapOnFocus = (e) => {
|
|
emit(ON_TRAP_FOCUS_EVT, e);
|
|
};
|
|
const releaseOnFocus = (e) => emit(ON_RELEASE_FOCUS_EVT, e);
|
|
const onFocusIn = (e) => {
|
|
const trapContainer = unref(forwardRef);
|
|
if (!trapContainer)
|
|
return;
|
|
const target2 = e.target;
|
|
const relatedTarget = e.relatedTarget;
|
|
const isFocusedInTrap = target2 && trapContainer.contains(target2);
|
|
if (!props2.trapped) {
|
|
const isPrevFocusedInTrap = relatedTarget && trapContainer.contains(relatedTarget);
|
|
if (!isPrevFocusedInTrap) {
|
|
lastFocusBeforeTrapped = relatedTarget;
|
|
}
|
|
}
|
|
if (isFocusedInTrap)
|
|
emit("focusin", e);
|
|
if (focusLayer.paused)
|
|
return;
|
|
if (props2.trapped) {
|
|
if (isFocusedInTrap) {
|
|
lastFocusAfterTrapped = target2;
|
|
} else {
|
|
tryFocus(lastFocusAfterTrapped, true);
|
|
}
|
|
}
|
|
};
|
|
const onFocusOut = (e) => {
|
|
const trapContainer = unref(forwardRef);
|
|
if (focusLayer.paused || !trapContainer)
|
|
return;
|
|
if (props2.trapped) {
|
|
const relatedTarget = e.relatedTarget;
|
|
if (!isNil_default(relatedTarget) && !trapContainer.contains(relatedTarget)) {
|
|
setTimeout(() => {
|
|
if (!focusLayer.paused && props2.trapped) {
|
|
const focusoutPreventedEvent = createFocusOutPreventedEvent({
|
|
focusReason: focusReason2.value
|
|
});
|
|
emit("focusout-prevented", focusoutPreventedEvent);
|
|
if (!focusoutPreventedEvent.defaultPrevented) {
|
|
tryFocus(lastFocusAfterTrapped, true);
|
|
}
|
|
}
|
|
}, 0);
|
|
}
|
|
} else {
|
|
const target2 = e.target;
|
|
const isFocusedInTrap = target2 && trapContainer.contains(target2);
|
|
if (!isFocusedInTrap)
|
|
emit("focusout", e);
|
|
}
|
|
};
|
|
async function startTrap() {
|
|
await nextTick();
|
|
const trapContainer = unref(forwardRef);
|
|
if (trapContainer) {
|
|
focusableStack.push(focusLayer);
|
|
const prevFocusedElement = trapContainer.contains(document.activeElement) ? lastFocusBeforeTrapped : document.activeElement;
|
|
lastFocusBeforeTrapped = prevFocusedElement;
|
|
const isPrevFocusContained = trapContainer.contains(prevFocusedElement);
|
|
if (!isPrevFocusContained) {
|
|
const focusEvent = new Event(FOCUS_AFTER_TRAPPED, FOCUS_AFTER_TRAPPED_OPTS);
|
|
trapContainer.addEventListener(FOCUS_AFTER_TRAPPED, trapOnFocus);
|
|
trapContainer.dispatchEvent(focusEvent);
|
|
if (!focusEvent.defaultPrevented) {
|
|
nextTick(() => {
|
|
let focusStartEl = props2.focusStartEl;
|
|
if (!isString(focusStartEl)) {
|
|
tryFocus(focusStartEl);
|
|
if (document.activeElement !== focusStartEl) {
|
|
focusStartEl = "first";
|
|
}
|
|
}
|
|
if (focusStartEl === "first") {
|
|
focusFirstDescendant(obtainAllFocusableElements2(trapContainer), true);
|
|
}
|
|
if (document.activeElement === prevFocusedElement || focusStartEl === "container") {
|
|
tryFocus(trapContainer);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function stopTrap() {
|
|
const trapContainer = unref(forwardRef);
|
|
if (trapContainer) {
|
|
trapContainer.removeEventListener(FOCUS_AFTER_TRAPPED, trapOnFocus);
|
|
const releasedEvent = new CustomEvent(FOCUS_AFTER_RELEASED, {
|
|
...FOCUS_AFTER_TRAPPED_OPTS,
|
|
detail: {
|
|
focusReason: focusReason2.value
|
|
}
|
|
});
|
|
trapContainer.addEventListener(FOCUS_AFTER_RELEASED, releaseOnFocus);
|
|
trapContainer.dispatchEvent(releasedEvent);
|
|
if (!releasedEvent.defaultPrevented && (focusReason2.value == "keyboard" || !isFocusCausedByUserEvent() || trapContainer.contains(document.activeElement))) {
|
|
tryFocus(lastFocusBeforeTrapped != null ? lastFocusBeforeTrapped : document.body);
|
|
}
|
|
trapContainer.removeEventListener(FOCUS_AFTER_RELEASED, releaseOnFocus);
|
|
focusableStack.remove(focusLayer);
|
|
}
|
|
}
|
|
onMounted(() => {
|
|
if (props2.trapped) {
|
|
startTrap();
|
|
}
|
|
watch(() => props2.trapped, (trapped) => {
|
|
if (trapped) {
|
|
startTrap();
|
|
} else {
|
|
stopTrap();
|
|
}
|
|
});
|
|
});
|
|
onBeforeUnmount(() => {
|
|
if (props2.trapped) {
|
|
stopTrap();
|
|
}
|
|
if (forwardRef.value) {
|
|
forwardRef.value.removeEventListener("keydown", onKeydown);
|
|
forwardRef.value.removeEventListener("focusin", onFocusIn);
|
|
forwardRef.value.removeEventListener("focusout", onFocusOut);
|
|
forwardRef.value = void 0;
|
|
}
|
|
});
|
|
return {
|
|
onKeydown
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return renderSlot(_ctx.$slots, "default", { handleKeydown: _ctx.onKeydown });
|
|
}
|
|
var ElFocusTrap = _export_sfc(_sfc_main10, [["render", _sfc_render], ["__file", "focus-trap.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/popper/src/composables/use-focus-trap.mjs
|
|
var usePopperContentFocusTrap = (props2, emit) => {
|
|
const trapped = ref(false);
|
|
const focusStartRef = ref();
|
|
const onFocusAfterTrapped = () => {
|
|
emit("focus");
|
|
};
|
|
const onFocusAfterReleased = (event) => {
|
|
var _a2;
|
|
if (((_a2 = event.detail) == null ? void 0 : _a2.focusReason) !== "pointer") {
|
|
focusStartRef.value = "first";
|
|
emit("blur");
|
|
}
|
|
};
|
|
const onFocusInTrap = (event) => {
|
|
if (props2.visible && !trapped.value) {
|
|
if (event.target) {
|
|
focusStartRef.value = event.target;
|
|
}
|
|
trapped.value = true;
|
|
}
|
|
};
|
|
const onFocusoutPrevented = (event) => {
|
|
if (!props2.trapping) {
|
|
if (event.detail.focusReason === "pointer") {
|
|
event.preventDefault();
|
|
}
|
|
trapped.value = false;
|
|
}
|
|
};
|
|
const onReleaseRequested = () => {
|
|
trapped.value = false;
|
|
emit("close");
|
|
};
|
|
return {
|
|
focusStartRef,
|
|
trapped,
|
|
onFocusAfterReleased,
|
|
onFocusAfterTrapped,
|
|
onFocusInTrap,
|
|
onFocusoutPrevented,
|
|
onReleaseRequested
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/popper/src/utils.mjs
|
|
var buildPopperOptions = (props2, modifiers = []) => {
|
|
const { placement, strategy, popperOptions } = props2;
|
|
const options = {
|
|
placement,
|
|
strategy,
|
|
...popperOptions,
|
|
modifiers: [...genModifiers(props2), ...modifiers]
|
|
};
|
|
deriveExtraModifiers(options, popperOptions == null ? void 0 : popperOptions.modifiers);
|
|
return options;
|
|
};
|
|
var unwrapMeasurableEl = ($el) => {
|
|
if (!isClient)
|
|
return;
|
|
return unrefElement($el);
|
|
};
|
|
function genModifiers(options) {
|
|
const { offset: offset3, gpuAcceleration, fallbackPlacements } = options;
|
|
return [
|
|
{
|
|
name: "offset",
|
|
options: {
|
|
offset: [0, offset3 != null ? offset3 : 12]
|
|
}
|
|
},
|
|
{
|
|
name: "preventOverflow",
|
|
options: {
|
|
padding: {
|
|
top: 2,
|
|
bottom: 2,
|
|
left: 5,
|
|
right: 5
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: "flip",
|
|
options: {
|
|
padding: 5,
|
|
fallbackPlacements
|
|
}
|
|
},
|
|
{
|
|
name: "computeStyles",
|
|
options: {
|
|
gpuAcceleration
|
|
}
|
|
}
|
|
];
|
|
}
|
|
function deriveExtraModifiers(options, modifiers) {
|
|
if (modifiers) {
|
|
options.modifiers = [...options.modifiers, ...modifiers != null ? modifiers : []];
|
|
}
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/popper/src/composables/use-content.mjs
|
|
var DEFAULT_ARROW_OFFSET = 0;
|
|
var usePopperContent = (props2) => {
|
|
const { popperInstanceRef, contentRef, triggerRef, role } = inject(POPPER_INJECTION_KEY, void 0);
|
|
const arrowRef = ref();
|
|
const arrowOffset = computed(() => props2.arrowOffset);
|
|
const eventListenerModifier = computed(() => {
|
|
return {
|
|
name: "eventListeners",
|
|
enabled: !!props2.visible
|
|
};
|
|
});
|
|
const arrowModifier = computed(() => {
|
|
var _a2;
|
|
const arrowEl = unref(arrowRef);
|
|
const offset3 = (_a2 = unref(arrowOffset)) != null ? _a2 : DEFAULT_ARROW_OFFSET;
|
|
return {
|
|
name: "arrow",
|
|
enabled: !isUndefined_default(arrowEl),
|
|
options: {
|
|
element: arrowEl,
|
|
padding: offset3
|
|
}
|
|
};
|
|
});
|
|
const options = computed(() => {
|
|
return {
|
|
onFirstUpdate: () => {
|
|
update2();
|
|
},
|
|
...buildPopperOptions(props2, [
|
|
unref(arrowModifier),
|
|
unref(eventListenerModifier)
|
|
])
|
|
};
|
|
});
|
|
const computedReference = computed(() => unwrapMeasurableEl(props2.referenceEl) || unref(triggerRef));
|
|
const { attributes: attributes2, state, styles, update: update2, forceUpdate, instanceRef } = usePopper(computedReference, contentRef, options);
|
|
watch(instanceRef, (instance) => popperInstanceRef.value = instance, {
|
|
flush: "sync"
|
|
});
|
|
onMounted(() => {
|
|
watch(() => {
|
|
var _a2;
|
|
return (_a2 = unref(computedReference)) == null ? void 0 : _a2.getBoundingClientRect();
|
|
}, () => {
|
|
update2();
|
|
});
|
|
});
|
|
return {
|
|
attributes: attributes2,
|
|
arrowRef,
|
|
contentRef,
|
|
instanceRef,
|
|
state,
|
|
styles,
|
|
role,
|
|
forceUpdate,
|
|
update: update2
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/popper/src/composables/use-content-dom.mjs
|
|
var usePopperContentDOM = (props2, {
|
|
attributes: attributes2,
|
|
styles,
|
|
role
|
|
}) => {
|
|
const { nextZIndex } = useZIndex();
|
|
const ns = useNamespace("popper");
|
|
const contentAttrs = computed(() => unref(attributes2).popper);
|
|
const contentZIndex = ref(isNumber2(props2.zIndex) ? props2.zIndex : nextZIndex());
|
|
const contentClass = computed(() => [
|
|
ns.b(),
|
|
ns.is("pure", props2.pure),
|
|
ns.is(props2.effect),
|
|
props2.popperClass
|
|
]);
|
|
const contentStyle = computed(() => {
|
|
return [
|
|
{ zIndex: unref(contentZIndex) },
|
|
unref(styles).popper,
|
|
props2.popperStyle || {}
|
|
];
|
|
});
|
|
const ariaModal = computed(() => role.value === "dialog" ? "false" : void 0);
|
|
const arrowStyle = computed(() => unref(styles).arrow || {});
|
|
const updateZIndex = () => {
|
|
contentZIndex.value = isNumber2(props2.zIndex) ? props2.zIndex : nextZIndex();
|
|
};
|
|
return {
|
|
ariaModal,
|
|
arrowStyle,
|
|
contentAttrs,
|
|
contentClass,
|
|
contentStyle,
|
|
contentZIndex,
|
|
updateZIndex
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/popper/src/content2.mjs
|
|
var __default__8 = defineComponent({
|
|
name: "ElPopperContent"
|
|
});
|
|
var _sfc_main11 = defineComponent({
|
|
...__default__8,
|
|
props: popperContentProps,
|
|
emits: popperContentEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const {
|
|
focusStartRef,
|
|
trapped,
|
|
onFocusAfterReleased,
|
|
onFocusAfterTrapped,
|
|
onFocusInTrap,
|
|
onFocusoutPrevented,
|
|
onReleaseRequested
|
|
} = usePopperContentFocusTrap(props2, emit);
|
|
const { attributes: attributes2, arrowRef, contentRef, styles, instanceRef, role, update: update2 } = usePopperContent(props2);
|
|
const {
|
|
ariaModal,
|
|
arrowStyle,
|
|
contentAttrs,
|
|
contentClass,
|
|
contentStyle,
|
|
updateZIndex
|
|
} = usePopperContentDOM(props2, {
|
|
styles,
|
|
attributes: attributes2,
|
|
role
|
|
});
|
|
const formItemContext = inject(formItemContextKey, void 0);
|
|
provide(POPPER_CONTENT_INJECTION_KEY, {
|
|
arrowStyle,
|
|
arrowRef
|
|
});
|
|
if (formItemContext) {
|
|
provide(formItemContextKey, {
|
|
...formItemContext,
|
|
addInputId: NOOP,
|
|
removeInputId: NOOP
|
|
});
|
|
}
|
|
let triggerTargetAriaStopWatch = void 0;
|
|
const updatePopper = (shouldUpdateZIndex = true) => {
|
|
update2();
|
|
shouldUpdateZIndex && updateZIndex();
|
|
};
|
|
const togglePopperAlive = () => {
|
|
updatePopper(false);
|
|
if (props2.visible && props2.focusOnShow) {
|
|
trapped.value = true;
|
|
} else if (props2.visible === false) {
|
|
trapped.value = false;
|
|
}
|
|
};
|
|
onMounted(() => {
|
|
watch(() => props2.triggerTargetEl, (triggerTargetEl, prevTriggerTargetEl) => {
|
|
triggerTargetAriaStopWatch == null ? void 0 : triggerTargetAriaStopWatch();
|
|
triggerTargetAriaStopWatch = void 0;
|
|
const el = unref(triggerTargetEl || contentRef.value);
|
|
const prevEl = unref(prevTriggerTargetEl || contentRef.value);
|
|
if (isElement2(el)) {
|
|
triggerTargetAriaStopWatch = watch([role, () => props2.ariaLabel, ariaModal, () => props2.id], (watches) => {
|
|
["role", "aria-label", "aria-modal", "id"].forEach((key, idx) => {
|
|
isNil_default(watches[idx]) ? el.removeAttribute(key) : el.setAttribute(key, watches[idx]);
|
|
});
|
|
}, { immediate: true });
|
|
}
|
|
if (prevEl !== el && isElement2(prevEl)) {
|
|
["role", "aria-label", "aria-modal", "id"].forEach((key) => {
|
|
prevEl.removeAttribute(key);
|
|
});
|
|
}
|
|
}, { immediate: true });
|
|
watch(() => props2.visible, togglePopperAlive, { immediate: true });
|
|
});
|
|
onBeforeUnmount(() => {
|
|
triggerTargetAriaStopWatch == null ? void 0 : triggerTargetAriaStopWatch();
|
|
triggerTargetAriaStopWatch = void 0;
|
|
});
|
|
expose({
|
|
popperContentRef: contentRef,
|
|
popperInstanceRef: instanceRef,
|
|
updatePopper,
|
|
contentStyle
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", mergeProps({
|
|
ref_key: "contentRef",
|
|
ref: contentRef
|
|
}, unref(contentAttrs), {
|
|
style: unref(contentStyle),
|
|
class: unref(contentClass),
|
|
tabindex: "-1",
|
|
onMouseenter: (e) => _ctx.$emit("mouseenter", e),
|
|
onMouseleave: (e) => _ctx.$emit("mouseleave", e)
|
|
}), [
|
|
createVNode(unref(ElFocusTrap), {
|
|
trapped: unref(trapped),
|
|
"trap-on-focus-in": true,
|
|
"focus-trap-el": unref(contentRef),
|
|
"focus-start-el": unref(focusStartRef),
|
|
onFocusAfterTrapped: unref(onFocusAfterTrapped),
|
|
onFocusAfterReleased: unref(onFocusAfterReleased),
|
|
onFocusin: unref(onFocusInTrap),
|
|
onFocusoutPrevented: unref(onFocusoutPrevented),
|
|
onReleaseRequested: unref(onReleaseRequested)
|
|
}, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 8, ["trapped", "focus-trap-el", "focus-start-el", "onFocusAfterTrapped", "onFocusAfterReleased", "onFocusin", "onFocusoutPrevented", "onReleaseRequested"])
|
|
], 16, ["onMouseenter", "onMouseleave"]);
|
|
};
|
|
}
|
|
});
|
|
var ElPopperContent = _export_sfc(_sfc_main11, [["__file", "content.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/popper/src/popper2.mjs
|
|
var __default__9 = defineComponent({
|
|
name: "ElPopper",
|
|
inheritAttrs: false
|
|
});
|
|
var _sfc_main12 = defineComponent({
|
|
...__default__9,
|
|
props: popperProps,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const triggerRef = ref();
|
|
const popperInstanceRef = ref();
|
|
const contentRef = ref();
|
|
const referenceRef = ref();
|
|
const role = computed(() => props2.role);
|
|
const popperProvides = {
|
|
triggerRef,
|
|
popperInstanceRef,
|
|
contentRef,
|
|
referenceRef,
|
|
role
|
|
};
|
|
expose(popperProvides);
|
|
provide(POPPER_INJECTION_KEY, popperProvides);
|
|
return (_ctx, _cache) => {
|
|
return renderSlot(_ctx.$slots, "default");
|
|
};
|
|
}
|
|
});
|
|
var Popper = _export_sfc(_sfc_main12, [["__file", "popper.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/popper/index.mjs
|
|
var ElPopper = withInstall(Popper);
|
|
|
|
// node_modules/element-plus/es/components/tooltip/src/constants.mjs
|
|
var TOOLTIP_INJECTION_KEY = Symbol("elTooltip");
|
|
|
|
// node_modules/element-plus/es/hooks/use-timeout/index.mjs
|
|
function useTimeout() {
|
|
let timeoutHandle;
|
|
const registerTimeout = (fn2, delay2) => {
|
|
cancelTimeout();
|
|
timeoutHandle = window.setTimeout(fn2, delay2);
|
|
};
|
|
const cancelTimeout = () => window.clearTimeout(timeoutHandle);
|
|
tryOnScopeDispose(() => cancelTimeout());
|
|
return {
|
|
registerTimeout,
|
|
cancelTimeout
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/hooks/use-delayed-toggle/index.mjs
|
|
var useDelayedToggleProps = buildProps({
|
|
showAfter: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
hideAfter: {
|
|
type: Number,
|
|
default: 200
|
|
},
|
|
autoClose: {
|
|
type: Number,
|
|
default: 0
|
|
}
|
|
});
|
|
var useDelayedToggle = ({
|
|
showAfter,
|
|
hideAfter,
|
|
autoClose,
|
|
open,
|
|
close: close2
|
|
}) => {
|
|
const { registerTimeout } = useTimeout();
|
|
const {
|
|
registerTimeout: registerTimeoutForAutoClose,
|
|
cancelTimeout: cancelTimeoutForAutoClose
|
|
} = useTimeout();
|
|
const onOpen = (event) => {
|
|
registerTimeout(() => {
|
|
open(event);
|
|
const _autoClose = unref(autoClose);
|
|
if (isNumber2(_autoClose) && _autoClose > 0) {
|
|
registerTimeoutForAutoClose(() => {
|
|
close2(event);
|
|
}, _autoClose);
|
|
}
|
|
}, unref(showAfter));
|
|
};
|
|
const onClose = (event) => {
|
|
cancelTimeoutForAutoClose();
|
|
registerTimeout(() => {
|
|
close2(event);
|
|
}, unref(hideAfter));
|
|
};
|
|
return {
|
|
onOpen,
|
|
onClose
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/teleport/src/teleport.mjs
|
|
var teleportProps = buildProps({
|
|
to: {
|
|
type: definePropType([String, Object]),
|
|
required: true
|
|
},
|
|
disabled: Boolean
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tooltip/src/content.mjs
|
|
var useTooltipContentProps = buildProps({
|
|
...useDelayedToggleProps,
|
|
...popperContentProps,
|
|
appendTo: {
|
|
type: teleportProps.to.type
|
|
},
|
|
content: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
rawContent: Boolean,
|
|
persistent: Boolean,
|
|
visible: {
|
|
type: definePropType(Boolean),
|
|
default: null
|
|
},
|
|
transition: String,
|
|
teleported: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
disabled: Boolean,
|
|
...useAriaProps(["ariaLabel"])
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tooltip/src/trigger2.mjs
|
|
var useTooltipTriggerProps = buildProps({
|
|
...popperTriggerProps,
|
|
disabled: Boolean,
|
|
trigger: {
|
|
type: definePropType([String, Array]),
|
|
default: "hover"
|
|
},
|
|
triggerKeys: {
|
|
type: definePropType(Array),
|
|
default: () => [EVENT_CODE.enter, EVENT_CODE.numpadEnter, EVENT_CODE.space]
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/hooks/use-model-toggle/index.mjs
|
|
var _prop = buildProp({
|
|
type: definePropType(Boolean),
|
|
default: null
|
|
});
|
|
var _event = buildProp({
|
|
type: definePropType(Function)
|
|
});
|
|
var createModelToggleComposable = (name) => {
|
|
const updateEventKey = `update:${name}`;
|
|
const updateEventKeyRaw2 = `onUpdate:${name}`;
|
|
const useModelToggleEmits2 = [updateEventKey];
|
|
const useModelToggleProps2 = {
|
|
[name]: _prop,
|
|
[updateEventKeyRaw2]: _event
|
|
};
|
|
const useModelToggle2 = ({
|
|
indicator,
|
|
toggleReason,
|
|
shouldHideWhenRouteChanges,
|
|
shouldProceed,
|
|
onShow,
|
|
onHide
|
|
}) => {
|
|
const instance = getCurrentInstance();
|
|
const { emit } = instance;
|
|
const props2 = instance.props;
|
|
const hasUpdateHandler = computed(() => isFunction(props2[updateEventKeyRaw2]));
|
|
const isModelBindingAbsent = computed(() => props2[name] === null);
|
|
const doShow = (event) => {
|
|
if (indicator.value === true) {
|
|
return;
|
|
}
|
|
indicator.value = true;
|
|
if (toggleReason) {
|
|
toggleReason.value = event;
|
|
}
|
|
if (isFunction(onShow)) {
|
|
onShow(event);
|
|
}
|
|
};
|
|
const doHide = (event) => {
|
|
if (indicator.value === false) {
|
|
return;
|
|
}
|
|
indicator.value = false;
|
|
if (toggleReason) {
|
|
toggleReason.value = event;
|
|
}
|
|
if (isFunction(onHide)) {
|
|
onHide(event);
|
|
}
|
|
};
|
|
const show = (event) => {
|
|
if (props2.disabled === true || isFunction(shouldProceed) && !shouldProceed())
|
|
return;
|
|
const shouldEmit = hasUpdateHandler.value && isClient;
|
|
if (shouldEmit) {
|
|
emit(updateEventKey, true);
|
|
}
|
|
if (isModelBindingAbsent.value || !shouldEmit) {
|
|
doShow(event);
|
|
}
|
|
};
|
|
const hide2 = (event) => {
|
|
if (props2.disabled === true || !isClient)
|
|
return;
|
|
const shouldEmit = hasUpdateHandler.value && isClient;
|
|
if (shouldEmit) {
|
|
emit(updateEventKey, false);
|
|
}
|
|
if (isModelBindingAbsent.value || !shouldEmit) {
|
|
doHide(event);
|
|
}
|
|
};
|
|
const onChange = (val) => {
|
|
if (!isBoolean2(val))
|
|
return;
|
|
if (props2.disabled && val) {
|
|
if (hasUpdateHandler.value) {
|
|
emit(updateEventKey, false);
|
|
}
|
|
} else if (indicator.value !== val) {
|
|
if (val) {
|
|
doShow();
|
|
} else {
|
|
doHide();
|
|
}
|
|
}
|
|
};
|
|
const toggle = () => {
|
|
if (indicator.value) {
|
|
hide2();
|
|
} else {
|
|
show();
|
|
}
|
|
};
|
|
watch(() => props2[name], onChange);
|
|
if (shouldHideWhenRouteChanges && instance.appContext.config.globalProperties.$route !== void 0) {
|
|
watch(() => ({
|
|
...instance.proxy.$route
|
|
}), () => {
|
|
if (shouldHideWhenRouteChanges.value && indicator.value) {
|
|
hide2();
|
|
}
|
|
});
|
|
}
|
|
onMounted(() => {
|
|
onChange(props2[name]);
|
|
});
|
|
return {
|
|
hide: hide2,
|
|
show,
|
|
toggle,
|
|
hasUpdateHandler
|
|
};
|
|
};
|
|
return {
|
|
useModelToggle: useModelToggle2,
|
|
useModelToggleProps: useModelToggleProps2,
|
|
useModelToggleEmits: useModelToggleEmits2
|
|
};
|
|
};
|
|
var { useModelToggle, useModelToggleProps, useModelToggleEmits } = createModelToggleComposable("modelValue");
|
|
|
|
// node_modules/element-plus/es/components/tooltip/src/tooltip.mjs
|
|
var {
|
|
useModelToggleProps: useTooltipModelToggleProps,
|
|
useModelToggleEmits: useTooltipModelToggleEmits,
|
|
useModelToggle: useTooltipModelToggle
|
|
} = createModelToggleComposable("visible");
|
|
var useTooltipProps = buildProps({
|
|
...popperProps,
|
|
...useTooltipModelToggleProps,
|
|
...useTooltipContentProps,
|
|
...useTooltipTriggerProps,
|
|
...popperArrowProps,
|
|
showArrow: {
|
|
type: Boolean,
|
|
default: true
|
|
}
|
|
});
|
|
var tooltipEmits = [
|
|
...useTooltipModelToggleEmits,
|
|
"before-show",
|
|
"before-hide",
|
|
"show",
|
|
"hide",
|
|
"open",
|
|
"close"
|
|
];
|
|
|
|
// node_modules/element-plus/es/hooks/use-popper-container/index.mjs
|
|
var usePopperContainerId = () => {
|
|
const namespace = useGetDerivedNamespace();
|
|
const idInjection = useIdInjection();
|
|
const id = computed(() => {
|
|
return `${namespace.value}-popper-container-${idInjection.prefix}`;
|
|
});
|
|
const selector = computed(() => `#${id.value}`);
|
|
return {
|
|
id,
|
|
selector
|
|
};
|
|
};
|
|
var createContainer = (id) => {
|
|
const container = document.createElement("div");
|
|
container.id = id;
|
|
document.body.appendChild(container);
|
|
return container;
|
|
};
|
|
var usePopperContainer = () => {
|
|
const { id, selector } = usePopperContainerId();
|
|
onBeforeMount(() => {
|
|
if (!isClient)
|
|
return;
|
|
if (!document.body.querySelector(selector.value)) {
|
|
createContainer(id.value);
|
|
}
|
|
});
|
|
return {
|
|
id,
|
|
selector
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/tooltip/src/utils.mjs
|
|
var isTriggerType = (trigger, type4) => {
|
|
if (isArray(trigger)) {
|
|
return trigger.includes(type4);
|
|
}
|
|
return trigger === type4;
|
|
};
|
|
var whenTrigger = (trigger, type4, handler) => {
|
|
return (e) => {
|
|
isTriggerType(unref(trigger), type4) && handler(e);
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/utils/dom/event.mjs
|
|
var composeEventHandlers = (theirsHandler, oursHandler, { checkForDefaultPrevented = true } = {}) => {
|
|
const handleEvent = (event) => {
|
|
const shouldPrevent = theirsHandler == null ? void 0 : theirsHandler(event);
|
|
if (checkForDefaultPrevented === false || !shouldPrevent) {
|
|
return oursHandler == null ? void 0 : oursHandler(event);
|
|
}
|
|
};
|
|
return handleEvent;
|
|
};
|
|
var whenMouse = (handler) => {
|
|
return (e) => e.pointerType === "mouse" ? handler(e) : void 0;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/tooltip/src/trigger.mjs
|
|
var __default__10 = defineComponent({
|
|
name: "ElTooltipTrigger"
|
|
});
|
|
var _sfc_main13 = defineComponent({
|
|
...__default__10,
|
|
props: useTooltipTriggerProps,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("tooltip");
|
|
const { controlled, id, open, onOpen, onClose, onToggle } = inject(TOOLTIP_INJECTION_KEY, void 0);
|
|
const triggerRef = ref(null);
|
|
const stopWhenControlledOrDisabled = () => {
|
|
if (unref(controlled) || props2.disabled) {
|
|
return true;
|
|
}
|
|
};
|
|
const trigger = toRef(props2, "trigger");
|
|
const onMouseenter = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "hover", onOpen));
|
|
const onMouseleave = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "hover", onClose));
|
|
const onClick = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "click", (e) => {
|
|
if (e.button === 0) {
|
|
onToggle(e);
|
|
}
|
|
}));
|
|
const onFocus = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "focus", onOpen));
|
|
const onBlur = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "focus", onClose));
|
|
const onContextMenu = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "contextmenu", (e) => {
|
|
e.preventDefault();
|
|
onToggle(e);
|
|
}));
|
|
const onKeydown = composeEventHandlers(stopWhenControlledOrDisabled, (e) => {
|
|
const { code } = e;
|
|
if (props2.triggerKeys.includes(code)) {
|
|
e.preventDefault();
|
|
onToggle(e);
|
|
}
|
|
});
|
|
expose({
|
|
triggerRef
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElPopperTrigger), {
|
|
id: unref(id),
|
|
"virtual-ref": _ctx.virtualRef,
|
|
open: unref(open),
|
|
"virtual-triggering": _ctx.virtualTriggering,
|
|
class: normalizeClass(unref(ns).e("trigger")),
|
|
onBlur: unref(onBlur),
|
|
onClick: unref(onClick),
|
|
onContextmenu: unref(onContextMenu),
|
|
onFocus: unref(onFocus),
|
|
onMouseenter: unref(onMouseenter),
|
|
onMouseleave: unref(onMouseleave),
|
|
onKeydown: unref(onKeydown)
|
|
}, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 8, ["id", "virtual-ref", "open", "virtual-triggering", "class", "onBlur", "onClick", "onContextmenu", "onFocus", "onMouseenter", "onMouseleave", "onKeydown"]);
|
|
};
|
|
}
|
|
});
|
|
var ElTooltipTrigger = _export_sfc(_sfc_main13, [["__file", "trigger.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/teleport/src/teleport2.mjs
|
|
var _sfc_main14 = defineComponent({
|
|
__name: "teleport",
|
|
props: teleportProps,
|
|
setup(__props) {
|
|
return (_ctx, _cache) => {
|
|
return _ctx.disabled ? renderSlot(_ctx.$slots, "default", { key: 0 }) : (openBlock(), createBlock(Teleport, {
|
|
key: 1,
|
|
to: _ctx.to
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 8, ["to"]));
|
|
};
|
|
}
|
|
});
|
|
var Teleport2 = _export_sfc(_sfc_main14, [["__file", "teleport.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/teleport/index.mjs
|
|
var ElTeleport = withInstall(Teleport2);
|
|
|
|
// node_modules/element-plus/es/components/tooltip/src/content2.mjs
|
|
var __default__11 = defineComponent({
|
|
name: "ElTooltipContent",
|
|
inheritAttrs: false
|
|
});
|
|
var _sfc_main15 = defineComponent({
|
|
...__default__11,
|
|
props: useTooltipContentProps,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const { selector } = usePopperContainerId();
|
|
const ns = useNamespace("tooltip");
|
|
const contentRef = ref();
|
|
const popperContentRef = computedEager(() => {
|
|
var _a2;
|
|
return (_a2 = contentRef.value) == null ? void 0 : _a2.popperContentRef;
|
|
});
|
|
let stopHandle;
|
|
const {
|
|
controlled,
|
|
id,
|
|
open,
|
|
trigger,
|
|
onClose,
|
|
onOpen,
|
|
onShow,
|
|
onHide,
|
|
onBeforeShow,
|
|
onBeforeHide
|
|
} = inject(TOOLTIP_INJECTION_KEY, void 0);
|
|
const transitionClass = computed(() => {
|
|
return props2.transition || `${ns.namespace.value}-fade-in-linear`;
|
|
});
|
|
const persistentRef = computed(() => {
|
|
if (false) {
|
|
if (!process.env.RUN_TEST_WITH_PERSISTENT) {
|
|
return true;
|
|
}
|
|
}
|
|
return props2.persistent;
|
|
});
|
|
onBeforeUnmount(() => {
|
|
stopHandle == null ? void 0 : stopHandle();
|
|
});
|
|
const shouldRender = computed(() => {
|
|
return unref(persistentRef) ? true : unref(open);
|
|
});
|
|
const shouldShow = computed(() => {
|
|
return props2.disabled ? false : unref(open);
|
|
});
|
|
const appendTo = computed(() => {
|
|
return props2.appendTo || selector.value;
|
|
});
|
|
const contentStyle = computed(() => {
|
|
var _a2;
|
|
return (_a2 = props2.style) != null ? _a2 : {};
|
|
});
|
|
const ariaHidden = ref(true);
|
|
const onTransitionLeave = () => {
|
|
onHide();
|
|
isFocusInsideContent() && tryFocus(document.body);
|
|
ariaHidden.value = true;
|
|
};
|
|
const stopWhenControlled = () => {
|
|
if (unref(controlled))
|
|
return true;
|
|
};
|
|
const onContentEnter = composeEventHandlers(stopWhenControlled, () => {
|
|
if (props2.enterable && unref(trigger) === "hover") {
|
|
onOpen();
|
|
}
|
|
});
|
|
const onContentLeave = composeEventHandlers(stopWhenControlled, () => {
|
|
if (unref(trigger) === "hover") {
|
|
onClose();
|
|
}
|
|
});
|
|
const onBeforeEnter = () => {
|
|
var _a2, _b;
|
|
(_b = (_a2 = contentRef.value) == null ? void 0 : _a2.updatePopper) == null ? void 0 : _b.call(_a2);
|
|
onBeforeShow == null ? void 0 : onBeforeShow();
|
|
};
|
|
const onBeforeLeave = () => {
|
|
onBeforeHide == null ? void 0 : onBeforeHide();
|
|
};
|
|
const onAfterShow = () => {
|
|
onShow();
|
|
};
|
|
const onBlur = () => {
|
|
if (!props2.virtualTriggering) {
|
|
onClose();
|
|
}
|
|
};
|
|
const isFocusInsideContent = (event) => {
|
|
var _a2;
|
|
const popperContent = (_a2 = contentRef.value) == null ? void 0 : _a2.popperContentRef;
|
|
const activeElement = (event == null ? void 0 : event.relatedTarget) || document.activeElement;
|
|
return popperContent == null ? void 0 : popperContent.contains(activeElement);
|
|
};
|
|
watch(() => unref(open), (val) => {
|
|
if (!val) {
|
|
stopHandle == null ? void 0 : stopHandle();
|
|
} else {
|
|
ariaHidden.value = false;
|
|
stopHandle = onClickOutside(popperContentRef, () => {
|
|
if (unref(controlled))
|
|
return;
|
|
const $trigger = unref(trigger);
|
|
if ($trigger !== "hover") {
|
|
onClose();
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
flush: "post"
|
|
});
|
|
watch(() => props2.content, () => {
|
|
var _a2, _b;
|
|
(_b = (_a2 = contentRef.value) == null ? void 0 : _a2.updatePopper) == null ? void 0 : _b.call(_a2);
|
|
});
|
|
expose({
|
|
contentRef,
|
|
isFocusInsideContent
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElTeleport), {
|
|
disabled: !_ctx.teleported,
|
|
to: unref(appendTo)
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(Transition, {
|
|
name: unref(transitionClass),
|
|
onAfterLeave: onTransitionLeave,
|
|
onBeforeEnter,
|
|
onAfterEnter: onAfterShow,
|
|
onBeforeLeave
|
|
}, {
|
|
default: withCtx(() => [
|
|
unref(shouldRender) ? withDirectives((openBlock(), createBlock(unref(ElPopperContent), mergeProps({
|
|
key: 0,
|
|
id: unref(id),
|
|
ref_key: "contentRef",
|
|
ref: contentRef
|
|
}, _ctx.$attrs, {
|
|
"aria-label": _ctx.ariaLabel,
|
|
"aria-hidden": ariaHidden.value,
|
|
"boundaries-padding": _ctx.boundariesPadding,
|
|
"fallback-placements": _ctx.fallbackPlacements,
|
|
"gpu-acceleration": _ctx.gpuAcceleration,
|
|
offset: _ctx.offset,
|
|
placement: _ctx.placement,
|
|
"popper-options": _ctx.popperOptions,
|
|
"arrow-offset": _ctx.arrowOffset,
|
|
strategy: _ctx.strategy,
|
|
effect: _ctx.effect,
|
|
enterable: _ctx.enterable,
|
|
pure: _ctx.pure,
|
|
"popper-class": _ctx.popperClass,
|
|
"popper-style": [_ctx.popperStyle, unref(contentStyle)],
|
|
"reference-el": _ctx.referenceEl,
|
|
"trigger-target-el": _ctx.triggerTargetEl,
|
|
visible: unref(shouldShow),
|
|
"z-index": _ctx.zIndex,
|
|
onMouseenter: unref(onContentEnter),
|
|
onMouseleave: unref(onContentLeave),
|
|
onBlur,
|
|
onClose: unref(onClose)
|
|
}), {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 16, ["id", "aria-label", "aria-hidden", "boundaries-padding", "fallback-placements", "gpu-acceleration", "offset", "placement", "popper-options", "arrow-offset", "strategy", "effect", "enterable", "pure", "popper-class", "popper-style", "reference-el", "trigger-target-el", "visible", "z-index", "onMouseenter", "onMouseleave", "onClose"])), [
|
|
[vShow, unref(shouldShow)]
|
|
]) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 8, ["name"])
|
|
]),
|
|
_: 3
|
|
}, 8, ["disabled", "to"]);
|
|
};
|
|
}
|
|
});
|
|
var ElTooltipContent = _export_sfc(_sfc_main15, [["__file", "content.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tooltip/src/tooltip2.mjs
|
|
var __default__12 = defineComponent({
|
|
name: "ElTooltip"
|
|
});
|
|
var _sfc_main16 = defineComponent({
|
|
...__default__12,
|
|
props: useTooltipProps,
|
|
emits: tooltipEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
usePopperContainer();
|
|
const ns = useNamespace("tooltip");
|
|
const id = useId();
|
|
const popperRef = ref();
|
|
const contentRef = ref();
|
|
const updatePopper = () => {
|
|
var _a2;
|
|
const popperComponent = unref(popperRef);
|
|
if (popperComponent) {
|
|
(_a2 = popperComponent.popperInstanceRef) == null ? void 0 : _a2.update();
|
|
}
|
|
};
|
|
const open = ref(false);
|
|
const toggleReason = ref();
|
|
const { show, hide: hide2, hasUpdateHandler } = useTooltipModelToggle({
|
|
indicator: open,
|
|
toggleReason
|
|
});
|
|
const { onOpen, onClose } = useDelayedToggle({
|
|
showAfter: toRef(props2, "showAfter"),
|
|
hideAfter: toRef(props2, "hideAfter"),
|
|
autoClose: toRef(props2, "autoClose"),
|
|
open: show,
|
|
close: hide2
|
|
});
|
|
const controlled = computed(() => isBoolean2(props2.visible) && !hasUpdateHandler.value);
|
|
const kls = computed(() => {
|
|
return [ns.b(), props2.popperClass];
|
|
});
|
|
provide(TOOLTIP_INJECTION_KEY, {
|
|
controlled,
|
|
id,
|
|
open: readonly(open),
|
|
trigger: toRef(props2, "trigger"),
|
|
onOpen: (event) => {
|
|
onOpen(event);
|
|
},
|
|
onClose: (event) => {
|
|
onClose(event);
|
|
},
|
|
onToggle: (event) => {
|
|
if (unref(open)) {
|
|
onClose(event);
|
|
} else {
|
|
onOpen(event);
|
|
}
|
|
},
|
|
onShow: () => {
|
|
emit("show", toggleReason.value);
|
|
},
|
|
onHide: () => {
|
|
emit("hide", toggleReason.value);
|
|
},
|
|
onBeforeShow: () => {
|
|
emit("before-show", toggleReason.value);
|
|
},
|
|
onBeforeHide: () => {
|
|
emit("before-hide", toggleReason.value);
|
|
},
|
|
updatePopper
|
|
});
|
|
watch(() => props2.disabled, (disabled) => {
|
|
if (disabled && open.value) {
|
|
open.value = false;
|
|
}
|
|
});
|
|
const isFocusInsideContent = (event) => {
|
|
var _a2;
|
|
return (_a2 = contentRef.value) == null ? void 0 : _a2.isFocusInsideContent(event);
|
|
};
|
|
onDeactivated(() => open.value && hide2());
|
|
expose({
|
|
popperRef,
|
|
contentRef,
|
|
isFocusInsideContent,
|
|
updatePopper,
|
|
onOpen,
|
|
onClose,
|
|
hide: hide2
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElPopper), {
|
|
ref_key: "popperRef",
|
|
ref: popperRef,
|
|
role: _ctx.role
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(ElTooltipTrigger, {
|
|
disabled: _ctx.disabled,
|
|
trigger: _ctx.trigger,
|
|
"trigger-keys": _ctx.triggerKeys,
|
|
"virtual-ref": _ctx.virtualRef,
|
|
"virtual-triggering": _ctx.virtualTriggering
|
|
}, {
|
|
default: withCtx(() => [
|
|
_ctx.$slots.default ? renderSlot(_ctx.$slots, "default", { key: 0 }) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 8, ["disabled", "trigger", "trigger-keys", "virtual-ref", "virtual-triggering"]),
|
|
createVNode(ElTooltipContent, {
|
|
ref_key: "contentRef",
|
|
ref: contentRef,
|
|
"aria-label": _ctx.ariaLabel,
|
|
"boundaries-padding": _ctx.boundariesPadding,
|
|
content: _ctx.content,
|
|
disabled: _ctx.disabled,
|
|
effect: _ctx.effect,
|
|
enterable: _ctx.enterable,
|
|
"fallback-placements": _ctx.fallbackPlacements,
|
|
"hide-after": _ctx.hideAfter,
|
|
"gpu-acceleration": _ctx.gpuAcceleration,
|
|
offset: _ctx.offset,
|
|
persistent: _ctx.persistent,
|
|
"popper-class": unref(kls),
|
|
"popper-style": _ctx.popperStyle,
|
|
placement: _ctx.placement,
|
|
"popper-options": _ctx.popperOptions,
|
|
"arrow-offset": _ctx.arrowOffset,
|
|
pure: _ctx.pure,
|
|
"raw-content": _ctx.rawContent,
|
|
"reference-el": _ctx.referenceEl,
|
|
"trigger-target-el": _ctx.triggerTargetEl,
|
|
"show-after": _ctx.showAfter,
|
|
strategy: _ctx.strategy,
|
|
teleported: _ctx.teleported,
|
|
transition: _ctx.transition,
|
|
"virtual-triggering": _ctx.virtualTriggering,
|
|
"z-index": _ctx.zIndex,
|
|
"append-to": _ctx.appendTo
|
|
}, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "content", {}, () => [
|
|
_ctx.rawContent ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
innerHTML: _ctx.content
|
|
}, null, 8, ["innerHTML"])) : (openBlock(), createElementBlock("span", { key: 1 }, toDisplayString(_ctx.content), 1))
|
|
]),
|
|
_ctx.showArrow ? (openBlock(), createBlock(unref(ElPopperArrow), { key: 0 })) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 8, ["aria-label", "boundaries-padding", "content", "disabled", "effect", "enterable", "fallback-placements", "hide-after", "gpu-acceleration", "offset", "persistent", "popper-class", "popper-style", "placement", "popper-options", "arrow-offset", "pure", "raw-content", "reference-el", "trigger-target-el", "show-after", "strategy", "teleported", "transition", "virtual-triggering", "z-index", "append-to"])
|
|
]),
|
|
_: 3
|
|
}, 8, ["role"]);
|
|
};
|
|
}
|
|
});
|
|
var Tooltip = _export_sfc(_sfc_main16, [["__file", "tooltip.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tooltip/index.mjs
|
|
var ElTooltip = withInstall(Tooltip);
|
|
|
|
// node_modules/element-plus/es/components/autocomplete/src/autocomplete2.mjs
|
|
var autocompleteProps = buildProps({
|
|
valueKey: {
|
|
type: String,
|
|
default: "value"
|
|
},
|
|
modelValue: {
|
|
type: [String, Number],
|
|
default: ""
|
|
},
|
|
debounce: {
|
|
type: Number,
|
|
default: 300
|
|
},
|
|
placement: {
|
|
type: definePropType(String),
|
|
values: [
|
|
"top",
|
|
"top-start",
|
|
"top-end",
|
|
"bottom",
|
|
"bottom-start",
|
|
"bottom-end"
|
|
],
|
|
default: "bottom-start"
|
|
},
|
|
fetchSuggestions: {
|
|
type: definePropType([Function, Array]),
|
|
default: NOOP
|
|
},
|
|
popperClass: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
triggerOnFocus: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
selectWhenUnmatched: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
hideLoading: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
teleported: useTooltipContentProps.teleported,
|
|
appendTo: useTooltipContentProps.appendTo,
|
|
highlightFirstItem: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
fitInputWidth: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
clearable: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
disabled: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
name: String,
|
|
...useAriaProps(["ariaLabel"])
|
|
});
|
|
var autocompleteEmits = {
|
|
[UPDATE_MODEL_EVENT]: (value) => isString(value),
|
|
[INPUT_EVENT]: (value) => isString(value),
|
|
[CHANGE_EVENT]: (value) => isString(value),
|
|
focus: (evt) => evt instanceof FocusEvent,
|
|
blur: (evt) => evt instanceof FocusEvent,
|
|
clear: () => true,
|
|
select: (item) => isObject(item)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/autocomplete/src/autocomplete.mjs
|
|
var COMPONENT_NAME5 = "ElAutocomplete";
|
|
var __default__13 = defineComponent({
|
|
name: COMPONENT_NAME5,
|
|
inheritAttrs: false
|
|
});
|
|
var _sfc_main17 = defineComponent({
|
|
...__default__13,
|
|
props: autocompleteProps,
|
|
emits: autocompleteEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const attrs = useAttrs2();
|
|
const rawAttrs = useAttrs();
|
|
const disabled = useFormDisabled();
|
|
const ns = useNamespace("autocomplete");
|
|
const inputRef = ref();
|
|
const regionRef = ref();
|
|
const popperRef = ref();
|
|
const listboxRef = ref();
|
|
let readonly2 = false;
|
|
let ignoreFocusEvent = false;
|
|
const suggestions = ref([]);
|
|
const highlightedIndex = ref(-1);
|
|
const dropdownWidth = ref("");
|
|
const activated = ref(false);
|
|
const suggestionDisabled = ref(false);
|
|
const loading = ref(false);
|
|
const listboxId = useId();
|
|
const styles = computed(() => rawAttrs.style);
|
|
const suggestionVisible = computed(() => {
|
|
const isValidData = suggestions.value.length > 0;
|
|
return (isValidData || loading.value) && activated.value;
|
|
});
|
|
const suggestionLoading = computed(() => !props2.hideLoading && loading.value);
|
|
const refInput = computed(() => {
|
|
if (inputRef.value) {
|
|
return Array.from(inputRef.value.$el.querySelectorAll("input"));
|
|
}
|
|
return [];
|
|
});
|
|
const onSuggestionShow = () => {
|
|
if (suggestionVisible.value) {
|
|
dropdownWidth.value = `${inputRef.value.$el.offsetWidth}px`;
|
|
}
|
|
};
|
|
const onHide = () => {
|
|
highlightedIndex.value = -1;
|
|
};
|
|
const getData2 = async (queryString) => {
|
|
if (suggestionDisabled.value)
|
|
return;
|
|
const cb = (suggestionList) => {
|
|
loading.value = false;
|
|
if (suggestionDisabled.value)
|
|
return;
|
|
if (isArray(suggestionList)) {
|
|
suggestions.value = suggestionList;
|
|
highlightedIndex.value = props2.highlightFirstItem ? 0 : -1;
|
|
} else {
|
|
throwError(COMPONENT_NAME5, "autocomplete suggestions must be an array");
|
|
}
|
|
};
|
|
loading.value = true;
|
|
if (isArray(props2.fetchSuggestions)) {
|
|
cb(props2.fetchSuggestions);
|
|
} else {
|
|
const result2 = await props2.fetchSuggestions(queryString, cb);
|
|
if (isArray(result2))
|
|
cb(result2);
|
|
}
|
|
};
|
|
const debouncedGetData = debounce_default(getData2, props2.debounce);
|
|
const handleInput = (value) => {
|
|
const valuePresented = !!value;
|
|
emit(INPUT_EVENT, value);
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
suggestionDisabled.value = false;
|
|
activated.value || (activated.value = valuePresented);
|
|
if (!props2.triggerOnFocus && !value) {
|
|
suggestionDisabled.value = true;
|
|
suggestions.value = [];
|
|
return;
|
|
}
|
|
debouncedGetData(value);
|
|
};
|
|
const handleMouseDown = (event) => {
|
|
var _a2;
|
|
if (disabled.value)
|
|
return;
|
|
if (((_a2 = event.target) == null ? void 0 : _a2.tagName) !== "INPUT" || refInput.value.includes(document.activeElement)) {
|
|
activated.value = true;
|
|
}
|
|
};
|
|
const handleChange = (value) => {
|
|
emit(CHANGE_EVENT, value);
|
|
};
|
|
const handleFocus = (evt) => {
|
|
var _a2;
|
|
if (!ignoreFocusEvent) {
|
|
activated.value = true;
|
|
emit("focus", evt);
|
|
const queryString = (_a2 = props2.modelValue) != null ? _a2 : "";
|
|
if (props2.triggerOnFocus && !readonly2) {
|
|
debouncedGetData(String(queryString));
|
|
}
|
|
} else {
|
|
ignoreFocusEvent = false;
|
|
}
|
|
};
|
|
const handleBlur = (evt) => {
|
|
setTimeout(() => {
|
|
var _a2;
|
|
if ((_a2 = popperRef.value) == null ? void 0 : _a2.isFocusInsideContent()) {
|
|
ignoreFocusEvent = true;
|
|
return;
|
|
}
|
|
activated.value && close2();
|
|
emit("blur", evt);
|
|
});
|
|
};
|
|
const handleClear = () => {
|
|
activated.value = false;
|
|
emit(UPDATE_MODEL_EVENT, "");
|
|
emit("clear");
|
|
};
|
|
const handleKeyEnter = async () => {
|
|
if (suggestionVisible.value && highlightedIndex.value >= 0 && highlightedIndex.value < suggestions.value.length) {
|
|
handleSelect(suggestions.value[highlightedIndex.value]);
|
|
} else if (props2.selectWhenUnmatched) {
|
|
emit("select", { value: props2.modelValue });
|
|
suggestions.value = [];
|
|
highlightedIndex.value = -1;
|
|
}
|
|
};
|
|
const handleKeyEscape = (evt) => {
|
|
if (suggestionVisible.value) {
|
|
evt.preventDefault();
|
|
evt.stopPropagation();
|
|
close2();
|
|
}
|
|
};
|
|
const close2 = () => {
|
|
activated.value = false;
|
|
};
|
|
const focus = () => {
|
|
var _a2;
|
|
(_a2 = inputRef.value) == null ? void 0 : _a2.focus();
|
|
};
|
|
const blur = () => {
|
|
var _a2;
|
|
(_a2 = inputRef.value) == null ? void 0 : _a2.blur();
|
|
};
|
|
const handleSelect = async (item) => {
|
|
emit(INPUT_EVENT, item[props2.valueKey]);
|
|
emit(UPDATE_MODEL_EVENT, item[props2.valueKey]);
|
|
emit("select", item);
|
|
suggestions.value = [];
|
|
highlightedIndex.value = -1;
|
|
};
|
|
const highlight = (index) => {
|
|
if (!suggestionVisible.value || loading.value)
|
|
return;
|
|
if (index < 0) {
|
|
highlightedIndex.value = -1;
|
|
return;
|
|
}
|
|
if (index >= suggestions.value.length) {
|
|
index = suggestions.value.length - 1;
|
|
}
|
|
const suggestion = regionRef.value.querySelector(`.${ns.be("suggestion", "wrap")}`);
|
|
const suggestionList = suggestion.querySelectorAll(`.${ns.be("suggestion", "list")} li`);
|
|
const highlightItem = suggestionList[index];
|
|
const scrollTop = suggestion.scrollTop;
|
|
const { offsetTop, scrollHeight } = highlightItem;
|
|
if (offsetTop + scrollHeight > scrollTop + suggestion.clientHeight) {
|
|
suggestion.scrollTop += scrollHeight;
|
|
}
|
|
if (offsetTop < scrollTop) {
|
|
suggestion.scrollTop -= scrollHeight;
|
|
}
|
|
highlightedIndex.value = index;
|
|
inputRef.value.ref.setAttribute("aria-activedescendant", `${listboxId.value}-item-${highlightedIndex.value}`);
|
|
};
|
|
const stopHandle = onClickOutside(listboxRef, () => {
|
|
var _a2;
|
|
if ((_a2 = popperRef.value) == null ? void 0 : _a2.isFocusInsideContent())
|
|
return;
|
|
suggestionVisible.value && close2();
|
|
});
|
|
onBeforeUnmount(() => {
|
|
stopHandle == null ? void 0 : stopHandle();
|
|
});
|
|
onMounted(() => {
|
|
inputRef.value.ref.setAttribute("role", "textbox");
|
|
inputRef.value.ref.setAttribute("aria-autocomplete", "list");
|
|
inputRef.value.ref.setAttribute("aria-controls", "id");
|
|
inputRef.value.ref.setAttribute("aria-activedescendant", `${listboxId.value}-item-${highlightedIndex.value}`);
|
|
readonly2 = inputRef.value.ref.hasAttribute("readonly");
|
|
});
|
|
expose({
|
|
highlightedIndex,
|
|
activated,
|
|
loading,
|
|
inputRef,
|
|
popperRef,
|
|
suggestions,
|
|
handleSelect,
|
|
handleKeyEnter,
|
|
focus,
|
|
blur,
|
|
close: close2,
|
|
highlight,
|
|
getData: getData2
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElTooltip), {
|
|
ref_key: "popperRef",
|
|
ref: popperRef,
|
|
visible: unref(suggestionVisible),
|
|
placement: _ctx.placement,
|
|
"fallback-placements": ["bottom-start", "top-start"],
|
|
"popper-class": [unref(ns).e("popper"), _ctx.popperClass],
|
|
teleported: _ctx.teleported,
|
|
"append-to": _ctx.appendTo,
|
|
"gpu-acceleration": false,
|
|
pure: "",
|
|
"manual-mode": "",
|
|
effect: "light",
|
|
trigger: "click",
|
|
transition: `${unref(ns).namespace.value}-zoom-in-top`,
|
|
persistent: "",
|
|
role: "listbox",
|
|
onBeforeShow: onSuggestionShow,
|
|
onHide
|
|
}, {
|
|
content: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
ref_key: "regionRef",
|
|
ref: regionRef,
|
|
class: normalizeClass([unref(ns).b("suggestion"), unref(ns).is("loading", unref(suggestionLoading))]),
|
|
style: normalizeStyle({
|
|
[_ctx.fitInputWidth ? "width" : "minWidth"]: dropdownWidth.value,
|
|
outline: "none"
|
|
}),
|
|
role: "region"
|
|
}, [
|
|
createVNode(unref(ElScrollbar), {
|
|
id: unref(listboxId),
|
|
tag: "ul",
|
|
"wrap-class": unref(ns).be("suggestion", "wrap"),
|
|
"view-class": unref(ns).be("suggestion", "list"),
|
|
role: "listbox"
|
|
}, {
|
|
default: withCtx(() => [
|
|
unref(suggestionLoading) ? (openBlock(), createElementBlock("li", { key: 0 }, [
|
|
renderSlot(_ctx.$slots, "loading", {}, () => [
|
|
createVNode(unref(ElIcon), {
|
|
class: normalizeClass(unref(ns).is("loading"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(loading_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])
|
|
])
|
|
])) : (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(suggestions.value, (item, index) => {
|
|
return openBlock(), createElementBlock("li", {
|
|
id: `${unref(listboxId)}-item-${index}`,
|
|
key: index,
|
|
class: normalizeClass({ highlighted: highlightedIndex.value === index }),
|
|
role: "option",
|
|
"aria-selected": highlightedIndex.value === index,
|
|
onClick: ($event) => handleSelect(item)
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default", { item }, () => [
|
|
createTextVNode(toDisplayString(item[_ctx.valueKey]), 1)
|
|
])
|
|
], 10, ["id", "aria-selected", "onClick"]);
|
|
}), 128))
|
|
]),
|
|
_: 3
|
|
}, 8, ["id", "wrap-class", "view-class"])
|
|
], 6)
|
|
]),
|
|
default: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
ref_key: "listboxRef",
|
|
ref: listboxRef,
|
|
class: normalizeClass([unref(ns).b(), _ctx.$attrs.class]),
|
|
style: normalizeStyle(unref(styles)),
|
|
role: "combobox",
|
|
"aria-haspopup": "listbox",
|
|
"aria-expanded": unref(suggestionVisible),
|
|
"aria-owns": unref(listboxId)
|
|
}, [
|
|
createVNode(unref(ElInput), mergeProps({
|
|
ref_key: "inputRef",
|
|
ref: inputRef
|
|
}, unref(attrs), {
|
|
clearable: _ctx.clearable,
|
|
disabled: unref(disabled),
|
|
name: _ctx.name,
|
|
"model-value": _ctx.modelValue,
|
|
"aria-label": _ctx.ariaLabel,
|
|
onInput: handleInput,
|
|
onChange: handleChange,
|
|
onFocus: handleFocus,
|
|
onBlur: handleBlur,
|
|
onClear: handleClear,
|
|
onKeydown: [
|
|
withKeys(withModifiers(($event) => highlight(highlightedIndex.value - 1), ["prevent"]), ["up"]),
|
|
withKeys(withModifiers(($event) => highlight(highlightedIndex.value + 1), ["prevent"]), ["down"]),
|
|
withKeys(handleKeyEnter, ["enter"]),
|
|
withKeys(close2, ["tab"]),
|
|
withKeys(handleKeyEscape, ["esc"])
|
|
],
|
|
onMousedown: handleMouseDown
|
|
}), createSlots({
|
|
_: 2
|
|
}, [
|
|
_ctx.$slots.prepend ? {
|
|
name: "prepend",
|
|
fn: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "prepend")
|
|
])
|
|
} : void 0,
|
|
_ctx.$slots.append ? {
|
|
name: "append",
|
|
fn: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "append")
|
|
])
|
|
} : void 0,
|
|
_ctx.$slots.prefix ? {
|
|
name: "prefix",
|
|
fn: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "prefix")
|
|
])
|
|
} : void 0,
|
|
_ctx.$slots.suffix ? {
|
|
name: "suffix",
|
|
fn: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "suffix")
|
|
])
|
|
} : void 0
|
|
]), 1040, ["clearable", "disabled", "name", "model-value", "aria-label", "onKeydown"])
|
|
], 14, ["aria-expanded", "aria-owns"])
|
|
]),
|
|
_: 3
|
|
}, 8, ["visible", "placement", "popper-class", "teleported", "append-to", "transition"]);
|
|
};
|
|
}
|
|
});
|
|
var Autocomplete = _export_sfc(_sfc_main17, [["__file", "autocomplete.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/autocomplete/index.mjs
|
|
var ElAutocomplete = withInstall(Autocomplete);
|
|
|
|
// node_modules/element-plus/es/components/avatar/src/avatar.mjs
|
|
var avatarProps = buildProps({
|
|
size: {
|
|
type: [Number, String],
|
|
values: componentSizes,
|
|
default: "",
|
|
validator: (val) => isNumber2(val)
|
|
},
|
|
shape: {
|
|
type: String,
|
|
values: ["circle", "square"],
|
|
default: "circle"
|
|
},
|
|
icon: {
|
|
type: iconPropType
|
|
},
|
|
src: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
alt: String,
|
|
srcSet: String,
|
|
fit: {
|
|
type: definePropType(String),
|
|
default: "cover"
|
|
}
|
|
});
|
|
var avatarEmits = {
|
|
error: (evt) => evt instanceof Event
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/avatar/src/avatar2.mjs
|
|
var __default__14 = defineComponent({
|
|
name: "ElAvatar"
|
|
});
|
|
var _sfc_main18 = defineComponent({
|
|
...__default__14,
|
|
props: avatarProps,
|
|
emits: avatarEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("avatar");
|
|
const hasLoadError = ref(false);
|
|
const avatarClass = computed(() => {
|
|
const { size: size3, icon, shape } = props2;
|
|
const classList = [ns.b()];
|
|
if (isString(size3))
|
|
classList.push(ns.m(size3));
|
|
if (icon)
|
|
classList.push(ns.m("icon"));
|
|
if (shape)
|
|
classList.push(ns.m(shape));
|
|
return classList;
|
|
});
|
|
const sizeStyle = computed(() => {
|
|
const { size: size3 } = props2;
|
|
return isNumber2(size3) ? ns.cssVarBlock({
|
|
size: addUnit(size3) || ""
|
|
}) : void 0;
|
|
});
|
|
const fitStyle = computed(() => ({
|
|
objectFit: props2.fit
|
|
}));
|
|
watch(() => props2.src, () => hasLoadError.value = false);
|
|
function handleError(e) {
|
|
hasLoadError.value = true;
|
|
emit("error", e);
|
|
}
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("span", {
|
|
class: normalizeClass(unref(avatarClass)),
|
|
style: normalizeStyle(unref(sizeStyle))
|
|
}, [
|
|
(_ctx.src || _ctx.srcSet) && !hasLoadError.value ? (openBlock(), createElementBlock("img", {
|
|
key: 0,
|
|
src: _ctx.src,
|
|
alt: _ctx.alt,
|
|
srcset: _ctx.srcSet,
|
|
style: normalizeStyle(unref(fitStyle)),
|
|
onError: handleError
|
|
}, null, 44, ["src", "alt", "srcset"])) : _ctx.icon ? (openBlock(), createBlock(unref(ElIcon), { key: 1 }, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
|
|
]),
|
|
_: 1
|
|
})) : renderSlot(_ctx.$slots, "default", { key: 2 })
|
|
], 6);
|
|
};
|
|
}
|
|
});
|
|
var Avatar = _export_sfc(_sfc_main18, [["__file", "avatar.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/avatar/index.mjs
|
|
var ElAvatar = withInstall(Avatar);
|
|
|
|
// node_modules/element-plus/es/components/backtop/src/backtop.mjs
|
|
var backtopProps = {
|
|
visibilityHeight: {
|
|
type: Number,
|
|
default: 200
|
|
},
|
|
target: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
right: {
|
|
type: Number,
|
|
default: 40
|
|
},
|
|
bottom: {
|
|
type: Number,
|
|
default: 40
|
|
}
|
|
};
|
|
var backtopEmits = {
|
|
click: (evt) => evt instanceof MouseEvent
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/backtop/src/use-backtop.mjs
|
|
var useBackTop = (props2, emit, componentName2) => {
|
|
const el = shallowRef();
|
|
const container = shallowRef();
|
|
const visible = ref(false);
|
|
const handleScroll2 = () => {
|
|
if (el.value)
|
|
visible.value = el.value.scrollTop >= props2.visibilityHeight;
|
|
};
|
|
const handleClick = (event) => {
|
|
var _a2;
|
|
(_a2 = el.value) == null ? void 0 : _a2.scrollTo({ top: 0, behavior: "smooth" });
|
|
emit("click", event);
|
|
};
|
|
const handleScrollThrottled = useThrottleFn(handleScroll2, 300, true);
|
|
useEventListener(container, "scroll", handleScrollThrottled);
|
|
onMounted(() => {
|
|
var _a2;
|
|
container.value = document;
|
|
el.value = document.documentElement;
|
|
if (props2.target) {
|
|
el.value = (_a2 = document.querySelector(props2.target)) != null ? _a2 : void 0;
|
|
if (!el.value) {
|
|
throwError(componentName2, `target does not exist: ${props2.target}`);
|
|
}
|
|
container.value = el.value;
|
|
}
|
|
handleScroll2();
|
|
});
|
|
return {
|
|
visible,
|
|
handleClick
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/backtop/src/backtop2.mjs
|
|
var COMPONENT_NAME6 = "ElBacktop";
|
|
var __default__15 = defineComponent({
|
|
name: COMPONENT_NAME6
|
|
});
|
|
var _sfc_main19 = defineComponent({
|
|
...__default__15,
|
|
props: backtopProps,
|
|
emits: backtopEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("backtop");
|
|
const { handleClick, visible } = useBackTop(props2, emit, COMPONENT_NAME6);
|
|
const backTopStyle = computed(() => ({
|
|
right: `${props2.right}px`,
|
|
bottom: `${props2.bottom}px`
|
|
}));
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(Transition, {
|
|
name: `${unref(ns).namespace.value}-fade-in`
|
|
}, {
|
|
default: withCtx(() => [
|
|
unref(visible) ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
style: normalizeStyle(unref(backTopStyle)),
|
|
class: normalizeClass(unref(ns).b()),
|
|
onClick: withModifiers(unref(handleClick), ["stop"])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default", {}, () => [
|
|
createVNode(unref(ElIcon), {
|
|
class: normalizeClass(unref(ns).e("icon"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(caret_top_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])
|
|
])
|
|
], 14, ["onClick"])) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 8, ["name"]);
|
|
};
|
|
}
|
|
});
|
|
var Backtop = _export_sfc(_sfc_main19, [["__file", "backtop.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/backtop/index.mjs
|
|
var ElBacktop = withInstall(Backtop);
|
|
|
|
// node_modules/element-plus/es/components/badge/src/badge.mjs
|
|
var badgeProps = buildProps({
|
|
value: {
|
|
type: [String, Number],
|
|
default: ""
|
|
},
|
|
max: {
|
|
type: Number,
|
|
default: 99
|
|
},
|
|
isDot: Boolean,
|
|
hidden: Boolean,
|
|
type: {
|
|
type: String,
|
|
values: ["primary", "success", "warning", "info", "danger"],
|
|
default: "danger"
|
|
},
|
|
showZero: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
color: String,
|
|
badgeStyle: {
|
|
type: definePropType([String, Object, Array])
|
|
},
|
|
offset: {
|
|
type: definePropType(Array),
|
|
default: [0, 0]
|
|
},
|
|
badgeClass: {
|
|
type: String
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/badge/src/badge2.mjs
|
|
var __default__16 = defineComponent({
|
|
name: "ElBadge"
|
|
});
|
|
var _sfc_main20 = defineComponent({
|
|
...__default__16,
|
|
props: badgeProps,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("badge");
|
|
const content = computed(() => {
|
|
if (props2.isDot)
|
|
return "";
|
|
if (isNumber2(props2.value) && isNumber2(props2.max)) {
|
|
return props2.max < props2.value ? `${props2.max}+` : `${props2.value}`;
|
|
}
|
|
return `${props2.value}`;
|
|
});
|
|
const style = computed(() => {
|
|
var _a2, _b, _c, _d, _e;
|
|
return [
|
|
{
|
|
backgroundColor: props2.color,
|
|
marginRight: addUnit(-((_b = (_a2 = props2.offset) == null ? void 0 : _a2[0]) != null ? _b : 0)),
|
|
marginTop: addUnit((_d = (_c = props2.offset) == null ? void 0 : _c[1]) != null ? _d : 0)
|
|
},
|
|
(_e = props2.badgeStyle) != null ? _e : {}
|
|
];
|
|
});
|
|
expose({
|
|
content
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(unref(ns).b())
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default"),
|
|
createVNode(Transition, {
|
|
name: `${unref(ns).namespace.value}-zoom-in-center`,
|
|
persisted: ""
|
|
}, {
|
|
default: withCtx(() => [
|
|
withDirectives(createBaseVNode("sup", {
|
|
class: normalizeClass([
|
|
unref(ns).e("content"),
|
|
unref(ns).em("content", _ctx.type),
|
|
unref(ns).is("fixed", !!_ctx.$slots.default),
|
|
unref(ns).is("dot", _ctx.isDot),
|
|
unref(ns).is("hide-zero", !_ctx.showZero && props2.value === 0),
|
|
_ctx.badgeClass
|
|
]),
|
|
style: normalizeStyle(unref(style))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "content", { value: unref(content) }, () => [
|
|
createTextVNode(toDisplayString(unref(content)), 1)
|
|
])
|
|
], 6), [
|
|
[vShow, !_ctx.hidden && (unref(content) || _ctx.isDot || _ctx.$slots.content)]
|
|
])
|
|
]),
|
|
_: 3
|
|
}, 8, ["name"])
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Badge = _export_sfc(_sfc_main20, [["__file", "badge.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/badge/index.mjs
|
|
var ElBadge = withInstall(Badge);
|
|
|
|
// node_modules/element-plus/es/components/breadcrumb/src/constants.mjs
|
|
var breadcrumbKey = Symbol("breadcrumbKey");
|
|
|
|
// node_modules/element-plus/es/components/breadcrumb/src/breadcrumb.mjs
|
|
var breadcrumbProps = buildProps({
|
|
separator: {
|
|
type: String,
|
|
default: "/"
|
|
},
|
|
separatorIcon: {
|
|
type: iconPropType
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/breadcrumb/src/breadcrumb-item.mjs
|
|
var breadcrumbItemProps = buildProps({
|
|
to: {
|
|
type: definePropType([String, Object]),
|
|
default: ""
|
|
},
|
|
replace: Boolean
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/breadcrumb/src/breadcrumb2.mjs
|
|
var __default__17 = defineComponent({
|
|
name: "ElBreadcrumb"
|
|
});
|
|
var _sfc_main21 = defineComponent({
|
|
...__default__17,
|
|
props: breadcrumbProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("breadcrumb");
|
|
const breadcrumb = ref();
|
|
provide(breadcrumbKey, props2);
|
|
onMounted(() => {
|
|
const items = breadcrumb.value.querySelectorAll(`.${ns.e("item")}`);
|
|
if (items.length) {
|
|
items[items.length - 1].setAttribute("aria-current", "page");
|
|
}
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "breadcrumb",
|
|
ref: breadcrumb,
|
|
class: normalizeClass(unref(ns).b()),
|
|
"aria-label": unref(t)("el.breadcrumb.label"),
|
|
role: "navigation"
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 10, ["aria-label"]);
|
|
};
|
|
}
|
|
});
|
|
var Breadcrumb = _export_sfc(_sfc_main21, [["__file", "breadcrumb.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/breadcrumb/src/breadcrumb-item2.mjs
|
|
var __default__18 = defineComponent({
|
|
name: "ElBreadcrumbItem"
|
|
});
|
|
var _sfc_main22 = defineComponent({
|
|
...__default__18,
|
|
props: breadcrumbItemProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const instance = getCurrentInstance();
|
|
const breadcrumbContext = inject(breadcrumbKey, void 0);
|
|
const ns = useNamespace("breadcrumb");
|
|
const router = instance.appContext.config.globalProperties.$router;
|
|
const link = ref();
|
|
const onClick = () => {
|
|
if (!props2.to || !router)
|
|
return;
|
|
props2.replace ? router.replace(props2.to) : router.push(props2.to);
|
|
};
|
|
return (_ctx, _cache) => {
|
|
var _a2, _b;
|
|
return openBlock(), createElementBlock("span", {
|
|
class: normalizeClass(unref(ns).e("item"))
|
|
}, [
|
|
createBaseVNode("span", {
|
|
ref_key: "link",
|
|
ref: link,
|
|
class: normalizeClass([unref(ns).e("inner"), unref(ns).is("link", !!_ctx.to)]),
|
|
role: "link",
|
|
onClick
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2),
|
|
((_a2 = unref(breadcrumbContext)) == null ? void 0 : _a2.separatorIcon) ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("separator"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(unref(breadcrumbContext).separatorIcon)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : (openBlock(), createElementBlock("span", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("separator")),
|
|
role: "presentation"
|
|
}, toDisplayString((_b = unref(breadcrumbContext)) == null ? void 0 : _b.separator), 3))
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var BreadcrumbItem = _export_sfc(_sfc_main22, [["__file", "breadcrumb-item.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/breadcrumb/index.mjs
|
|
var ElBreadcrumb = withInstall(Breadcrumb, {
|
|
BreadcrumbItem
|
|
});
|
|
var ElBreadcrumbItem = withNoopInstall(BreadcrumbItem);
|
|
|
|
// node_modules/element-plus/es/components/button/src/constants.mjs
|
|
var buttonGroupContextKey = Symbol("buttonGroupContextKey");
|
|
|
|
// node_modules/element-plus/es/hooks/use-deprecated/index.mjs
|
|
var useDeprecated = ({ from, replacement, scope, version: version4, ref: ref2, type: type4 = "API" }, condition) => {
|
|
watch(() => unref(condition), (val) => {
|
|
if (val) {
|
|
debugWarn(scope, `[${type4}] ${from} is about to be deprecated in version ${version4}, please use ${replacement} instead.
|
|
For more detail, please visit: ${ref2}
|
|
`);
|
|
}
|
|
}, {
|
|
immediate: true
|
|
});
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/button/src/button.mjs
|
|
var buttonTypes = [
|
|
"default",
|
|
"primary",
|
|
"success",
|
|
"warning",
|
|
"info",
|
|
"danger",
|
|
"text",
|
|
""
|
|
];
|
|
var buttonNativeTypes = ["button", "submit", "reset"];
|
|
var buttonProps = buildProps({
|
|
size: useSizeProp,
|
|
disabled: Boolean,
|
|
type: {
|
|
type: String,
|
|
values: buttonTypes,
|
|
default: ""
|
|
},
|
|
icon: {
|
|
type: iconPropType
|
|
},
|
|
nativeType: {
|
|
type: String,
|
|
values: buttonNativeTypes,
|
|
default: "button"
|
|
},
|
|
loading: Boolean,
|
|
loadingIcon: {
|
|
type: iconPropType,
|
|
default: () => loading_default
|
|
},
|
|
plain: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
text: Boolean,
|
|
link: Boolean,
|
|
bg: Boolean,
|
|
autofocus: Boolean,
|
|
round: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
circle: Boolean,
|
|
color: String,
|
|
dark: Boolean,
|
|
autoInsertSpace: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
tag: {
|
|
type: definePropType([String, Object]),
|
|
default: "button"
|
|
}
|
|
});
|
|
var buttonEmits = {
|
|
click: (evt) => evt instanceof MouseEvent
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/button/src/use-button.mjs
|
|
var useButton = (props2, emit) => {
|
|
useDeprecated({
|
|
from: "type.text",
|
|
replacement: "link",
|
|
version: "3.0.0",
|
|
scope: "props",
|
|
ref: "https://element-plus.org/en-US/component/button.html#button-attributes"
|
|
}, computed(() => props2.type === "text"));
|
|
const buttonGroupContext = inject(buttonGroupContextKey, void 0);
|
|
const globalConfig2 = useGlobalConfig("button");
|
|
const { form } = useFormItem();
|
|
const _size = useFormSize(computed(() => buttonGroupContext == null ? void 0 : buttonGroupContext.size));
|
|
const _disabled = useFormDisabled();
|
|
const _ref = ref();
|
|
const slots = useSlots();
|
|
const _type = computed(() => {
|
|
var _a2;
|
|
return props2.type || (buttonGroupContext == null ? void 0 : buttonGroupContext.type) || ((_a2 = globalConfig2.value) == null ? void 0 : _a2.type) || "";
|
|
});
|
|
const autoInsertSpace = computed(() => {
|
|
var _a2, _b, _c;
|
|
return (_c = (_b = props2.autoInsertSpace) != null ? _b : (_a2 = globalConfig2.value) == null ? void 0 : _a2.autoInsertSpace) != null ? _c : false;
|
|
});
|
|
const _plain = computed(() => {
|
|
var _a2, _b, _c;
|
|
return (_c = (_b = props2.plain) != null ? _b : (_a2 = globalConfig2.value) == null ? void 0 : _a2.plain) != null ? _c : false;
|
|
});
|
|
const _round = computed(() => {
|
|
var _a2, _b, _c;
|
|
return (_c = (_b = props2.round) != null ? _b : (_a2 = globalConfig2.value) == null ? void 0 : _a2.round) != null ? _c : false;
|
|
});
|
|
const _props = computed(() => {
|
|
if (props2.tag === "button") {
|
|
return {
|
|
ariaDisabled: _disabled.value || props2.loading,
|
|
disabled: _disabled.value || props2.loading,
|
|
autofocus: props2.autofocus,
|
|
type: props2.nativeType
|
|
};
|
|
}
|
|
return {};
|
|
});
|
|
const shouldAddSpace = computed(() => {
|
|
var _a2;
|
|
const defaultSlot = (_a2 = slots.default) == null ? void 0 : _a2.call(slots);
|
|
if (autoInsertSpace.value && (defaultSlot == null ? void 0 : defaultSlot.length) === 1) {
|
|
const slot = defaultSlot[0];
|
|
if ((slot == null ? void 0 : slot.type) === Text) {
|
|
const text = slot.children;
|
|
return /^\p{Unified_Ideograph}{2}$/u.test(text.trim());
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
const handleClick = (evt) => {
|
|
if (_disabled.value || props2.loading) {
|
|
evt.stopPropagation();
|
|
return;
|
|
}
|
|
if (props2.nativeType === "reset") {
|
|
form == null ? void 0 : form.resetFields();
|
|
}
|
|
emit("click", evt);
|
|
};
|
|
return {
|
|
_disabled,
|
|
_size,
|
|
_type,
|
|
_ref,
|
|
_props,
|
|
_plain,
|
|
_round,
|
|
shouldAddSpace,
|
|
handleClick
|
|
};
|
|
};
|
|
|
|
// node_modules/@ctrl/tinycolor/dist/module/util.js
|
|
function bound01(n, max4) {
|
|
if (isOnePointZero(n)) {
|
|
n = "100%";
|
|
}
|
|
var isPercent = isPercentage(n);
|
|
n = max4 === 360 ? n : Math.min(max4, Math.max(0, parseFloat(n)));
|
|
if (isPercent) {
|
|
n = parseInt(String(n * max4), 10) / 100;
|
|
}
|
|
if (Math.abs(n - max4) < 1e-6) {
|
|
return 1;
|
|
}
|
|
if (max4 === 360) {
|
|
n = (n < 0 ? n % max4 + max4 : n % max4) / parseFloat(String(max4));
|
|
} else {
|
|
n = n % max4 / parseFloat(String(max4));
|
|
}
|
|
return n;
|
|
}
|
|
function clamp01(val) {
|
|
return Math.min(1, Math.max(0, val));
|
|
}
|
|
function isOnePointZero(n) {
|
|
return typeof n === "string" && n.indexOf(".") !== -1 && parseFloat(n) === 1;
|
|
}
|
|
function isPercentage(n) {
|
|
return typeof n === "string" && n.indexOf("%") !== -1;
|
|
}
|
|
function boundAlpha(a2) {
|
|
a2 = parseFloat(a2);
|
|
if (isNaN(a2) || a2 < 0 || a2 > 1) {
|
|
a2 = 1;
|
|
}
|
|
return a2;
|
|
}
|
|
function convertToPercentage(n) {
|
|
if (n <= 1) {
|
|
return "".concat(Number(n) * 100, "%");
|
|
}
|
|
return n;
|
|
}
|
|
function pad2(c2) {
|
|
return c2.length === 1 ? "0" + c2 : String(c2);
|
|
}
|
|
|
|
// node_modules/@ctrl/tinycolor/dist/module/conversion.js
|
|
function rgbToRgb(r, g, b2) {
|
|
return {
|
|
r: bound01(r, 255) * 255,
|
|
g: bound01(g, 255) * 255,
|
|
b: bound01(b2, 255) * 255
|
|
};
|
|
}
|
|
function rgbToHsl(r, g, b2) {
|
|
r = bound01(r, 255);
|
|
g = bound01(g, 255);
|
|
b2 = bound01(b2, 255);
|
|
var max4 = Math.max(r, g, b2);
|
|
var min4 = Math.min(r, g, b2);
|
|
var h3 = 0;
|
|
var s2 = 0;
|
|
var l2 = (max4 + min4) / 2;
|
|
if (max4 === min4) {
|
|
s2 = 0;
|
|
h3 = 0;
|
|
} else {
|
|
var d2 = max4 - min4;
|
|
s2 = l2 > 0.5 ? d2 / (2 - max4 - min4) : d2 / (max4 + min4);
|
|
switch (max4) {
|
|
case r:
|
|
h3 = (g - b2) / d2 + (g < b2 ? 6 : 0);
|
|
break;
|
|
case g:
|
|
h3 = (b2 - r) / d2 + 2;
|
|
break;
|
|
case b2:
|
|
h3 = (r - g) / d2 + 4;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
h3 /= 6;
|
|
}
|
|
return { h: h3, s: s2, l: l2 };
|
|
}
|
|
function hue2rgb(p2, q2, t) {
|
|
if (t < 0) {
|
|
t += 1;
|
|
}
|
|
if (t > 1) {
|
|
t -= 1;
|
|
}
|
|
if (t < 1 / 6) {
|
|
return p2 + (q2 - p2) * (6 * t);
|
|
}
|
|
if (t < 1 / 2) {
|
|
return q2;
|
|
}
|
|
if (t < 2 / 3) {
|
|
return p2 + (q2 - p2) * (2 / 3 - t) * 6;
|
|
}
|
|
return p2;
|
|
}
|
|
function hslToRgb(h3, s2, l2) {
|
|
var r;
|
|
var g;
|
|
var b2;
|
|
h3 = bound01(h3, 360);
|
|
s2 = bound01(s2, 100);
|
|
l2 = bound01(l2, 100);
|
|
if (s2 === 0) {
|
|
g = l2;
|
|
b2 = l2;
|
|
r = l2;
|
|
} else {
|
|
var q2 = l2 < 0.5 ? l2 * (1 + s2) : l2 + s2 - l2 * s2;
|
|
var p2 = 2 * l2 - q2;
|
|
r = hue2rgb(p2, q2, h3 + 1 / 3);
|
|
g = hue2rgb(p2, q2, h3);
|
|
b2 = hue2rgb(p2, q2, h3 - 1 / 3);
|
|
}
|
|
return { r: r * 255, g: g * 255, b: b2 * 255 };
|
|
}
|
|
function rgbToHsv(r, g, b2) {
|
|
r = bound01(r, 255);
|
|
g = bound01(g, 255);
|
|
b2 = bound01(b2, 255);
|
|
var max4 = Math.max(r, g, b2);
|
|
var min4 = Math.min(r, g, b2);
|
|
var h3 = 0;
|
|
var v2 = max4;
|
|
var d2 = max4 - min4;
|
|
var s2 = max4 === 0 ? 0 : d2 / max4;
|
|
if (max4 === min4) {
|
|
h3 = 0;
|
|
} else {
|
|
switch (max4) {
|
|
case r:
|
|
h3 = (g - b2) / d2 + (g < b2 ? 6 : 0);
|
|
break;
|
|
case g:
|
|
h3 = (b2 - r) / d2 + 2;
|
|
break;
|
|
case b2:
|
|
h3 = (r - g) / d2 + 4;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
h3 /= 6;
|
|
}
|
|
return { h: h3, s: s2, v: v2 };
|
|
}
|
|
function hsvToRgb(h3, s2, v2) {
|
|
h3 = bound01(h3, 360) * 6;
|
|
s2 = bound01(s2, 100);
|
|
v2 = bound01(v2, 100);
|
|
var i = Math.floor(h3);
|
|
var f2 = h3 - i;
|
|
var p2 = v2 * (1 - s2);
|
|
var q2 = v2 * (1 - f2 * s2);
|
|
var t = v2 * (1 - (1 - f2) * s2);
|
|
var mod = i % 6;
|
|
var r = [v2, q2, p2, p2, t, v2][mod];
|
|
var g = [t, v2, v2, q2, p2, p2][mod];
|
|
var b2 = [p2, p2, t, v2, v2, q2][mod];
|
|
return { r: r * 255, g: g * 255, b: b2 * 255 };
|
|
}
|
|
function rgbToHex(r, g, b2, allow3Char) {
|
|
var hex2 = [
|
|
pad2(Math.round(r).toString(16)),
|
|
pad2(Math.round(g).toString(16)),
|
|
pad2(Math.round(b2).toString(16))
|
|
];
|
|
if (allow3Char && hex2[0].startsWith(hex2[0].charAt(1)) && hex2[1].startsWith(hex2[1].charAt(1)) && hex2[2].startsWith(hex2[2].charAt(1))) {
|
|
return hex2[0].charAt(0) + hex2[1].charAt(0) + hex2[2].charAt(0);
|
|
}
|
|
return hex2.join("");
|
|
}
|
|
function rgbaToHex(r, g, b2, a2, allow4Char) {
|
|
var hex2 = [
|
|
pad2(Math.round(r).toString(16)),
|
|
pad2(Math.round(g).toString(16)),
|
|
pad2(Math.round(b2).toString(16)),
|
|
pad2(convertDecimalToHex(a2))
|
|
];
|
|
if (allow4Char && hex2[0].startsWith(hex2[0].charAt(1)) && hex2[1].startsWith(hex2[1].charAt(1)) && hex2[2].startsWith(hex2[2].charAt(1)) && hex2[3].startsWith(hex2[3].charAt(1))) {
|
|
return hex2[0].charAt(0) + hex2[1].charAt(0) + hex2[2].charAt(0) + hex2[3].charAt(0);
|
|
}
|
|
return hex2.join("");
|
|
}
|
|
function convertDecimalToHex(d2) {
|
|
return Math.round(parseFloat(d2) * 255).toString(16);
|
|
}
|
|
function convertHexToDecimal(h3) {
|
|
return parseIntFromHex(h3) / 255;
|
|
}
|
|
function parseIntFromHex(val) {
|
|
return parseInt(val, 16);
|
|
}
|
|
function numberInputToObject(color) {
|
|
return {
|
|
r: color >> 16,
|
|
g: (color & 65280) >> 8,
|
|
b: color & 255
|
|
};
|
|
}
|
|
|
|
// node_modules/@ctrl/tinycolor/dist/module/css-color-names.js
|
|
var names = {
|
|
aliceblue: "#f0f8ff",
|
|
antiquewhite: "#faebd7",
|
|
aqua: "#00ffff",
|
|
aquamarine: "#7fffd4",
|
|
azure: "#f0ffff",
|
|
beige: "#f5f5dc",
|
|
bisque: "#ffe4c4",
|
|
black: "#000000",
|
|
blanchedalmond: "#ffebcd",
|
|
blue: "#0000ff",
|
|
blueviolet: "#8a2be2",
|
|
brown: "#a52a2a",
|
|
burlywood: "#deb887",
|
|
cadetblue: "#5f9ea0",
|
|
chartreuse: "#7fff00",
|
|
chocolate: "#d2691e",
|
|
coral: "#ff7f50",
|
|
cornflowerblue: "#6495ed",
|
|
cornsilk: "#fff8dc",
|
|
crimson: "#dc143c",
|
|
cyan: "#00ffff",
|
|
darkblue: "#00008b",
|
|
darkcyan: "#008b8b",
|
|
darkgoldenrod: "#b8860b",
|
|
darkgray: "#a9a9a9",
|
|
darkgreen: "#006400",
|
|
darkgrey: "#a9a9a9",
|
|
darkkhaki: "#bdb76b",
|
|
darkmagenta: "#8b008b",
|
|
darkolivegreen: "#556b2f",
|
|
darkorange: "#ff8c00",
|
|
darkorchid: "#9932cc",
|
|
darkred: "#8b0000",
|
|
darksalmon: "#e9967a",
|
|
darkseagreen: "#8fbc8f",
|
|
darkslateblue: "#483d8b",
|
|
darkslategray: "#2f4f4f",
|
|
darkslategrey: "#2f4f4f",
|
|
darkturquoise: "#00ced1",
|
|
darkviolet: "#9400d3",
|
|
deeppink: "#ff1493",
|
|
deepskyblue: "#00bfff",
|
|
dimgray: "#696969",
|
|
dimgrey: "#696969",
|
|
dodgerblue: "#1e90ff",
|
|
firebrick: "#b22222",
|
|
floralwhite: "#fffaf0",
|
|
forestgreen: "#228b22",
|
|
fuchsia: "#ff00ff",
|
|
gainsboro: "#dcdcdc",
|
|
ghostwhite: "#f8f8ff",
|
|
goldenrod: "#daa520",
|
|
gold: "#ffd700",
|
|
gray: "#808080",
|
|
green: "#008000",
|
|
greenyellow: "#adff2f",
|
|
grey: "#808080",
|
|
honeydew: "#f0fff0",
|
|
hotpink: "#ff69b4",
|
|
indianred: "#cd5c5c",
|
|
indigo: "#4b0082",
|
|
ivory: "#fffff0",
|
|
khaki: "#f0e68c",
|
|
lavenderblush: "#fff0f5",
|
|
lavender: "#e6e6fa",
|
|
lawngreen: "#7cfc00",
|
|
lemonchiffon: "#fffacd",
|
|
lightblue: "#add8e6",
|
|
lightcoral: "#f08080",
|
|
lightcyan: "#e0ffff",
|
|
lightgoldenrodyellow: "#fafad2",
|
|
lightgray: "#d3d3d3",
|
|
lightgreen: "#90ee90",
|
|
lightgrey: "#d3d3d3",
|
|
lightpink: "#ffb6c1",
|
|
lightsalmon: "#ffa07a",
|
|
lightseagreen: "#20b2aa",
|
|
lightskyblue: "#87cefa",
|
|
lightslategray: "#778899",
|
|
lightslategrey: "#778899",
|
|
lightsteelblue: "#b0c4de",
|
|
lightyellow: "#ffffe0",
|
|
lime: "#00ff00",
|
|
limegreen: "#32cd32",
|
|
linen: "#faf0e6",
|
|
magenta: "#ff00ff",
|
|
maroon: "#800000",
|
|
mediumaquamarine: "#66cdaa",
|
|
mediumblue: "#0000cd",
|
|
mediumorchid: "#ba55d3",
|
|
mediumpurple: "#9370db",
|
|
mediumseagreen: "#3cb371",
|
|
mediumslateblue: "#7b68ee",
|
|
mediumspringgreen: "#00fa9a",
|
|
mediumturquoise: "#48d1cc",
|
|
mediumvioletred: "#c71585",
|
|
midnightblue: "#191970",
|
|
mintcream: "#f5fffa",
|
|
mistyrose: "#ffe4e1",
|
|
moccasin: "#ffe4b5",
|
|
navajowhite: "#ffdead",
|
|
navy: "#000080",
|
|
oldlace: "#fdf5e6",
|
|
olive: "#808000",
|
|
olivedrab: "#6b8e23",
|
|
orange: "#ffa500",
|
|
orangered: "#ff4500",
|
|
orchid: "#da70d6",
|
|
palegoldenrod: "#eee8aa",
|
|
palegreen: "#98fb98",
|
|
paleturquoise: "#afeeee",
|
|
palevioletred: "#db7093",
|
|
papayawhip: "#ffefd5",
|
|
peachpuff: "#ffdab9",
|
|
peru: "#cd853f",
|
|
pink: "#ffc0cb",
|
|
plum: "#dda0dd",
|
|
powderblue: "#b0e0e6",
|
|
purple: "#800080",
|
|
rebeccapurple: "#663399",
|
|
red: "#ff0000",
|
|
rosybrown: "#bc8f8f",
|
|
royalblue: "#4169e1",
|
|
saddlebrown: "#8b4513",
|
|
salmon: "#fa8072",
|
|
sandybrown: "#f4a460",
|
|
seagreen: "#2e8b57",
|
|
seashell: "#fff5ee",
|
|
sienna: "#a0522d",
|
|
silver: "#c0c0c0",
|
|
skyblue: "#87ceeb",
|
|
slateblue: "#6a5acd",
|
|
slategray: "#708090",
|
|
slategrey: "#708090",
|
|
snow: "#fffafa",
|
|
springgreen: "#00ff7f",
|
|
steelblue: "#4682b4",
|
|
tan: "#d2b48c",
|
|
teal: "#008080",
|
|
thistle: "#d8bfd8",
|
|
tomato: "#ff6347",
|
|
turquoise: "#40e0d0",
|
|
violet: "#ee82ee",
|
|
wheat: "#f5deb3",
|
|
white: "#ffffff",
|
|
whitesmoke: "#f5f5f5",
|
|
yellow: "#ffff00",
|
|
yellowgreen: "#9acd32"
|
|
};
|
|
|
|
// node_modules/@ctrl/tinycolor/dist/module/format-input.js
|
|
function inputToRGB(color) {
|
|
var rgb = { r: 0, g: 0, b: 0 };
|
|
var a2 = 1;
|
|
var s2 = null;
|
|
var v2 = null;
|
|
var l2 = null;
|
|
var ok = false;
|
|
var format2 = false;
|
|
if (typeof color === "string") {
|
|
color = stringInputToObject(color);
|
|
}
|
|
if (typeof color === "object") {
|
|
if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
|
|
rgb = rgbToRgb(color.r, color.g, color.b);
|
|
ok = true;
|
|
format2 = String(color.r).substr(-1) === "%" ? "prgb" : "rgb";
|
|
} else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
|
|
s2 = convertToPercentage(color.s);
|
|
v2 = convertToPercentage(color.v);
|
|
rgb = hsvToRgb(color.h, s2, v2);
|
|
ok = true;
|
|
format2 = "hsv";
|
|
} else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
|
|
s2 = convertToPercentage(color.s);
|
|
l2 = convertToPercentage(color.l);
|
|
rgb = hslToRgb(color.h, s2, l2);
|
|
ok = true;
|
|
format2 = "hsl";
|
|
}
|
|
if (Object.prototype.hasOwnProperty.call(color, "a")) {
|
|
a2 = color.a;
|
|
}
|
|
}
|
|
a2 = boundAlpha(a2);
|
|
return {
|
|
ok,
|
|
format: color.format || format2,
|
|
r: Math.min(255, Math.max(rgb.r, 0)),
|
|
g: Math.min(255, Math.max(rgb.g, 0)),
|
|
b: Math.min(255, Math.max(rgb.b, 0)),
|
|
a: a2
|
|
};
|
|
}
|
|
var CSS_INTEGER = "[-\\+]?\\d+%?";
|
|
var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?";
|
|
var CSS_UNIT = "(?:".concat(CSS_NUMBER, ")|(?:").concat(CSS_INTEGER, ")");
|
|
var PERMISSIVE_MATCH3 = "[\\s|\\(]+(".concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")\\s*\\)?");
|
|
var PERMISSIVE_MATCH4 = "[\\s|\\(]+(".concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")\\s*\\)?");
|
|
var matchers = {
|
|
CSS_UNIT: new RegExp(CSS_UNIT),
|
|
rgb: new RegExp("rgb" + PERMISSIVE_MATCH3),
|
|
rgba: new RegExp("rgba" + PERMISSIVE_MATCH4),
|
|
hsl: new RegExp("hsl" + PERMISSIVE_MATCH3),
|
|
hsla: new RegExp("hsla" + PERMISSIVE_MATCH4),
|
|
hsv: new RegExp("hsv" + PERMISSIVE_MATCH3),
|
|
hsva: new RegExp("hsva" + PERMISSIVE_MATCH4),
|
|
hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
|
|
hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
|
|
hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
|
|
hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
|
|
};
|
|
function stringInputToObject(color) {
|
|
color = color.trim().toLowerCase();
|
|
if (color.length === 0) {
|
|
return false;
|
|
}
|
|
var named = false;
|
|
if (names[color]) {
|
|
color = names[color];
|
|
named = true;
|
|
} else if (color === "transparent") {
|
|
return { r: 0, g: 0, b: 0, a: 0, format: "name" };
|
|
}
|
|
var match = matchers.rgb.exec(color);
|
|
if (match) {
|
|
return { r: match[1], g: match[2], b: match[3] };
|
|
}
|
|
match = matchers.rgba.exec(color);
|
|
if (match) {
|
|
return { r: match[1], g: match[2], b: match[3], a: match[4] };
|
|
}
|
|
match = matchers.hsl.exec(color);
|
|
if (match) {
|
|
return { h: match[1], s: match[2], l: match[3] };
|
|
}
|
|
match = matchers.hsla.exec(color);
|
|
if (match) {
|
|
return { h: match[1], s: match[2], l: match[3], a: match[4] };
|
|
}
|
|
match = matchers.hsv.exec(color);
|
|
if (match) {
|
|
return { h: match[1], s: match[2], v: match[3] };
|
|
}
|
|
match = matchers.hsva.exec(color);
|
|
if (match) {
|
|
return { h: match[1], s: match[2], v: match[3], a: match[4] };
|
|
}
|
|
match = matchers.hex8.exec(color);
|
|
if (match) {
|
|
return {
|
|
r: parseIntFromHex(match[1]),
|
|
g: parseIntFromHex(match[2]),
|
|
b: parseIntFromHex(match[3]),
|
|
a: convertHexToDecimal(match[4]),
|
|
format: named ? "name" : "hex8"
|
|
};
|
|
}
|
|
match = matchers.hex6.exec(color);
|
|
if (match) {
|
|
return {
|
|
r: parseIntFromHex(match[1]),
|
|
g: parseIntFromHex(match[2]),
|
|
b: parseIntFromHex(match[3]),
|
|
format: named ? "name" : "hex"
|
|
};
|
|
}
|
|
match = matchers.hex4.exec(color);
|
|
if (match) {
|
|
return {
|
|
r: parseIntFromHex(match[1] + match[1]),
|
|
g: parseIntFromHex(match[2] + match[2]),
|
|
b: parseIntFromHex(match[3] + match[3]),
|
|
a: convertHexToDecimal(match[4] + match[4]),
|
|
format: named ? "name" : "hex8"
|
|
};
|
|
}
|
|
match = matchers.hex3.exec(color);
|
|
if (match) {
|
|
return {
|
|
r: parseIntFromHex(match[1] + match[1]),
|
|
g: parseIntFromHex(match[2] + match[2]),
|
|
b: parseIntFromHex(match[3] + match[3]),
|
|
format: named ? "name" : "hex"
|
|
};
|
|
}
|
|
return false;
|
|
}
|
|
function isValidCSSUnit(color) {
|
|
return Boolean(matchers.CSS_UNIT.exec(String(color)));
|
|
}
|
|
|
|
// node_modules/@ctrl/tinycolor/dist/module/index.js
|
|
var TinyColor = function() {
|
|
function TinyColor2(color, opts) {
|
|
if (color === void 0) {
|
|
color = "";
|
|
}
|
|
if (opts === void 0) {
|
|
opts = {};
|
|
}
|
|
var _a2;
|
|
if (color instanceof TinyColor2) {
|
|
return color;
|
|
}
|
|
if (typeof color === "number") {
|
|
color = numberInputToObject(color);
|
|
}
|
|
this.originalInput = color;
|
|
var rgb = inputToRGB(color);
|
|
this.originalInput = color;
|
|
this.r = rgb.r;
|
|
this.g = rgb.g;
|
|
this.b = rgb.b;
|
|
this.a = rgb.a;
|
|
this.roundA = Math.round(100 * this.a) / 100;
|
|
this.format = (_a2 = opts.format) !== null && _a2 !== void 0 ? _a2 : rgb.format;
|
|
this.gradientType = opts.gradientType;
|
|
if (this.r < 1) {
|
|
this.r = Math.round(this.r);
|
|
}
|
|
if (this.g < 1) {
|
|
this.g = Math.round(this.g);
|
|
}
|
|
if (this.b < 1) {
|
|
this.b = Math.round(this.b);
|
|
}
|
|
this.isValid = rgb.ok;
|
|
}
|
|
TinyColor2.prototype.isDark = function() {
|
|
return this.getBrightness() < 128;
|
|
};
|
|
TinyColor2.prototype.isLight = function() {
|
|
return !this.isDark();
|
|
};
|
|
TinyColor2.prototype.getBrightness = function() {
|
|
var rgb = this.toRgb();
|
|
return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1e3;
|
|
};
|
|
TinyColor2.prototype.getLuminance = function() {
|
|
var rgb = this.toRgb();
|
|
var R2;
|
|
var G2;
|
|
var B2;
|
|
var RsRGB = rgb.r / 255;
|
|
var GsRGB = rgb.g / 255;
|
|
var BsRGB = rgb.b / 255;
|
|
if (RsRGB <= 0.03928) {
|
|
R2 = RsRGB / 12.92;
|
|
} else {
|
|
R2 = Math.pow((RsRGB + 0.055) / 1.055, 2.4);
|
|
}
|
|
if (GsRGB <= 0.03928) {
|
|
G2 = GsRGB / 12.92;
|
|
} else {
|
|
G2 = Math.pow((GsRGB + 0.055) / 1.055, 2.4);
|
|
}
|
|
if (BsRGB <= 0.03928) {
|
|
B2 = BsRGB / 12.92;
|
|
} else {
|
|
B2 = Math.pow((BsRGB + 0.055) / 1.055, 2.4);
|
|
}
|
|
return 0.2126 * R2 + 0.7152 * G2 + 0.0722 * B2;
|
|
};
|
|
TinyColor2.prototype.getAlpha = function() {
|
|
return this.a;
|
|
};
|
|
TinyColor2.prototype.setAlpha = function(alpha) {
|
|
this.a = boundAlpha(alpha);
|
|
this.roundA = Math.round(100 * this.a) / 100;
|
|
return this;
|
|
};
|
|
TinyColor2.prototype.isMonochrome = function() {
|
|
var s2 = this.toHsl().s;
|
|
return s2 === 0;
|
|
};
|
|
TinyColor2.prototype.toHsv = function() {
|
|
var hsv = rgbToHsv(this.r, this.g, this.b);
|
|
return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this.a };
|
|
};
|
|
TinyColor2.prototype.toHsvString = function() {
|
|
var hsv = rgbToHsv(this.r, this.g, this.b);
|
|
var h3 = Math.round(hsv.h * 360);
|
|
var s2 = Math.round(hsv.s * 100);
|
|
var v2 = Math.round(hsv.v * 100);
|
|
return this.a === 1 ? "hsv(".concat(h3, ", ").concat(s2, "%, ").concat(v2, "%)") : "hsva(".concat(h3, ", ").concat(s2, "%, ").concat(v2, "%, ").concat(this.roundA, ")");
|
|
};
|
|
TinyColor2.prototype.toHsl = function() {
|
|
var hsl = rgbToHsl(this.r, this.g, this.b);
|
|
return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this.a };
|
|
};
|
|
TinyColor2.prototype.toHslString = function() {
|
|
var hsl = rgbToHsl(this.r, this.g, this.b);
|
|
var h3 = Math.round(hsl.h * 360);
|
|
var s2 = Math.round(hsl.s * 100);
|
|
var l2 = Math.round(hsl.l * 100);
|
|
return this.a === 1 ? "hsl(".concat(h3, ", ").concat(s2, "%, ").concat(l2, "%)") : "hsla(".concat(h3, ", ").concat(s2, "%, ").concat(l2, "%, ").concat(this.roundA, ")");
|
|
};
|
|
TinyColor2.prototype.toHex = function(allow3Char) {
|
|
if (allow3Char === void 0) {
|
|
allow3Char = false;
|
|
}
|
|
return rgbToHex(this.r, this.g, this.b, allow3Char);
|
|
};
|
|
TinyColor2.prototype.toHexString = function(allow3Char) {
|
|
if (allow3Char === void 0) {
|
|
allow3Char = false;
|
|
}
|
|
return "#" + this.toHex(allow3Char);
|
|
};
|
|
TinyColor2.prototype.toHex8 = function(allow4Char) {
|
|
if (allow4Char === void 0) {
|
|
allow4Char = false;
|
|
}
|
|
return rgbaToHex(this.r, this.g, this.b, this.a, allow4Char);
|
|
};
|
|
TinyColor2.prototype.toHex8String = function(allow4Char) {
|
|
if (allow4Char === void 0) {
|
|
allow4Char = false;
|
|
}
|
|
return "#" + this.toHex8(allow4Char);
|
|
};
|
|
TinyColor2.prototype.toHexShortString = function(allowShortChar) {
|
|
if (allowShortChar === void 0) {
|
|
allowShortChar = false;
|
|
}
|
|
return this.a === 1 ? this.toHexString(allowShortChar) : this.toHex8String(allowShortChar);
|
|
};
|
|
TinyColor2.prototype.toRgb = function() {
|
|
return {
|
|
r: Math.round(this.r),
|
|
g: Math.round(this.g),
|
|
b: Math.round(this.b),
|
|
a: this.a
|
|
};
|
|
};
|
|
TinyColor2.prototype.toRgbString = function() {
|
|
var r = Math.round(this.r);
|
|
var g = Math.round(this.g);
|
|
var b2 = Math.round(this.b);
|
|
return this.a === 1 ? "rgb(".concat(r, ", ").concat(g, ", ").concat(b2, ")") : "rgba(".concat(r, ", ").concat(g, ", ").concat(b2, ", ").concat(this.roundA, ")");
|
|
};
|
|
TinyColor2.prototype.toPercentageRgb = function() {
|
|
var fmt = function(x2) {
|
|
return "".concat(Math.round(bound01(x2, 255) * 100), "%");
|
|
};
|
|
return {
|
|
r: fmt(this.r),
|
|
g: fmt(this.g),
|
|
b: fmt(this.b),
|
|
a: this.a
|
|
};
|
|
};
|
|
TinyColor2.prototype.toPercentageRgbString = function() {
|
|
var rnd = function(x2) {
|
|
return Math.round(bound01(x2, 255) * 100);
|
|
};
|
|
return this.a === 1 ? "rgb(".concat(rnd(this.r), "%, ").concat(rnd(this.g), "%, ").concat(rnd(this.b), "%)") : "rgba(".concat(rnd(this.r), "%, ").concat(rnd(this.g), "%, ").concat(rnd(this.b), "%, ").concat(this.roundA, ")");
|
|
};
|
|
TinyColor2.prototype.toName = function() {
|
|
if (this.a === 0) {
|
|
return "transparent";
|
|
}
|
|
if (this.a < 1) {
|
|
return false;
|
|
}
|
|
var hex2 = "#" + rgbToHex(this.r, this.g, this.b, false);
|
|
for (var _i = 0, _a2 = Object.entries(names); _i < _a2.length; _i++) {
|
|
var _b = _a2[_i], key = _b[0], value = _b[1];
|
|
if (hex2 === value) {
|
|
return key;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
TinyColor2.prototype.toString = function(format2) {
|
|
var formatSet = Boolean(format2);
|
|
format2 = format2 !== null && format2 !== void 0 ? format2 : this.format;
|
|
var formattedString = false;
|
|
var hasAlpha = this.a < 1 && this.a >= 0;
|
|
var needsAlphaFormat = !formatSet && hasAlpha && (format2.startsWith("hex") || format2 === "name");
|
|
if (needsAlphaFormat) {
|
|
if (format2 === "name" && this.a === 0) {
|
|
return this.toName();
|
|
}
|
|
return this.toRgbString();
|
|
}
|
|
if (format2 === "rgb") {
|
|
formattedString = this.toRgbString();
|
|
}
|
|
if (format2 === "prgb") {
|
|
formattedString = this.toPercentageRgbString();
|
|
}
|
|
if (format2 === "hex" || format2 === "hex6") {
|
|
formattedString = this.toHexString();
|
|
}
|
|
if (format2 === "hex3") {
|
|
formattedString = this.toHexString(true);
|
|
}
|
|
if (format2 === "hex4") {
|
|
formattedString = this.toHex8String(true);
|
|
}
|
|
if (format2 === "hex8") {
|
|
formattedString = this.toHex8String();
|
|
}
|
|
if (format2 === "name") {
|
|
formattedString = this.toName();
|
|
}
|
|
if (format2 === "hsl") {
|
|
formattedString = this.toHslString();
|
|
}
|
|
if (format2 === "hsv") {
|
|
formattedString = this.toHsvString();
|
|
}
|
|
return formattedString || this.toHexString();
|
|
};
|
|
TinyColor2.prototype.toNumber = function() {
|
|
return (Math.round(this.r) << 16) + (Math.round(this.g) << 8) + Math.round(this.b);
|
|
};
|
|
TinyColor2.prototype.clone = function() {
|
|
return new TinyColor2(this.toString());
|
|
};
|
|
TinyColor2.prototype.lighten = function(amount) {
|
|
if (amount === void 0) {
|
|
amount = 10;
|
|
}
|
|
var hsl = this.toHsl();
|
|
hsl.l += amount / 100;
|
|
hsl.l = clamp01(hsl.l);
|
|
return new TinyColor2(hsl);
|
|
};
|
|
TinyColor2.prototype.brighten = function(amount) {
|
|
if (amount === void 0) {
|
|
amount = 10;
|
|
}
|
|
var rgb = this.toRgb();
|
|
rgb.r = Math.max(0, Math.min(255, rgb.r - Math.round(255 * -(amount / 100))));
|
|
rgb.g = Math.max(0, Math.min(255, rgb.g - Math.round(255 * -(amount / 100))));
|
|
rgb.b = Math.max(0, Math.min(255, rgb.b - Math.round(255 * -(amount / 100))));
|
|
return new TinyColor2(rgb);
|
|
};
|
|
TinyColor2.prototype.darken = function(amount) {
|
|
if (amount === void 0) {
|
|
amount = 10;
|
|
}
|
|
var hsl = this.toHsl();
|
|
hsl.l -= amount / 100;
|
|
hsl.l = clamp01(hsl.l);
|
|
return new TinyColor2(hsl);
|
|
};
|
|
TinyColor2.prototype.tint = function(amount) {
|
|
if (amount === void 0) {
|
|
amount = 10;
|
|
}
|
|
return this.mix("white", amount);
|
|
};
|
|
TinyColor2.prototype.shade = function(amount) {
|
|
if (amount === void 0) {
|
|
amount = 10;
|
|
}
|
|
return this.mix("black", amount);
|
|
};
|
|
TinyColor2.prototype.desaturate = function(amount) {
|
|
if (amount === void 0) {
|
|
amount = 10;
|
|
}
|
|
var hsl = this.toHsl();
|
|
hsl.s -= amount / 100;
|
|
hsl.s = clamp01(hsl.s);
|
|
return new TinyColor2(hsl);
|
|
};
|
|
TinyColor2.prototype.saturate = function(amount) {
|
|
if (amount === void 0) {
|
|
amount = 10;
|
|
}
|
|
var hsl = this.toHsl();
|
|
hsl.s += amount / 100;
|
|
hsl.s = clamp01(hsl.s);
|
|
return new TinyColor2(hsl);
|
|
};
|
|
TinyColor2.prototype.greyscale = function() {
|
|
return this.desaturate(100);
|
|
};
|
|
TinyColor2.prototype.spin = function(amount) {
|
|
var hsl = this.toHsl();
|
|
var hue = (hsl.h + amount) % 360;
|
|
hsl.h = hue < 0 ? 360 + hue : hue;
|
|
return new TinyColor2(hsl);
|
|
};
|
|
TinyColor2.prototype.mix = function(color, amount) {
|
|
if (amount === void 0) {
|
|
amount = 50;
|
|
}
|
|
var rgb1 = this.toRgb();
|
|
var rgb2 = new TinyColor2(color).toRgb();
|
|
var p2 = amount / 100;
|
|
var rgba = {
|
|
r: (rgb2.r - rgb1.r) * p2 + rgb1.r,
|
|
g: (rgb2.g - rgb1.g) * p2 + rgb1.g,
|
|
b: (rgb2.b - rgb1.b) * p2 + rgb1.b,
|
|
a: (rgb2.a - rgb1.a) * p2 + rgb1.a
|
|
};
|
|
return new TinyColor2(rgba);
|
|
};
|
|
TinyColor2.prototype.analogous = function(results, slices) {
|
|
if (results === void 0) {
|
|
results = 6;
|
|
}
|
|
if (slices === void 0) {
|
|
slices = 30;
|
|
}
|
|
var hsl = this.toHsl();
|
|
var part = 360 / slices;
|
|
var ret = [this];
|
|
for (hsl.h = (hsl.h - (part * results >> 1) + 720) % 360; --results; ) {
|
|
hsl.h = (hsl.h + part) % 360;
|
|
ret.push(new TinyColor2(hsl));
|
|
}
|
|
return ret;
|
|
};
|
|
TinyColor2.prototype.complement = function() {
|
|
var hsl = this.toHsl();
|
|
hsl.h = (hsl.h + 180) % 360;
|
|
return new TinyColor2(hsl);
|
|
};
|
|
TinyColor2.prototype.monochromatic = function(results) {
|
|
if (results === void 0) {
|
|
results = 6;
|
|
}
|
|
var hsv = this.toHsv();
|
|
var h3 = hsv.h;
|
|
var s2 = hsv.s;
|
|
var v2 = hsv.v;
|
|
var res = [];
|
|
var modification = 1 / results;
|
|
while (results--) {
|
|
res.push(new TinyColor2({ h: h3, s: s2, v: v2 }));
|
|
v2 = (v2 + modification) % 1;
|
|
}
|
|
return res;
|
|
};
|
|
TinyColor2.prototype.splitcomplement = function() {
|
|
var hsl = this.toHsl();
|
|
var h3 = hsl.h;
|
|
return [
|
|
this,
|
|
new TinyColor2({ h: (h3 + 72) % 360, s: hsl.s, l: hsl.l }),
|
|
new TinyColor2({ h: (h3 + 216) % 360, s: hsl.s, l: hsl.l })
|
|
];
|
|
};
|
|
TinyColor2.prototype.onBackground = function(background) {
|
|
var fg = this.toRgb();
|
|
var bg = new TinyColor2(background).toRgb();
|
|
var alpha = fg.a + bg.a * (1 - fg.a);
|
|
return new TinyColor2({
|
|
r: (fg.r * fg.a + bg.r * bg.a * (1 - fg.a)) / alpha,
|
|
g: (fg.g * fg.a + bg.g * bg.a * (1 - fg.a)) / alpha,
|
|
b: (fg.b * fg.a + bg.b * bg.a * (1 - fg.a)) / alpha,
|
|
a: alpha
|
|
});
|
|
};
|
|
TinyColor2.prototype.triad = function() {
|
|
return this.polyad(3);
|
|
};
|
|
TinyColor2.prototype.tetrad = function() {
|
|
return this.polyad(4);
|
|
};
|
|
TinyColor2.prototype.polyad = function(n) {
|
|
var hsl = this.toHsl();
|
|
var h3 = hsl.h;
|
|
var result2 = [this];
|
|
var increment = 360 / n;
|
|
for (var i = 1; i < n; i++) {
|
|
result2.push(new TinyColor2({ h: (h3 + i * increment) % 360, s: hsl.s, l: hsl.l }));
|
|
}
|
|
return result2;
|
|
};
|
|
TinyColor2.prototype.equals = function(color) {
|
|
return this.toRgbString() === new TinyColor2(color).toRgbString();
|
|
};
|
|
return TinyColor2;
|
|
}();
|
|
|
|
// node_modules/element-plus/es/components/button/src/button-custom.mjs
|
|
function darken(color, amount = 20) {
|
|
return color.mix("#141414", amount).toString();
|
|
}
|
|
function useButtonCustomStyle(props2) {
|
|
const _disabled = useFormDisabled();
|
|
const ns = useNamespace("button");
|
|
return computed(() => {
|
|
let styles = {};
|
|
let buttonColor = props2.color;
|
|
if (buttonColor) {
|
|
const match = buttonColor.match(/var\((.*?)\)/);
|
|
if (match) {
|
|
buttonColor = window.getComputedStyle(window.document.documentElement).getPropertyValue(match[1]);
|
|
}
|
|
const color = new TinyColor(buttonColor);
|
|
const activeBgColor = props2.dark ? color.tint(20).toString() : darken(color, 20);
|
|
if (props2.plain) {
|
|
styles = ns.cssVarBlock({
|
|
"bg-color": props2.dark ? darken(color, 90) : color.tint(90).toString(),
|
|
"text-color": buttonColor,
|
|
"border-color": props2.dark ? darken(color, 50) : color.tint(50).toString(),
|
|
"hover-text-color": `var(${ns.cssVarName("color-white")})`,
|
|
"hover-bg-color": buttonColor,
|
|
"hover-border-color": buttonColor,
|
|
"active-bg-color": activeBgColor,
|
|
"active-text-color": `var(${ns.cssVarName("color-white")})`,
|
|
"active-border-color": activeBgColor
|
|
});
|
|
if (_disabled.value) {
|
|
styles[ns.cssVarBlockName("disabled-bg-color")] = props2.dark ? darken(color, 90) : color.tint(90).toString();
|
|
styles[ns.cssVarBlockName("disabled-text-color")] = props2.dark ? darken(color, 50) : color.tint(50).toString();
|
|
styles[ns.cssVarBlockName("disabled-border-color")] = props2.dark ? darken(color, 80) : color.tint(80).toString();
|
|
}
|
|
} else {
|
|
const hoverBgColor = props2.dark ? darken(color, 30) : color.tint(30).toString();
|
|
const textColor = color.isDark() ? `var(${ns.cssVarName("color-white")})` : `var(${ns.cssVarName("color-black")})`;
|
|
styles = ns.cssVarBlock({
|
|
"bg-color": buttonColor,
|
|
"text-color": textColor,
|
|
"border-color": buttonColor,
|
|
"hover-bg-color": hoverBgColor,
|
|
"hover-text-color": textColor,
|
|
"hover-border-color": hoverBgColor,
|
|
"active-bg-color": activeBgColor,
|
|
"active-border-color": activeBgColor
|
|
});
|
|
if (_disabled.value) {
|
|
const disabledButtonColor = props2.dark ? darken(color, 50) : color.tint(50).toString();
|
|
styles[ns.cssVarBlockName("disabled-bg-color")] = disabledButtonColor;
|
|
styles[ns.cssVarBlockName("disabled-text-color")] = props2.dark ? "rgba(255, 255, 255, 0.5)" : `var(${ns.cssVarName("color-white")})`;
|
|
styles[ns.cssVarBlockName("disabled-border-color")] = disabledButtonColor;
|
|
}
|
|
}
|
|
}
|
|
return styles;
|
|
});
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/button/src/button2.mjs
|
|
var __default__19 = defineComponent({
|
|
name: "ElButton"
|
|
});
|
|
var _sfc_main23 = defineComponent({
|
|
...__default__19,
|
|
props: buttonProps,
|
|
emits: buttonEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const buttonStyle = useButtonCustomStyle(props2);
|
|
const ns = useNamespace("button");
|
|
const {
|
|
_ref,
|
|
_size,
|
|
_type,
|
|
_disabled,
|
|
_props,
|
|
_plain,
|
|
_round,
|
|
shouldAddSpace,
|
|
handleClick
|
|
} = useButton(props2, emit);
|
|
const buttonKls = computed(() => [
|
|
ns.b(),
|
|
ns.m(_type.value),
|
|
ns.m(_size.value),
|
|
ns.is("disabled", _disabled.value),
|
|
ns.is("loading", props2.loading),
|
|
ns.is("plain", _plain.value),
|
|
ns.is("round", _round.value),
|
|
ns.is("circle", props2.circle),
|
|
ns.is("text", props2.text),
|
|
ns.is("link", props2.link),
|
|
ns.is("has-bg", props2.bg)
|
|
]);
|
|
expose({
|
|
ref: _ref,
|
|
size: _size,
|
|
type: _type,
|
|
disabled: _disabled,
|
|
shouldAddSpace
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(resolveDynamicComponent(_ctx.tag), mergeProps({
|
|
ref_key: "_ref",
|
|
ref: _ref
|
|
}, unref(_props), {
|
|
class: unref(buttonKls),
|
|
style: unref(buttonStyle),
|
|
onClick: unref(handleClick)
|
|
}), {
|
|
default: withCtx(() => [
|
|
_ctx.loading ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
|
|
_ctx.$slots.loading ? renderSlot(_ctx.$slots, "loading", { key: 0 }) : (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).is("loading"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.loadingIcon)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"]))
|
|
], 64)) : _ctx.icon || _ctx.$slots.icon ? (openBlock(), createBlock(unref(ElIcon), { key: 1 }, {
|
|
default: withCtx(() => [
|
|
_ctx.icon ? (openBlock(), createBlock(resolveDynamicComponent(_ctx.icon), { key: 0 })) : renderSlot(_ctx.$slots, "icon", { key: 1 })
|
|
]),
|
|
_: 3
|
|
})) : createCommentVNode("v-if", true),
|
|
_ctx.$slots.default ? (openBlock(), createElementBlock("span", {
|
|
key: 2,
|
|
class: normalizeClass({ [unref(ns).em("text", "expand")]: unref(shouldAddSpace) })
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 16, ["class", "style", "onClick"]);
|
|
};
|
|
}
|
|
});
|
|
var Button = _export_sfc(_sfc_main23, [["__file", "button.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/button/src/button-group.mjs
|
|
var buttonGroupProps = {
|
|
size: buttonProps.size,
|
|
type: buttonProps.type
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/button/src/button-group2.mjs
|
|
var __default__20 = defineComponent({
|
|
name: "ElButtonGroup"
|
|
});
|
|
var _sfc_main24 = defineComponent({
|
|
...__default__20,
|
|
props: buttonGroupProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
provide(buttonGroupContextKey, reactive({
|
|
size: toRef(props2, "size"),
|
|
type: toRef(props2, "type")
|
|
}));
|
|
const ns = useNamespace("button");
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(unref(ns).b("group"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var ButtonGroup = _export_sfc(_sfc_main24, [["__file", "button-group.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/button/index.mjs
|
|
var ElButton = withInstall(Button, {
|
|
ButtonGroup
|
|
});
|
|
var ElButtonGroup = withNoopInstall(ButtonGroup);
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/utils.mjs
|
|
var import_dayjs = __toModule(require_dayjs_min());
|
|
var buildTimeList = (value, bound) => {
|
|
return [
|
|
value > 0 ? value - 1 : void 0,
|
|
value,
|
|
value < bound ? value + 1 : void 0
|
|
];
|
|
};
|
|
var rangeArr = (n) => Array.from(Array.from({ length: n }).keys());
|
|
var extractDateFormat = (format2) => {
|
|
return format2.replace(/\W?m{1,2}|\W?ZZ/g, "").replace(/\W?h{1,2}|\W?s{1,3}|\W?a/gi, "").trim();
|
|
};
|
|
var extractTimeFormat = (format2) => {
|
|
return format2.replace(/\W?D{1,2}|\W?Do|\W?d{1,4}|\W?M{1,4}|\W?Y{2,4}/g, "").trim();
|
|
};
|
|
var dateEquals = function(a2, b2) {
|
|
const aIsDate = isDate(a2);
|
|
const bIsDate = isDate(b2);
|
|
if (aIsDate && bIsDate) {
|
|
return a2.getTime() === b2.getTime();
|
|
}
|
|
if (!aIsDate && !bIsDate) {
|
|
return a2 === b2;
|
|
}
|
|
return false;
|
|
};
|
|
var valueEquals = function(a2, b2) {
|
|
const aIsArray = isArray(a2);
|
|
const bIsArray = isArray(b2);
|
|
if (aIsArray && bIsArray) {
|
|
if (a2.length !== b2.length) {
|
|
return false;
|
|
}
|
|
return a2.every((item, index) => dateEquals(item, b2[index]));
|
|
}
|
|
if (!aIsArray && !bIsArray) {
|
|
return dateEquals(a2, b2);
|
|
}
|
|
return false;
|
|
};
|
|
var parseDate = function(date4, format2, lang) {
|
|
const day = isEmpty2(format2) || format2 === "x" ? (0, import_dayjs.default)(date4).locale(lang) : (0, import_dayjs.default)(date4, format2).locale(lang);
|
|
return day.isValid() ? day : void 0;
|
|
};
|
|
var formatter = function(date4, format2, lang) {
|
|
if (isEmpty2(format2))
|
|
return date4;
|
|
if (format2 === "x")
|
|
return +date4;
|
|
return (0, import_dayjs.default)(date4).locale(lang).format(format2);
|
|
};
|
|
var makeList = (total2, method5) => {
|
|
var _a2;
|
|
const arr = [];
|
|
const disabledArr = method5 == null ? void 0 : method5();
|
|
for (let i = 0; i < total2; i++) {
|
|
arr.push((_a2 = disabledArr == null ? void 0 : disabledArr.includes(i)) != null ? _a2 : false);
|
|
}
|
|
return arr;
|
|
};
|
|
var dayOrDaysToDate = (dayOrDays) => {
|
|
return isArray(dayOrDays) ? dayOrDays.map((d2) => d2.toDate()) : dayOrDays.toDate();
|
|
};
|
|
|
|
// node_modules/element-plus/es/constants/date.mjs
|
|
var datePickTypes = [
|
|
"year",
|
|
"years",
|
|
"month",
|
|
"months",
|
|
"date",
|
|
"dates",
|
|
"week",
|
|
"datetime",
|
|
"datetimerange",
|
|
"daterange",
|
|
"monthrange",
|
|
"yearrange"
|
|
];
|
|
var WEEK_DAYS = [
|
|
"sun",
|
|
"mon",
|
|
"tue",
|
|
"wed",
|
|
"thu",
|
|
"fri",
|
|
"sat"
|
|
];
|
|
|
|
// node_modules/element-plus/es/components/calendar/src/calendar.mjs
|
|
var isValidRange = (range4) => isArray(range4) && range4.length === 2 && range4.every((item) => isDate(item));
|
|
var calendarProps = buildProps({
|
|
modelValue: {
|
|
type: Date
|
|
},
|
|
range: {
|
|
type: definePropType(Array),
|
|
validator: isValidRange
|
|
}
|
|
});
|
|
var calendarEmits = {
|
|
[UPDATE_MODEL_EVENT]: (value) => isDate(value),
|
|
[INPUT_EVENT]: (value) => isDate(value)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/calendar/src/date-table.mjs
|
|
var getPrevMonthLastDays = (date4, count) => {
|
|
const lastDay = date4.subtract(1, "month").endOf("month").date();
|
|
return rangeArr(count).map((_2, index) => lastDay - (count - index - 1));
|
|
};
|
|
var getMonthDays = (date4) => {
|
|
const days = date4.daysInMonth();
|
|
return rangeArr(days).map((_2, index) => index + 1);
|
|
};
|
|
var toNestedArr = (days) => rangeArr(days.length / 7).map((index) => {
|
|
const start = index * 7;
|
|
return days.slice(start, start + 7);
|
|
});
|
|
var dateTableProps = buildProps({
|
|
selectedDay: {
|
|
type: definePropType(Object)
|
|
},
|
|
range: {
|
|
type: definePropType(Array)
|
|
},
|
|
date: {
|
|
type: definePropType(Object),
|
|
required: true
|
|
},
|
|
hideHeader: {
|
|
type: Boolean
|
|
}
|
|
});
|
|
var dateTableEmits = {
|
|
pick: (value) => isObject(value)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/calendar/src/use-date-table.mjs
|
|
var import_dayjs2 = __toModule(require_dayjs_min());
|
|
var import_localeData = __toModule(require_localeData());
|
|
var useDateTable = (props2, emit) => {
|
|
import_dayjs2.default.extend(import_localeData.default);
|
|
const firstDayOfWeek = import_dayjs2.default.localeData().firstDayOfWeek();
|
|
const { t, lang } = useLocale();
|
|
const now2 = (0, import_dayjs2.default)().locale(lang.value);
|
|
const isInRange = computed(() => !!props2.range && !!props2.range.length);
|
|
const rows = computed(() => {
|
|
let days = [];
|
|
if (isInRange.value) {
|
|
const [start, end] = props2.range;
|
|
const currentMonthRange = rangeArr(end.date() - start.date() + 1).map((index) => ({
|
|
text: start.date() + index,
|
|
type: "current"
|
|
}));
|
|
let remaining = currentMonthRange.length % 7;
|
|
remaining = remaining === 0 ? 0 : 7 - remaining;
|
|
const nextMonthRange = rangeArr(remaining).map((_2, index) => ({
|
|
text: index + 1,
|
|
type: "next"
|
|
}));
|
|
days = currentMonthRange.concat(nextMonthRange);
|
|
} else {
|
|
const firstDay = props2.date.startOf("month").day();
|
|
const prevMonthDays = getPrevMonthLastDays(props2.date, (firstDay - firstDayOfWeek + 7) % 7).map((day) => ({
|
|
text: day,
|
|
type: "prev"
|
|
}));
|
|
const currentMonthDays = getMonthDays(props2.date).map((day) => ({
|
|
text: day,
|
|
type: "current"
|
|
}));
|
|
days = [...prevMonthDays, ...currentMonthDays];
|
|
const remaining = 7 - (days.length % 7 || 7);
|
|
const nextMonthDays = rangeArr(remaining).map((_2, index) => ({
|
|
text: index + 1,
|
|
type: "next"
|
|
}));
|
|
days = days.concat(nextMonthDays);
|
|
}
|
|
return toNestedArr(days);
|
|
});
|
|
const weekDays = computed(() => {
|
|
const start = firstDayOfWeek;
|
|
if (start === 0) {
|
|
return WEEK_DAYS.map((_2) => t(`el.datepicker.weeks.${_2}`));
|
|
} else {
|
|
return WEEK_DAYS.slice(start).concat(WEEK_DAYS.slice(0, start)).map((_2) => t(`el.datepicker.weeks.${_2}`));
|
|
}
|
|
});
|
|
const getFormattedDate = (day, type4) => {
|
|
switch (type4) {
|
|
case "prev":
|
|
return props2.date.startOf("month").subtract(1, "month").date(day);
|
|
case "next":
|
|
return props2.date.startOf("month").add(1, "month").date(day);
|
|
case "current":
|
|
return props2.date.date(day);
|
|
}
|
|
};
|
|
const handlePickDay = ({ text, type: type4 }) => {
|
|
const date4 = getFormattedDate(text, type4);
|
|
emit("pick", date4);
|
|
};
|
|
const getSlotData = ({ text, type: type4 }) => {
|
|
const day = getFormattedDate(text, type4);
|
|
return {
|
|
isSelected: day.isSame(props2.selectedDay),
|
|
type: `${type4}-month`,
|
|
day: day.format("YYYY-MM-DD"),
|
|
date: day.toDate()
|
|
};
|
|
};
|
|
return {
|
|
now: now2,
|
|
isInRange,
|
|
rows,
|
|
weekDays,
|
|
getFormattedDate,
|
|
handlePickDay,
|
|
getSlotData
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/calendar/src/date-table2.mjs
|
|
var __default__21 = defineComponent({
|
|
name: "DateTable"
|
|
});
|
|
var _sfc_main25 = defineComponent({
|
|
...__default__21,
|
|
props: dateTableProps,
|
|
emits: dateTableEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const {
|
|
isInRange,
|
|
now: now2,
|
|
rows,
|
|
weekDays,
|
|
getFormattedDate,
|
|
handlePickDay,
|
|
getSlotData
|
|
} = useDateTable(props2, emit);
|
|
const nsTable = useNamespace("calendar-table");
|
|
const nsDay = useNamespace("calendar-day");
|
|
const getCellClass = ({ text, type: type4 }) => {
|
|
const classes = [type4];
|
|
if (type4 === "current") {
|
|
const date4 = getFormattedDate(text, type4);
|
|
if (date4.isSame(props2.selectedDay, "day")) {
|
|
classes.push(nsDay.is("selected"));
|
|
}
|
|
if (date4.isSame(now2, "day")) {
|
|
classes.push(nsDay.is("today"));
|
|
}
|
|
}
|
|
return classes;
|
|
};
|
|
expose({
|
|
getFormattedDate
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("table", {
|
|
class: normalizeClass([unref(nsTable).b(), unref(nsTable).is("range", unref(isInRange))]),
|
|
cellspacing: "0",
|
|
cellpadding: "0"
|
|
}, [
|
|
!_ctx.hideHeader ? (openBlock(), createElementBlock("thead", { key: 0 }, [
|
|
createBaseVNode("tr", null, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(weekDays), (day) => {
|
|
return openBlock(), createElementBlock("th", {
|
|
key: day,
|
|
scope: "col"
|
|
}, toDisplayString(day), 1);
|
|
}), 128))
|
|
])
|
|
])) : createCommentVNode("v-if", true),
|
|
createBaseVNode("tbody", null, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(rows), (row, index) => {
|
|
return openBlock(), createElementBlock("tr", {
|
|
key: index,
|
|
class: normalizeClass({
|
|
[unref(nsTable).e("row")]: true,
|
|
[unref(nsTable).em("row", "hide-border")]: index === 0 && _ctx.hideHeader
|
|
})
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(row, (cell, key) => {
|
|
return openBlock(), createElementBlock("td", {
|
|
key,
|
|
class: normalizeClass(getCellClass(cell)),
|
|
onClick: ($event) => unref(handlePickDay)(cell)
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(nsDay).b())
|
|
}, [
|
|
renderSlot(_ctx.$slots, "date-cell", {
|
|
data: unref(getSlotData)(cell)
|
|
}, () => [
|
|
createBaseVNode("span", null, toDisplayString(cell.text), 1)
|
|
])
|
|
], 2)
|
|
], 10, ["onClick"]);
|
|
}), 128))
|
|
], 2);
|
|
}), 128))
|
|
])
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var DateTable = _export_sfc(_sfc_main25, [["__file", "date-table.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/calendar/src/use-calendar.mjs
|
|
var import_dayjs3 = __toModule(require_dayjs_min());
|
|
var adjacentMonth = (start, end) => {
|
|
const firstMonthLastDay = start.endOf("month");
|
|
const lastMonthFirstDay = end.startOf("month");
|
|
const isSameWeek = firstMonthLastDay.isSame(lastMonthFirstDay, "week");
|
|
const lastMonthStartDay = isSameWeek ? lastMonthFirstDay.add(1, "week") : lastMonthFirstDay;
|
|
return [
|
|
[start, firstMonthLastDay],
|
|
[lastMonthStartDay.startOf("week"), end]
|
|
];
|
|
};
|
|
var threeConsecutiveMonth = (start, end) => {
|
|
const firstMonthLastDay = start.endOf("month");
|
|
const secondMonthFirstDay = start.add(1, "month").startOf("month");
|
|
const secondMonthStartDay = firstMonthLastDay.isSame(secondMonthFirstDay, "week") ? secondMonthFirstDay.add(1, "week") : secondMonthFirstDay;
|
|
const secondMonthLastDay = secondMonthStartDay.endOf("month");
|
|
const lastMonthFirstDay = end.startOf("month");
|
|
const lastMonthStartDay = secondMonthLastDay.isSame(lastMonthFirstDay, "week") ? lastMonthFirstDay.add(1, "week") : lastMonthFirstDay;
|
|
return [
|
|
[start, firstMonthLastDay],
|
|
[secondMonthStartDay.startOf("week"), secondMonthLastDay],
|
|
[lastMonthStartDay.startOf("week"), end]
|
|
];
|
|
};
|
|
var useCalendar = (props2, emit, componentName2) => {
|
|
const { lang } = useLocale();
|
|
const selectedDay = ref();
|
|
const now2 = (0, import_dayjs3.default)().locale(lang.value);
|
|
const realSelectedDay = computed({
|
|
get() {
|
|
if (!props2.modelValue)
|
|
return selectedDay.value;
|
|
return date4.value;
|
|
},
|
|
set(val) {
|
|
if (!val)
|
|
return;
|
|
selectedDay.value = val;
|
|
const result2 = val.toDate();
|
|
emit(INPUT_EVENT, result2);
|
|
emit(UPDATE_MODEL_EVENT, result2);
|
|
}
|
|
});
|
|
const validatedRange = computed(() => {
|
|
if (!props2.range || !isArray(props2.range) || props2.range.length !== 2 || props2.range.some((item) => !isDate(item)))
|
|
return [];
|
|
const rangeArrDayjs = props2.range.map((_2) => (0, import_dayjs3.default)(_2).locale(lang.value));
|
|
const [startDayjs, endDayjs] = rangeArrDayjs;
|
|
if (startDayjs.isAfter(endDayjs)) {
|
|
debugWarn(componentName2, "end time should be greater than start time");
|
|
return [];
|
|
}
|
|
if (startDayjs.isSame(endDayjs, "month")) {
|
|
return calculateValidatedDateRange(startDayjs, endDayjs);
|
|
} else {
|
|
if (startDayjs.add(1, "month").month() !== endDayjs.month()) {
|
|
debugWarn(componentName2, "start time and end time interval must not exceed two months");
|
|
return [];
|
|
}
|
|
return calculateValidatedDateRange(startDayjs, endDayjs);
|
|
}
|
|
});
|
|
const date4 = computed(() => {
|
|
if (!props2.modelValue) {
|
|
return realSelectedDay.value || (validatedRange.value.length ? validatedRange.value[0][0] : now2);
|
|
} else {
|
|
return (0, import_dayjs3.default)(props2.modelValue).locale(lang.value);
|
|
}
|
|
});
|
|
const prevMonthDayjs = computed(() => date4.value.subtract(1, "month").date(1));
|
|
const nextMonthDayjs = computed(() => date4.value.add(1, "month").date(1));
|
|
const prevYearDayjs = computed(() => date4.value.subtract(1, "year").date(1));
|
|
const nextYearDayjs = computed(() => date4.value.add(1, "year").date(1));
|
|
const calculateValidatedDateRange = (startDayjs, endDayjs) => {
|
|
const firstDay = startDayjs.startOf("week");
|
|
const lastDay = endDayjs.endOf("week");
|
|
const firstMonth = firstDay.get("month");
|
|
const lastMonth = lastDay.get("month");
|
|
if (firstMonth === lastMonth) {
|
|
return [[firstDay, lastDay]];
|
|
} else if ((firstMonth + 1) % 12 === lastMonth) {
|
|
return adjacentMonth(firstDay, lastDay);
|
|
} else if (firstMonth + 2 === lastMonth || (firstMonth + 1) % 11 === lastMonth) {
|
|
return threeConsecutiveMonth(firstDay, lastDay);
|
|
} else {
|
|
debugWarn(componentName2, "start time and end time interval must not exceed two months");
|
|
return [];
|
|
}
|
|
};
|
|
const pickDay = (day) => {
|
|
realSelectedDay.value = day;
|
|
};
|
|
const selectDate = (type4) => {
|
|
const dateMap = {
|
|
"prev-month": prevMonthDayjs.value,
|
|
"next-month": nextMonthDayjs.value,
|
|
"prev-year": prevYearDayjs.value,
|
|
"next-year": nextYearDayjs.value,
|
|
today: now2
|
|
};
|
|
const day = dateMap[type4];
|
|
if (!day.isSame(date4.value, "day")) {
|
|
pickDay(day);
|
|
}
|
|
};
|
|
return {
|
|
calculateValidatedDateRange,
|
|
date: date4,
|
|
realSelectedDay,
|
|
pickDay,
|
|
selectDate,
|
|
validatedRange
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/calendar/src/calendar2.mjs
|
|
var COMPONENT_NAME7 = "ElCalendar";
|
|
var __default__22 = defineComponent({
|
|
name: COMPONENT_NAME7
|
|
});
|
|
var _sfc_main26 = defineComponent({
|
|
...__default__22,
|
|
props: calendarProps,
|
|
emits: calendarEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("calendar");
|
|
const {
|
|
calculateValidatedDateRange,
|
|
date: date4,
|
|
pickDay,
|
|
realSelectedDay,
|
|
selectDate,
|
|
validatedRange
|
|
} = useCalendar(props2, emit, COMPONENT_NAME7);
|
|
const { t } = useLocale();
|
|
const i18nDate = computed(() => {
|
|
const pickedMonth = `el.datepicker.month${date4.value.format("M")}`;
|
|
return `${date4.value.year()} ${t("el.datepicker.year")} ${t(pickedMonth)}`;
|
|
});
|
|
expose({
|
|
selectedDay: realSelectedDay,
|
|
pickDay,
|
|
selectDate,
|
|
calculateValidatedDateRange
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(unref(ns).b())
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("header"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "header", { date: unref(i18nDate) }, () => [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("title"))
|
|
}, toDisplayString(unref(i18nDate)), 3),
|
|
unref(validatedRange).length === 0 ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("button-group"))
|
|
}, [
|
|
createVNode(unref(ElButtonGroup), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(ElButton), {
|
|
size: "small",
|
|
onClick: ($event) => unref(selectDate)("prev-month")
|
|
}, {
|
|
default: withCtx(() => [
|
|
createTextVNode(toDisplayString(unref(t)("el.datepicker.prevMonth")), 1)
|
|
]),
|
|
_: 1
|
|
}, 8, ["onClick"]),
|
|
createVNode(unref(ElButton), {
|
|
size: "small",
|
|
onClick: ($event) => unref(selectDate)("today")
|
|
}, {
|
|
default: withCtx(() => [
|
|
createTextVNode(toDisplayString(unref(t)("el.datepicker.today")), 1)
|
|
]),
|
|
_: 1
|
|
}, 8, ["onClick"]),
|
|
createVNode(unref(ElButton), {
|
|
size: "small",
|
|
onClick: ($event) => unref(selectDate)("next-month")
|
|
}, {
|
|
default: withCtx(() => [
|
|
createTextVNode(toDisplayString(unref(t)("el.datepicker.nextMonth")), 1)
|
|
]),
|
|
_: 1
|
|
}, 8, ["onClick"])
|
|
]),
|
|
_: 1
|
|
})
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
])
|
|
], 2),
|
|
unref(validatedRange).length === 0 ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("body"))
|
|
}, [
|
|
createVNode(DateTable, {
|
|
date: unref(date4),
|
|
"selected-day": unref(realSelectedDay),
|
|
onPick: unref(pickDay)
|
|
}, createSlots({
|
|
_: 2
|
|
}, [
|
|
_ctx.$slots["date-cell"] ? {
|
|
name: "date-cell",
|
|
fn: withCtx((data) => [
|
|
renderSlot(_ctx.$slots, "date-cell", normalizeProps(guardReactiveProps(data)))
|
|
])
|
|
} : void 0
|
|
]), 1032, ["date", "selected-day", "onPick"])
|
|
], 2)) : (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("body"))
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(validatedRange), (range_, index) => {
|
|
return openBlock(), createBlock(DateTable, {
|
|
key: index,
|
|
date: range_[0],
|
|
"selected-day": unref(realSelectedDay),
|
|
range: range_,
|
|
"hide-header": index !== 0,
|
|
onPick: unref(pickDay)
|
|
}, createSlots({
|
|
_: 2
|
|
}, [
|
|
_ctx.$slots["date-cell"] ? {
|
|
name: "date-cell",
|
|
fn: withCtx((data) => [
|
|
renderSlot(_ctx.$slots, "date-cell", normalizeProps(guardReactiveProps(data)))
|
|
])
|
|
} : void 0
|
|
]), 1032, ["date", "selected-day", "range", "hide-header", "onPick"]);
|
|
}), 128))
|
|
], 2))
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Calendar = _export_sfc(_sfc_main26, [["__file", "calendar.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/calendar/index.mjs
|
|
var ElCalendar = withInstall(Calendar);
|
|
|
|
// node_modules/element-plus/es/components/card/src/card.mjs
|
|
var cardProps = buildProps({
|
|
header: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
footer: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
bodyStyle: {
|
|
type: definePropType([String, Object, Array]),
|
|
default: ""
|
|
},
|
|
headerClass: String,
|
|
bodyClass: String,
|
|
footerClass: String,
|
|
shadow: {
|
|
type: String,
|
|
values: ["always", "hover", "never"],
|
|
default: "always"
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/card/src/card2.mjs
|
|
var __default__23 = defineComponent({
|
|
name: "ElCard"
|
|
});
|
|
var _sfc_main27 = defineComponent({
|
|
...__default__23,
|
|
props: cardProps,
|
|
setup(__props) {
|
|
const ns = useNamespace("card");
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([unref(ns).b(), unref(ns).is(`${_ctx.shadow}-shadow`)])
|
|
}, [
|
|
_ctx.$slots.header || _ctx.header ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("header"), _ctx.headerClass])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "header", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.header), 1)
|
|
])
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([unref(ns).e("body"), _ctx.bodyClass]),
|
|
style: normalizeStyle(_ctx.bodyStyle)
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 6),
|
|
_ctx.$slots.footer || _ctx.footer ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass([unref(ns).e("footer"), _ctx.footerClass])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "footer", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.footer), 1)
|
|
])
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Card = _export_sfc(_sfc_main27, [["__file", "card.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/card/index.mjs
|
|
var ElCard = withInstall(Card);
|
|
|
|
// node_modules/element-plus/es/components/carousel/src/carousel.mjs
|
|
var carouselProps = buildProps({
|
|
initialIndex: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
height: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
trigger: {
|
|
type: String,
|
|
values: ["hover", "click"],
|
|
default: "hover"
|
|
},
|
|
autoplay: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
interval: {
|
|
type: Number,
|
|
default: 3e3
|
|
},
|
|
indicatorPosition: {
|
|
type: String,
|
|
values: ["", "none", "outside"],
|
|
default: ""
|
|
},
|
|
arrow: {
|
|
type: String,
|
|
values: ["always", "hover", "never"],
|
|
default: "hover"
|
|
},
|
|
type: {
|
|
type: String,
|
|
values: ["", "card"],
|
|
default: ""
|
|
},
|
|
cardScale: {
|
|
type: Number,
|
|
default: 0.83
|
|
},
|
|
loop: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
direction: {
|
|
type: String,
|
|
values: ["horizontal", "vertical"],
|
|
default: "horizontal"
|
|
},
|
|
pauseOnHover: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
motionBlur: Boolean
|
|
});
|
|
var carouselEmits = {
|
|
change: (current, prev) => [current, prev].every(isNumber2)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/carousel/src/constants.mjs
|
|
var carouselContextKey = Symbol("carouselContextKey");
|
|
var CAROUSEL_ITEM_NAME = "ElCarouselItem";
|
|
|
|
// node_modules/element-plus/es/utils/vue/vnode.mjs
|
|
var SCOPE3 = "utils/vue/vnode";
|
|
var PatchFlags = ((PatchFlags2) => {
|
|
PatchFlags2[PatchFlags2["TEXT"] = 1] = "TEXT";
|
|
PatchFlags2[PatchFlags2["CLASS"] = 2] = "CLASS";
|
|
PatchFlags2[PatchFlags2["STYLE"] = 4] = "STYLE";
|
|
PatchFlags2[PatchFlags2["PROPS"] = 8] = "PROPS";
|
|
PatchFlags2[PatchFlags2["FULL_PROPS"] = 16] = "FULL_PROPS";
|
|
PatchFlags2[PatchFlags2["HYDRATE_EVENTS"] = 32] = "HYDRATE_EVENTS";
|
|
PatchFlags2[PatchFlags2["STABLE_FRAGMENT"] = 64] = "STABLE_FRAGMENT";
|
|
PatchFlags2[PatchFlags2["KEYED_FRAGMENT"] = 128] = "KEYED_FRAGMENT";
|
|
PatchFlags2[PatchFlags2["UNKEYED_FRAGMENT"] = 256] = "UNKEYED_FRAGMENT";
|
|
PatchFlags2[PatchFlags2["NEED_PATCH"] = 512] = "NEED_PATCH";
|
|
PatchFlags2[PatchFlags2["DYNAMIC_SLOTS"] = 1024] = "DYNAMIC_SLOTS";
|
|
PatchFlags2[PatchFlags2["HOISTED"] = -1] = "HOISTED";
|
|
PatchFlags2[PatchFlags2["BAIL"] = -2] = "BAIL";
|
|
return PatchFlags2;
|
|
})(PatchFlags || {});
|
|
function isFragment(node) {
|
|
return isVNode(node) && node.type === Fragment;
|
|
}
|
|
function isComment(node) {
|
|
return isVNode(node) && node.type === Comment;
|
|
}
|
|
function isValidElementNode(node) {
|
|
return isVNode(node) && !isFragment(node) && !isComment(node);
|
|
}
|
|
var getNormalizedProps = (node) => {
|
|
if (!isVNode(node)) {
|
|
debugWarn(SCOPE3, "[getNormalizedProps] must be a VNode");
|
|
return {};
|
|
}
|
|
const raw = node.props || {};
|
|
const type4 = (isVNode(node.type) ? node.type.props : void 0) || {};
|
|
const props2 = {};
|
|
Object.keys(type4).forEach((key) => {
|
|
if (hasOwn(type4[key], "default")) {
|
|
props2[key] = type4[key].default;
|
|
}
|
|
});
|
|
Object.keys(raw).forEach((key) => {
|
|
props2[camelize(key)] = raw[key];
|
|
});
|
|
return props2;
|
|
};
|
|
var ensureOnlyChild = (children) => {
|
|
if (!isArray(children) || children.length > 1) {
|
|
throw new Error("expect to receive a single Vue element child");
|
|
}
|
|
return children[0];
|
|
};
|
|
var flattedChildren = (children) => {
|
|
const vNodes = isArray(children) ? children : [children];
|
|
const result2 = [];
|
|
vNodes.forEach((child) => {
|
|
var _a2;
|
|
if (isArray(child)) {
|
|
result2.push(...flattedChildren(child));
|
|
} else if (isVNode(child) && ((_a2 = child.component) == null ? void 0 : _a2.subTree)) {
|
|
result2.push(child, ...flattedChildren(child.component.subTree));
|
|
} else if (isVNode(child) && isArray(child.children)) {
|
|
result2.push(...flattedChildren(child.children));
|
|
} else if (isVNode(child) && child.shapeFlag === 2) {
|
|
result2.push(...flattedChildren(child.type()));
|
|
} else {
|
|
result2.push(child);
|
|
}
|
|
});
|
|
return result2;
|
|
};
|
|
|
|
// node_modules/element-plus/es/hooks/use-ordered-children/index.mjs
|
|
var getOrderedChildren = (vm, childComponentName, children) => {
|
|
const nodes = flattedChildren(vm.subTree).filter((n) => {
|
|
var _a2;
|
|
return isVNode(n) && ((_a2 = n.type) == null ? void 0 : _a2.name) === childComponentName && !!n.component;
|
|
});
|
|
const uids = nodes.map((n) => n.component.uid);
|
|
return uids.map((uid2) => children[uid2]).filter((p2) => !!p2);
|
|
};
|
|
var useOrderedChildren = (vm, childComponentName) => {
|
|
const children = {};
|
|
const orderedChildren = shallowRef([]);
|
|
const addChild = (child) => {
|
|
children[child.uid] = child;
|
|
orderedChildren.value = getOrderedChildren(vm, childComponentName, children);
|
|
};
|
|
const removeChild = (uid2) => {
|
|
delete children[uid2];
|
|
orderedChildren.value = orderedChildren.value.filter((children2) => children2.uid !== uid2);
|
|
};
|
|
return {
|
|
children: orderedChildren,
|
|
addChild,
|
|
removeChild
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/carousel/src/carousel-item.mjs
|
|
var carouselItemProps = buildProps({
|
|
name: { type: String, default: "" },
|
|
label: {
|
|
type: [String, Number],
|
|
default: ""
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/carousel/src/use-carousel.mjs
|
|
var THROTTLE_TIME = 300;
|
|
var useCarousel = (props2, emit, componentName2) => {
|
|
const {
|
|
children: items,
|
|
addChild: addItem,
|
|
removeChild: removeItem
|
|
} = useOrderedChildren(getCurrentInstance(), CAROUSEL_ITEM_NAME);
|
|
const slots = useSlots();
|
|
const activeIndex = ref(-1);
|
|
const timer = ref(null);
|
|
const hover = ref(false);
|
|
const root2 = ref();
|
|
const containerHeight = ref(0);
|
|
const isItemsTwoLength = ref(true);
|
|
const arrowDisplay = computed(() => props2.arrow !== "never" && !unref(isVertical));
|
|
const hasLabel = computed(() => {
|
|
return items.value.some((item) => item.props.label.toString().length > 0);
|
|
});
|
|
const isCardType = computed(() => props2.type === "card");
|
|
const isVertical = computed(() => props2.direction === "vertical");
|
|
const containerStyle = computed(() => {
|
|
if (props2.height !== "auto") {
|
|
return {
|
|
height: props2.height
|
|
};
|
|
}
|
|
return {
|
|
height: `${containerHeight.value}px`,
|
|
overflow: "hidden"
|
|
};
|
|
});
|
|
const throttledArrowClick = throttle_default((index) => {
|
|
setActiveItem(index);
|
|
}, THROTTLE_TIME, { trailing: true });
|
|
const throttledIndicatorHover = throttle_default((index) => {
|
|
handleIndicatorHover(index);
|
|
}, THROTTLE_TIME);
|
|
const isTwoLengthShow = (index) => {
|
|
if (!isItemsTwoLength.value)
|
|
return true;
|
|
return activeIndex.value <= 1 ? index <= 1 : index > 1;
|
|
};
|
|
function pauseTimer() {
|
|
if (timer.value) {
|
|
clearInterval(timer.value);
|
|
timer.value = null;
|
|
}
|
|
}
|
|
function startTimer() {
|
|
if (props2.interval <= 0 || !props2.autoplay || timer.value)
|
|
return;
|
|
timer.value = setInterval(() => playSlides(), props2.interval);
|
|
}
|
|
const playSlides = () => {
|
|
if (activeIndex.value < items.value.length - 1) {
|
|
activeIndex.value = activeIndex.value + 1;
|
|
} else if (props2.loop) {
|
|
activeIndex.value = 0;
|
|
}
|
|
};
|
|
function setActiveItem(index) {
|
|
if (isString(index)) {
|
|
const filteredItems = items.value.filter((item) => item.props.name === index);
|
|
if (filteredItems.length > 0) {
|
|
index = items.value.indexOf(filteredItems[0]);
|
|
}
|
|
}
|
|
index = Number(index);
|
|
if (Number.isNaN(index) || index !== Math.floor(index)) {
|
|
debugWarn(componentName2, "index must be integer.");
|
|
return;
|
|
}
|
|
const itemCount = items.value.length;
|
|
const oldIndex = activeIndex.value;
|
|
if (index < 0) {
|
|
activeIndex.value = props2.loop ? itemCount - 1 : 0;
|
|
} else if (index >= itemCount) {
|
|
activeIndex.value = props2.loop ? 0 : itemCount - 1;
|
|
} else {
|
|
activeIndex.value = index;
|
|
}
|
|
if (oldIndex === activeIndex.value) {
|
|
resetItemPosition(oldIndex);
|
|
}
|
|
resetTimer();
|
|
}
|
|
function resetItemPosition(oldIndex) {
|
|
items.value.forEach((item, index) => {
|
|
item.translateItem(index, activeIndex.value, oldIndex);
|
|
});
|
|
}
|
|
function itemInStage(item, index) {
|
|
var _a2, _b, _c, _d;
|
|
const _items = unref(items);
|
|
const itemCount = _items.length;
|
|
if (itemCount === 0 || !item.states.inStage)
|
|
return false;
|
|
const nextItemIndex = index + 1;
|
|
const prevItemIndex = index - 1;
|
|
const lastItemIndex = itemCount - 1;
|
|
const isLastItemActive = _items[lastItemIndex].states.active;
|
|
const isFirstItemActive = _items[0].states.active;
|
|
const isNextItemActive = (_b = (_a2 = _items[nextItemIndex]) == null ? void 0 : _a2.states) == null ? void 0 : _b.active;
|
|
const isPrevItemActive = (_d = (_c = _items[prevItemIndex]) == null ? void 0 : _c.states) == null ? void 0 : _d.active;
|
|
if (index === lastItemIndex && isFirstItemActive || isNextItemActive) {
|
|
return "left";
|
|
} else if (index === 0 && isLastItemActive || isPrevItemActive) {
|
|
return "right";
|
|
}
|
|
return false;
|
|
}
|
|
function handleMouseEnter() {
|
|
hover.value = true;
|
|
if (props2.pauseOnHover) {
|
|
pauseTimer();
|
|
}
|
|
}
|
|
function handleMouseLeave() {
|
|
hover.value = false;
|
|
startTimer();
|
|
}
|
|
function handleButtonEnter(arrow3) {
|
|
if (unref(isVertical))
|
|
return;
|
|
items.value.forEach((item, index) => {
|
|
if (arrow3 === itemInStage(item, index)) {
|
|
item.states.hover = true;
|
|
}
|
|
});
|
|
}
|
|
function handleButtonLeave() {
|
|
if (unref(isVertical))
|
|
return;
|
|
items.value.forEach((item) => {
|
|
item.states.hover = false;
|
|
});
|
|
}
|
|
function handleIndicatorClick(index) {
|
|
activeIndex.value = index;
|
|
}
|
|
function handleIndicatorHover(index) {
|
|
if (props2.trigger === "hover" && index !== activeIndex.value) {
|
|
activeIndex.value = index;
|
|
}
|
|
}
|
|
function prev() {
|
|
setActiveItem(activeIndex.value - 1);
|
|
}
|
|
function next() {
|
|
setActiveItem(activeIndex.value + 1);
|
|
}
|
|
function resetTimer() {
|
|
pauseTimer();
|
|
if (!props2.pauseOnHover)
|
|
startTimer();
|
|
}
|
|
function setContainerHeight(height) {
|
|
if (props2.height !== "auto")
|
|
return;
|
|
containerHeight.value = height;
|
|
}
|
|
function PlaceholderItem() {
|
|
var _a2;
|
|
const defaultSlots = (_a2 = slots.default) == null ? void 0 : _a2.call(slots);
|
|
if (!defaultSlots)
|
|
return null;
|
|
const flatSlots = flattedChildren(defaultSlots);
|
|
const normalizeSlots = flatSlots.filter((slot) => {
|
|
return isVNode(slot) && slot.type.name === CAROUSEL_ITEM_NAME;
|
|
});
|
|
if ((normalizeSlots == null ? void 0 : normalizeSlots.length) === 2 && props2.loop && !isCardType.value) {
|
|
isItemsTwoLength.value = true;
|
|
return normalizeSlots;
|
|
}
|
|
isItemsTwoLength.value = false;
|
|
return null;
|
|
}
|
|
watch(() => activeIndex.value, (current, prev2) => {
|
|
resetItemPosition(prev2);
|
|
if (isItemsTwoLength.value) {
|
|
current = current % 2;
|
|
prev2 = prev2 % 2;
|
|
}
|
|
if (prev2 > -1) {
|
|
emit(CHANGE_EVENT, current, prev2);
|
|
}
|
|
});
|
|
watch(() => props2.autoplay, (autoplay) => {
|
|
autoplay ? startTimer() : pauseTimer();
|
|
});
|
|
watch(() => props2.loop, () => {
|
|
setActiveItem(activeIndex.value);
|
|
});
|
|
watch(() => props2.interval, () => {
|
|
resetTimer();
|
|
});
|
|
const resizeObserver = shallowRef();
|
|
onMounted(() => {
|
|
watch(() => items.value, () => {
|
|
if (items.value.length > 0)
|
|
setActiveItem(props2.initialIndex);
|
|
}, {
|
|
immediate: true
|
|
});
|
|
resizeObserver.value = useResizeObserver(root2.value, () => {
|
|
resetItemPosition();
|
|
});
|
|
startTimer();
|
|
});
|
|
onBeforeUnmount(() => {
|
|
pauseTimer();
|
|
if (root2.value && resizeObserver.value)
|
|
resizeObserver.value.stop();
|
|
});
|
|
provide(carouselContextKey, {
|
|
root: root2,
|
|
isCardType,
|
|
isVertical,
|
|
items,
|
|
loop: props2.loop,
|
|
cardScale: props2.cardScale,
|
|
addItem,
|
|
removeItem,
|
|
setActiveItem,
|
|
setContainerHeight
|
|
});
|
|
return {
|
|
root: root2,
|
|
activeIndex,
|
|
arrowDisplay,
|
|
hasLabel,
|
|
hover,
|
|
isCardType,
|
|
items,
|
|
isVertical,
|
|
containerStyle,
|
|
isItemsTwoLength,
|
|
handleButtonEnter,
|
|
handleButtonLeave,
|
|
handleIndicatorClick,
|
|
handleMouseEnter,
|
|
handleMouseLeave,
|
|
setActiveItem,
|
|
prev,
|
|
next,
|
|
PlaceholderItem,
|
|
isTwoLengthShow,
|
|
throttledArrowClick,
|
|
throttledIndicatorHover
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/carousel/src/carousel2.mjs
|
|
var COMPONENT_NAME8 = "ElCarousel";
|
|
var __default__24 = defineComponent({
|
|
name: COMPONENT_NAME8
|
|
});
|
|
var _sfc_main28 = defineComponent({
|
|
...__default__24,
|
|
props: carouselProps,
|
|
emits: carouselEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const {
|
|
root: root2,
|
|
activeIndex,
|
|
arrowDisplay,
|
|
hasLabel,
|
|
hover,
|
|
isCardType,
|
|
items,
|
|
isVertical,
|
|
containerStyle,
|
|
handleButtonEnter,
|
|
handleButtonLeave,
|
|
handleIndicatorClick,
|
|
handleMouseEnter,
|
|
handleMouseLeave,
|
|
setActiveItem,
|
|
prev,
|
|
next,
|
|
PlaceholderItem,
|
|
isTwoLengthShow,
|
|
throttledArrowClick,
|
|
throttledIndicatorHover
|
|
} = useCarousel(props2, emit, COMPONENT_NAME8);
|
|
const ns = useNamespace("carousel");
|
|
const { t } = useLocale();
|
|
const carouselClasses = computed(() => {
|
|
const classes = [ns.b(), ns.m(props2.direction)];
|
|
if (unref(isCardType)) {
|
|
classes.push(ns.m("card"));
|
|
}
|
|
return classes;
|
|
});
|
|
const indicatorsClasses = computed(() => {
|
|
const classes = [ns.e("indicators"), ns.em("indicators", props2.direction)];
|
|
if (unref(hasLabel)) {
|
|
classes.push(ns.em("indicators", "labels"));
|
|
}
|
|
if (props2.indicatorPosition === "outside") {
|
|
classes.push(ns.em("indicators", "outside"));
|
|
}
|
|
if (unref(isVertical)) {
|
|
classes.push(ns.em("indicators", "right"));
|
|
}
|
|
return classes;
|
|
});
|
|
function handleTransitionStart(e) {
|
|
if (!props2.motionBlur)
|
|
return;
|
|
const kls = unref(isVertical) ? `${ns.namespace.value}-transitioning-vertical` : `${ns.namespace.value}-transitioning`;
|
|
e.currentTarget.classList.add(kls);
|
|
}
|
|
function handleTransitionEnd(e) {
|
|
if (!props2.motionBlur)
|
|
return;
|
|
const kls = unref(isVertical) ? `${ns.namespace.value}-transitioning-vertical` : `${ns.namespace.value}-transitioning`;
|
|
e.currentTarget.classList.remove(kls);
|
|
}
|
|
expose({
|
|
activeIndex,
|
|
setActiveItem,
|
|
prev,
|
|
next
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "root",
|
|
ref: root2,
|
|
class: normalizeClass(unref(carouselClasses)),
|
|
onMouseenter: withModifiers(unref(handleMouseEnter), ["stop"]),
|
|
onMouseleave: withModifiers(unref(handleMouseLeave), ["stop"])
|
|
}, [
|
|
unref(arrowDisplay) ? (openBlock(), createBlock(Transition, {
|
|
key: 0,
|
|
name: "carousel-arrow-left",
|
|
persisted: ""
|
|
}, {
|
|
default: withCtx(() => [
|
|
withDirectives(createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass([unref(ns).e("arrow"), unref(ns).em("arrow", "left")]),
|
|
"aria-label": unref(t)("el.carousel.leftArrow"),
|
|
onMouseenter: ($event) => unref(handleButtonEnter)("left"),
|
|
onMouseleave: unref(handleButtonLeave),
|
|
onClick: withModifiers(($event) => unref(throttledArrowClick)(unref(activeIndex) - 1), ["stop"])
|
|
}, [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(arrow_left_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
], 42, ["aria-label", "onMouseenter", "onMouseleave", "onClick"]), [
|
|
[
|
|
vShow,
|
|
(_ctx.arrow === "always" || unref(hover)) && (props2.loop || unref(activeIndex) > 0)
|
|
]
|
|
])
|
|
]),
|
|
_: 1
|
|
})) : createCommentVNode("v-if", true),
|
|
unref(arrowDisplay) ? (openBlock(), createBlock(Transition, {
|
|
key: 1,
|
|
name: "carousel-arrow-right",
|
|
persisted: ""
|
|
}, {
|
|
default: withCtx(() => [
|
|
withDirectives(createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass([unref(ns).e("arrow"), unref(ns).em("arrow", "right")]),
|
|
"aria-label": unref(t)("el.carousel.rightArrow"),
|
|
onMouseenter: ($event) => unref(handleButtonEnter)("right"),
|
|
onMouseleave: unref(handleButtonLeave),
|
|
onClick: withModifiers(($event) => unref(throttledArrowClick)(unref(activeIndex) + 1), ["stop"])
|
|
}, [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(arrow_right_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
], 42, ["aria-label", "onMouseenter", "onMouseleave", "onClick"]), [
|
|
[
|
|
vShow,
|
|
(_ctx.arrow === "always" || unref(hover)) && (props2.loop || unref(activeIndex) < unref(items).length - 1)
|
|
]
|
|
])
|
|
]),
|
|
_: 1
|
|
})) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("container")),
|
|
style: normalizeStyle(unref(containerStyle)),
|
|
onTransitionstart: handleTransitionStart,
|
|
onTransitionend: handleTransitionEnd
|
|
}, [
|
|
createVNode(unref(PlaceholderItem)),
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 38),
|
|
_ctx.indicatorPosition !== "none" ? (openBlock(), createElementBlock("ul", {
|
|
key: 2,
|
|
class: normalizeClass(unref(indicatorsClasses))
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(items), (item, index) => {
|
|
return withDirectives((openBlock(), createElementBlock("li", {
|
|
key: index,
|
|
class: normalizeClass([
|
|
unref(ns).e("indicator"),
|
|
unref(ns).em("indicator", _ctx.direction),
|
|
unref(ns).is("active", index === unref(activeIndex))
|
|
]),
|
|
onMouseenter: ($event) => unref(throttledIndicatorHover)(index),
|
|
onClick: withModifiers(($event) => unref(handleIndicatorClick)(index), ["stop"])
|
|
}, [
|
|
createBaseVNode("button", {
|
|
class: normalizeClass(unref(ns).e("button")),
|
|
"aria-label": unref(t)("el.carousel.indicator", { index: index + 1 })
|
|
}, [
|
|
unref(hasLabel) ? (openBlock(), createElementBlock("span", { key: 0 }, toDisplayString(item.props.label), 1)) : createCommentVNode("v-if", true)
|
|
], 10, ["aria-label"])
|
|
], 42, ["onMouseenter", "onClick"])), [
|
|
[vShow, unref(isTwoLengthShow)(index)]
|
|
]);
|
|
}), 128))
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
props2.motionBlur ? (openBlock(), createElementBlock("svg", {
|
|
key: 3,
|
|
xmlns: "http://www.w3.org/2000/svg",
|
|
version: "1.1",
|
|
style: { "display": "none" }
|
|
}, [
|
|
createBaseVNode("defs", null, [
|
|
createBaseVNode("filter", { id: "elCarouselHorizontal" }, [
|
|
createBaseVNode("feGaussianBlur", {
|
|
in: "SourceGraphic",
|
|
stdDeviation: "12,0"
|
|
})
|
|
]),
|
|
createBaseVNode("filter", { id: "elCarouselVertical" }, [
|
|
createBaseVNode("feGaussianBlur", {
|
|
in: "SourceGraphic",
|
|
stdDeviation: "0,10"
|
|
})
|
|
])
|
|
])
|
|
])) : createCommentVNode("v-if", true)
|
|
], 42, ["onMouseenter", "onMouseleave"]);
|
|
};
|
|
}
|
|
});
|
|
var Carousel = _export_sfc(_sfc_main28, [["__file", "carousel.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/carousel/src/use-carousel-item.mjs
|
|
var useCarouselItem = (props2) => {
|
|
const carouselContext = inject(carouselContextKey);
|
|
const instance = getCurrentInstance();
|
|
if (!carouselContext) {
|
|
debugWarn(CAROUSEL_ITEM_NAME, "usage: <el-carousel></el-carousel-item></el-carousel>");
|
|
}
|
|
if (!instance) {
|
|
debugWarn(CAROUSEL_ITEM_NAME, "compositional hook can only be invoked inside setups");
|
|
}
|
|
const carouselItemRef = ref();
|
|
const hover = ref(false);
|
|
const translate2 = ref(0);
|
|
const scale = ref(1);
|
|
const active = ref(false);
|
|
const ready = ref(false);
|
|
const inStage = ref(false);
|
|
const animating = ref(false);
|
|
const { isCardType, isVertical, cardScale } = carouselContext;
|
|
function processIndex(index, activeIndex, length) {
|
|
const lastItemIndex = length - 1;
|
|
const prevItemIndex = activeIndex - 1;
|
|
const nextItemIndex = activeIndex + 1;
|
|
const halfItemIndex = length / 2;
|
|
if (activeIndex === 0 && index === lastItemIndex) {
|
|
return -1;
|
|
} else if (activeIndex === lastItemIndex && index === 0) {
|
|
return length;
|
|
} else if (index < prevItemIndex && activeIndex - index >= halfItemIndex) {
|
|
return length + 1;
|
|
} else if (index > nextItemIndex && index - activeIndex >= halfItemIndex) {
|
|
return -2;
|
|
}
|
|
return index;
|
|
}
|
|
function calcCardTranslate(index, activeIndex) {
|
|
var _a2, _b;
|
|
const parentWidth = unref(isVertical) ? ((_a2 = carouselContext.root.value) == null ? void 0 : _a2.offsetHeight) || 0 : ((_b = carouselContext.root.value) == null ? void 0 : _b.offsetWidth) || 0;
|
|
if (inStage.value) {
|
|
return parentWidth * ((2 - cardScale) * (index - activeIndex) + 1) / 4;
|
|
} else if (index < activeIndex) {
|
|
return -(1 + cardScale) * parentWidth / 4;
|
|
} else {
|
|
return (3 + cardScale) * parentWidth / 4;
|
|
}
|
|
}
|
|
function calcTranslate(index, activeIndex, isVertical2) {
|
|
const rootEl = carouselContext.root.value;
|
|
if (!rootEl)
|
|
return 0;
|
|
const distance = (isVertical2 ? rootEl.offsetHeight : rootEl.offsetWidth) || 0;
|
|
return distance * (index - activeIndex);
|
|
}
|
|
const translateItem = (index, activeIndex, oldIndex) => {
|
|
var _a2;
|
|
const _isCardType = unref(isCardType);
|
|
const carouselItemLength = (_a2 = carouselContext.items.value.length) != null ? _a2 : Number.NaN;
|
|
const isActive = index === activeIndex;
|
|
if (!_isCardType && !isUndefined2(oldIndex)) {
|
|
animating.value = isActive || index === oldIndex;
|
|
}
|
|
if (!isActive && carouselItemLength > 2 && carouselContext.loop) {
|
|
index = processIndex(index, activeIndex, carouselItemLength);
|
|
}
|
|
const _isVertical = unref(isVertical);
|
|
active.value = isActive;
|
|
if (_isCardType) {
|
|
inStage.value = Math.round(Math.abs(index - activeIndex)) <= 1;
|
|
translate2.value = calcCardTranslate(index, activeIndex);
|
|
scale.value = unref(active) ? 1 : cardScale;
|
|
} else {
|
|
translate2.value = calcTranslate(index, activeIndex, _isVertical);
|
|
}
|
|
ready.value = true;
|
|
if (isActive && carouselItemRef.value) {
|
|
carouselContext.setContainerHeight(carouselItemRef.value.offsetHeight);
|
|
}
|
|
};
|
|
function handleItemClick() {
|
|
if (carouselContext && unref(isCardType)) {
|
|
const index = carouselContext.items.value.findIndex(({ uid: uid2 }) => uid2 === instance.uid);
|
|
carouselContext.setActiveItem(index);
|
|
}
|
|
}
|
|
onMounted(() => {
|
|
carouselContext.addItem({
|
|
props: props2,
|
|
states: reactive({
|
|
hover,
|
|
translate: translate2,
|
|
scale,
|
|
active,
|
|
ready,
|
|
inStage,
|
|
animating
|
|
}),
|
|
uid: instance.uid,
|
|
translateItem
|
|
});
|
|
});
|
|
onUnmounted(() => {
|
|
carouselContext.removeItem(instance.uid);
|
|
});
|
|
return {
|
|
carouselItemRef,
|
|
active,
|
|
animating,
|
|
hover,
|
|
inStage,
|
|
isVertical,
|
|
translate: translate2,
|
|
isCardType,
|
|
scale,
|
|
ready,
|
|
handleItemClick
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/carousel/src/carousel-item2.mjs
|
|
var __default__25 = defineComponent({
|
|
name: CAROUSEL_ITEM_NAME
|
|
});
|
|
var _sfc_main29 = defineComponent({
|
|
...__default__25,
|
|
props: carouselItemProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("carousel");
|
|
const {
|
|
carouselItemRef,
|
|
active,
|
|
animating,
|
|
hover,
|
|
inStage,
|
|
isVertical,
|
|
translate: translate2,
|
|
isCardType,
|
|
scale,
|
|
ready,
|
|
handleItemClick
|
|
} = useCarouselItem(props2);
|
|
const itemKls = computed(() => [
|
|
ns.e("item"),
|
|
ns.is("active", active.value),
|
|
ns.is("in-stage", inStage.value),
|
|
ns.is("hover", hover.value),
|
|
ns.is("animating", animating.value),
|
|
{
|
|
[ns.em("item", "card")]: isCardType.value,
|
|
[ns.em("item", "card-vertical")]: isCardType.value && isVertical.value
|
|
}
|
|
]);
|
|
const itemStyle = computed(() => {
|
|
const translateType = `translate${unref(isVertical) ? "Y" : "X"}`;
|
|
const _translate = `${translateType}(${unref(translate2)}px)`;
|
|
const _scale = `scale(${unref(scale)})`;
|
|
const transform2 = [_translate, _scale].join(" ");
|
|
return {
|
|
transform: transform2
|
|
};
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return withDirectives((openBlock(), createElementBlock("div", {
|
|
ref_key: "carouselItemRef",
|
|
ref: carouselItemRef,
|
|
class: normalizeClass(unref(itemKls)),
|
|
style: normalizeStyle(unref(itemStyle)),
|
|
onClick: unref(handleItemClick)
|
|
}, [
|
|
unref(isCardType) ? withDirectives((openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("mask"))
|
|
}, null, 2)), [
|
|
[vShow, !unref(active)]
|
|
]) : createCommentVNode("v-if", true),
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 14, ["onClick"])), [
|
|
[vShow, unref(ready)]
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
var CarouselItem = _export_sfc(_sfc_main29, [["__file", "carousel-item.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/carousel/index.mjs
|
|
var ElCarousel = withInstall(Carousel, {
|
|
CarouselItem
|
|
});
|
|
var ElCarouselItem = withNoopInstall(CarouselItem);
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/checkbox2.mjs
|
|
var checkboxProps = {
|
|
modelValue: {
|
|
type: [Number, String, Boolean],
|
|
default: void 0
|
|
},
|
|
label: {
|
|
type: [String, Boolean, Number, Object],
|
|
default: void 0
|
|
},
|
|
value: {
|
|
type: [String, Boolean, Number, Object],
|
|
default: void 0
|
|
},
|
|
indeterminate: Boolean,
|
|
disabled: Boolean,
|
|
checked: Boolean,
|
|
name: {
|
|
type: String,
|
|
default: void 0
|
|
},
|
|
trueValue: {
|
|
type: [String, Number],
|
|
default: void 0
|
|
},
|
|
falseValue: {
|
|
type: [String, Number],
|
|
default: void 0
|
|
},
|
|
trueLabel: {
|
|
type: [String, Number],
|
|
default: void 0
|
|
},
|
|
falseLabel: {
|
|
type: [String, Number],
|
|
default: void 0
|
|
},
|
|
id: {
|
|
type: String,
|
|
default: void 0
|
|
},
|
|
border: Boolean,
|
|
size: useSizeProp,
|
|
tabindex: [String, Number],
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
...useAriaProps(["ariaControls"])
|
|
};
|
|
var checkboxEmits = {
|
|
[UPDATE_MODEL_EVENT]: (val) => isString(val) || isNumber2(val) || isBoolean2(val),
|
|
change: (val) => isString(val) || isNumber2(val) || isBoolean2(val)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/constants.mjs
|
|
var checkboxGroupContextKey = Symbol("checkboxGroupContextKey");
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/checkbox-group.mjs
|
|
var checkboxGroupProps = buildProps({
|
|
modelValue: {
|
|
type: definePropType(Array),
|
|
default: () => []
|
|
},
|
|
disabled: Boolean,
|
|
min: Number,
|
|
max: Number,
|
|
size: useSizeProp,
|
|
fill: String,
|
|
textColor: String,
|
|
tag: {
|
|
type: String,
|
|
default: "div"
|
|
},
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
...useAriaProps(["ariaLabel"])
|
|
});
|
|
var checkboxGroupEmits = {
|
|
[UPDATE_MODEL_EVENT]: (val) => isArray(val),
|
|
change: (val) => isArray(val)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/composables/use-checkbox-disabled.mjs
|
|
var useCheckboxDisabled = ({
|
|
model,
|
|
isChecked
|
|
}) => {
|
|
const checkboxGroup = inject(checkboxGroupContextKey, void 0);
|
|
const isLimitDisabled = computed(() => {
|
|
var _a2, _b;
|
|
const max4 = (_a2 = checkboxGroup == null ? void 0 : checkboxGroup.max) == null ? void 0 : _a2.value;
|
|
const min4 = (_b = checkboxGroup == null ? void 0 : checkboxGroup.min) == null ? void 0 : _b.value;
|
|
return !isUndefined2(max4) && model.value.length >= max4 && !isChecked.value || !isUndefined2(min4) && model.value.length <= min4 && isChecked.value;
|
|
});
|
|
const isDisabled = useFormDisabled(computed(() => (checkboxGroup == null ? void 0 : checkboxGroup.disabled.value) || isLimitDisabled.value));
|
|
return {
|
|
isDisabled,
|
|
isLimitDisabled
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/composables/use-checkbox-event.mjs
|
|
var useCheckboxEvent = (props2, {
|
|
model,
|
|
isLimitExceeded,
|
|
hasOwnLabel,
|
|
isDisabled,
|
|
isLabeledByFormItem
|
|
}) => {
|
|
const checkboxGroup = inject(checkboxGroupContextKey, void 0);
|
|
const { formItem } = useFormItem();
|
|
const { emit } = getCurrentInstance();
|
|
function getLabeledValue(value) {
|
|
var _a2, _b, _c, _d;
|
|
return [true, props2.trueValue, props2.trueLabel].includes(value) ? (_b = (_a2 = props2.trueValue) != null ? _a2 : props2.trueLabel) != null ? _b : true : (_d = (_c = props2.falseValue) != null ? _c : props2.falseLabel) != null ? _d : false;
|
|
}
|
|
function emitChangeEvent(checked, e) {
|
|
emit(CHANGE_EVENT, getLabeledValue(checked), e);
|
|
}
|
|
function handleChange(e) {
|
|
if (isLimitExceeded.value)
|
|
return;
|
|
const target2 = e.target;
|
|
emit(CHANGE_EVENT, getLabeledValue(target2.checked), e);
|
|
}
|
|
async function onClickRoot(e) {
|
|
if (isLimitExceeded.value)
|
|
return;
|
|
if (!hasOwnLabel.value && !isDisabled.value && isLabeledByFormItem.value) {
|
|
const eventTargets = e.composedPath();
|
|
const hasLabel = eventTargets.some((item) => item.tagName === "LABEL");
|
|
if (!hasLabel) {
|
|
model.value = getLabeledValue([false, props2.falseValue, props2.falseLabel].includes(model.value));
|
|
await nextTick();
|
|
emitChangeEvent(model.value, e);
|
|
}
|
|
}
|
|
}
|
|
const validateEvent = computed(() => (checkboxGroup == null ? void 0 : checkboxGroup.validateEvent) || props2.validateEvent);
|
|
watch(() => props2.modelValue, () => {
|
|
if (validateEvent.value) {
|
|
formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
|
|
}
|
|
});
|
|
return {
|
|
handleChange,
|
|
onClickRoot
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/composables/use-checkbox-model.mjs
|
|
var useCheckboxModel = (props2) => {
|
|
const selfModel = ref(false);
|
|
const { emit } = getCurrentInstance();
|
|
const checkboxGroup = inject(checkboxGroupContextKey, void 0);
|
|
const isGroup = computed(() => isUndefined2(checkboxGroup) === false);
|
|
const isLimitExceeded = ref(false);
|
|
const model = computed({
|
|
get() {
|
|
var _a2, _b;
|
|
return isGroup.value ? (_a2 = checkboxGroup == null ? void 0 : checkboxGroup.modelValue) == null ? void 0 : _a2.value : (_b = props2.modelValue) != null ? _b : selfModel.value;
|
|
},
|
|
set(val) {
|
|
var _a2, _b;
|
|
if (isGroup.value && isArray(val)) {
|
|
isLimitExceeded.value = ((_a2 = checkboxGroup == null ? void 0 : checkboxGroup.max) == null ? void 0 : _a2.value) !== void 0 && val.length > (checkboxGroup == null ? void 0 : checkboxGroup.max.value) && val.length > model.value.length;
|
|
isLimitExceeded.value === false && ((_b = checkboxGroup == null ? void 0 : checkboxGroup.changeEvent) == null ? void 0 : _b.call(checkboxGroup, val));
|
|
} else {
|
|
emit(UPDATE_MODEL_EVENT, val);
|
|
selfModel.value = val;
|
|
}
|
|
}
|
|
});
|
|
return {
|
|
model,
|
|
isGroup,
|
|
isLimitExceeded
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/composables/use-checkbox-status.mjs
|
|
var useCheckboxStatus = (props2, slots, { model }) => {
|
|
const checkboxGroup = inject(checkboxGroupContextKey, void 0);
|
|
const isFocused = ref(false);
|
|
const actualValue = computed(() => {
|
|
if (!isPropAbsent(props2.value)) {
|
|
return props2.value;
|
|
}
|
|
return props2.label;
|
|
});
|
|
const isChecked = computed(() => {
|
|
const value = model.value;
|
|
if (isBoolean2(value)) {
|
|
return value;
|
|
} else if (isArray(value)) {
|
|
if (isObject(actualValue.value)) {
|
|
return value.map(toRaw).some((o2) => isEqual_default(o2, actualValue.value));
|
|
} else {
|
|
return value.map(toRaw).includes(actualValue.value);
|
|
}
|
|
} else if (value !== null && value !== void 0) {
|
|
return value === props2.trueValue || value === props2.trueLabel;
|
|
} else {
|
|
return !!value;
|
|
}
|
|
});
|
|
const checkboxButtonSize = useFormSize(computed(() => {
|
|
var _a2;
|
|
return (_a2 = checkboxGroup == null ? void 0 : checkboxGroup.size) == null ? void 0 : _a2.value;
|
|
}), {
|
|
prop: true
|
|
});
|
|
const checkboxSize = useFormSize(computed(() => {
|
|
var _a2;
|
|
return (_a2 = checkboxGroup == null ? void 0 : checkboxGroup.size) == null ? void 0 : _a2.value;
|
|
}));
|
|
const hasOwnLabel = computed(() => {
|
|
return !!slots.default || !isPropAbsent(actualValue.value);
|
|
});
|
|
return {
|
|
checkboxButtonSize,
|
|
isChecked,
|
|
isFocused,
|
|
checkboxSize,
|
|
hasOwnLabel,
|
|
actualValue
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/composables/use-checkbox.mjs
|
|
var useCheckbox = (props2, slots) => {
|
|
const { formItem: elFormItem } = useFormItem();
|
|
const { model, isGroup, isLimitExceeded } = useCheckboxModel(props2);
|
|
const {
|
|
isFocused,
|
|
isChecked,
|
|
checkboxButtonSize,
|
|
checkboxSize,
|
|
hasOwnLabel,
|
|
actualValue
|
|
} = useCheckboxStatus(props2, slots, { model });
|
|
const { isDisabled } = useCheckboxDisabled({ model, isChecked });
|
|
const { inputId, isLabeledByFormItem } = useFormItemInputId(props2, {
|
|
formItemContext: elFormItem,
|
|
disableIdGeneration: hasOwnLabel,
|
|
disableIdManagement: isGroup
|
|
});
|
|
const { handleChange, onClickRoot } = useCheckboxEvent(props2, {
|
|
model,
|
|
isLimitExceeded,
|
|
hasOwnLabel,
|
|
isDisabled,
|
|
isLabeledByFormItem
|
|
});
|
|
const setStoreValue = () => {
|
|
function addToStore() {
|
|
var _a2, _b;
|
|
if (isArray(model.value) && !model.value.includes(actualValue.value)) {
|
|
model.value.push(actualValue.value);
|
|
} else {
|
|
model.value = (_b = (_a2 = props2.trueValue) != null ? _a2 : props2.trueLabel) != null ? _b : true;
|
|
}
|
|
}
|
|
props2.checked && addToStore();
|
|
};
|
|
setStoreValue();
|
|
useDeprecated({
|
|
from: "label act as value",
|
|
replacement: "value",
|
|
version: "3.0.0",
|
|
scope: "el-checkbox",
|
|
ref: "https://element-plus.org/en-US/component/checkbox.html"
|
|
}, computed(() => isGroup.value && isPropAbsent(props2.value)));
|
|
useDeprecated({
|
|
from: "true-label",
|
|
replacement: "true-value",
|
|
version: "3.0.0",
|
|
scope: "el-checkbox",
|
|
ref: "https://element-plus.org/en-US/component/checkbox.html"
|
|
}, computed(() => !!props2.trueLabel));
|
|
useDeprecated({
|
|
from: "false-label",
|
|
replacement: "false-value",
|
|
version: "3.0.0",
|
|
scope: "el-checkbox",
|
|
ref: "https://element-plus.org/en-US/component/checkbox.html"
|
|
}, computed(() => !!props2.falseLabel));
|
|
return {
|
|
inputId,
|
|
isLabeledByFormItem,
|
|
isChecked,
|
|
isDisabled,
|
|
isFocused,
|
|
checkboxButtonSize,
|
|
checkboxSize,
|
|
hasOwnLabel,
|
|
model,
|
|
actualValue,
|
|
handleChange,
|
|
onClickRoot
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/checkbox.mjs
|
|
var __default__26 = defineComponent({
|
|
name: "ElCheckbox"
|
|
});
|
|
var _sfc_main30 = defineComponent({
|
|
...__default__26,
|
|
props: checkboxProps,
|
|
emits: checkboxEmits,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const slots = useSlots();
|
|
const {
|
|
inputId,
|
|
isLabeledByFormItem,
|
|
isChecked,
|
|
isDisabled,
|
|
isFocused,
|
|
checkboxSize,
|
|
hasOwnLabel,
|
|
model,
|
|
actualValue,
|
|
handleChange,
|
|
onClickRoot
|
|
} = useCheckbox(props2, slots);
|
|
const ns = useNamespace("checkbox");
|
|
const compKls = computed(() => {
|
|
return [
|
|
ns.b(),
|
|
ns.m(checkboxSize.value),
|
|
ns.is("disabled", isDisabled.value),
|
|
ns.is("bordered", props2.border),
|
|
ns.is("checked", isChecked.value)
|
|
];
|
|
});
|
|
const spanKls = computed(() => {
|
|
return [
|
|
ns.e("input"),
|
|
ns.is("disabled", isDisabled.value),
|
|
ns.is("checked", isChecked.value),
|
|
ns.is("indeterminate", props2.indeterminate),
|
|
ns.is("focus", isFocused.value)
|
|
];
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(resolveDynamicComponent(!unref(hasOwnLabel) && unref(isLabeledByFormItem) ? "span" : "label"), {
|
|
class: normalizeClass(unref(compKls)),
|
|
"aria-controls": _ctx.indeterminate ? _ctx.ariaControls : null,
|
|
onClick: unref(onClickRoot)
|
|
}, {
|
|
default: withCtx(() => {
|
|
var _a2, _b, _c, _d;
|
|
return [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(spanKls))
|
|
}, [
|
|
_ctx.trueValue || _ctx.falseValue || _ctx.trueLabel || _ctx.falseLabel ? withDirectives((openBlock(), createElementBlock("input", {
|
|
key: 0,
|
|
id: unref(inputId),
|
|
"onUpdate:modelValue": ($event) => isRef(model) ? model.value = $event : null,
|
|
class: normalizeClass(unref(ns).e("original")),
|
|
type: "checkbox",
|
|
indeterminate: _ctx.indeterminate,
|
|
name: _ctx.name,
|
|
tabindex: _ctx.tabindex,
|
|
disabled: unref(isDisabled),
|
|
"true-value": (_b = (_a2 = _ctx.trueValue) != null ? _a2 : _ctx.trueLabel) != null ? _b : true,
|
|
"false-value": (_d = (_c = _ctx.falseValue) != null ? _c : _ctx.falseLabel) != null ? _d : false,
|
|
onChange: unref(handleChange),
|
|
onFocus: ($event) => isFocused.value = true,
|
|
onBlur: ($event) => isFocused.value = false,
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, null, 42, ["id", "onUpdate:modelValue", "indeterminate", "name", "tabindex", "disabled", "true-value", "false-value", "onChange", "onFocus", "onBlur", "onClick"])), [
|
|
[vModelCheckbox, unref(model)]
|
|
]) : withDirectives((openBlock(), createElementBlock("input", {
|
|
key: 1,
|
|
id: unref(inputId),
|
|
"onUpdate:modelValue": ($event) => isRef(model) ? model.value = $event : null,
|
|
class: normalizeClass(unref(ns).e("original")),
|
|
type: "checkbox",
|
|
indeterminate: _ctx.indeterminate,
|
|
disabled: unref(isDisabled),
|
|
value: unref(actualValue),
|
|
name: _ctx.name,
|
|
tabindex: _ctx.tabindex,
|
|
onChange: unref(handleChange),
|
|
onFocus: ($event) => isFocused.value = true,
|
|
onBlur: ($event) => isFocused.value = false,
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, null, 42, ["id", "onUpdate:modelValue", "indeterminate", "disabled", "value", "name", "tabindex", "onChange", "onFocus", "onBlur", "onClick"])), [
|
|
[vModelCheckbox, unref(model)]
|
|
]),
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(ns).e("inner"))
|
|
}, null, 2)
|
|
], 2),
|
|
unref(hasOwnLabel) ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("label"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default"),
|
|
!_ctx.$slots.default ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
|
|
createTextVNode(toDisplayString(_ctx.label), 1)
|
|
], 64)) : createCommentVNode("v-if", true)
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
];
|
|
}),
|
|
_: 3
|
|
}, 8, ["class", "aria-controls", "onClick"]);
|
|
};
|
|
}
|
|
});
|
|
var Checkbox = _export_sfc(_sfc_main30, [["__file", "checkbox.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/checkbox-button.mjs
|
|
var __default__27 = defineComponent({
|
|
name: "ElCheckboxButton"
|
|
});
|
|
var _sfc_main31 = defineComponent({
|
|
...__default__27,
|
|
props: checkboxProps,
|
|
emits: checkboxEmits,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const slots = useSlots();
|
|
const {
|
|
isFocused,
|
|
isChecked,
|
|
isDisabled,
|
|
checkboxButtonSize,
|
|
model,
|
|
actualValue,
|
|
handleChange
|
|
} = useCheckbox(props2, slots);
|
|
const checkboxGroup = inject(checkboxGroupContextKey, void 0);
|
|
const ns = useNamespace("checkbox");
|
|
const activeStyle = computed(() => {
|
|
var _a2, _b, _c, _d;
|
|
const fillValue = (_b = (_a2 = checkboxGroup == null ? void 0 : checkboxGroup.fill) == null ? void 0 : _a2.value) != null ? _b : "";
|
|
return {
|
|
backgroundColor: fillValue,
|
|
borderColor: fillValue,
|
|
color: (_d = (_c = checkboxGroup == null ? void 0 : checkboxGroup.textColor) == null ? void 0 : _c.value) != null ? _d : "",
|
|
boxShadow: fillValue ? `-1px 0 0 0 ${fillValue}` : void 0
|
|
};
|
|
});
|
|
const labelKls = computed(() => {
|
|
return [
|
|
ns.b("button"),
|
|
ns.bm("button", checkboxButtonSize.value),
|
|
ns.is("disabled", isDisabled.value),
|
|
ns.is("checked", isChecked.value),
|
|
ns.is("focus", isFocused.value)
|
|
];
|
|
});
|
|
return (_ctx, _cache) => {
|
|
var _a2, _b, _c, _d;
|
|
return openBlock(), createElementBlock("label", {
|
|
class: normalizeClass(unref(labelKls))
|
|
}, [
|
|
_ctx.trueValue || _ctx.falseValue || _ctx.trueLabel || _ctx.falseLabel ? withDirectives((openBlock(), createElementBlock("input", {
|
|
key: 0,
|
|
"onUpdate:modelValue": ($event) => isRef(model) ? model.value = $event : null,
|
|
class: normalizeClass(unref(ns).be("button", "original")),
|
|
type: "checkbox",
|
|
name: _ctx.name,
|
|
tabindex: _ctx.tabindex,
|
|
disabled: unref(isDisabled),
|
|
"true-value": (_b = (_a2 = _ctx.trueValue) != null ? _a2 : _ctx.trueLabel) != null ? _b : true,
|
|
"false-value": (_d = (_c = _ctx.falseValue) != null ? _c : _ctx.falseLabel) != null ? _d : false,
|
|
onChange: unref(handleChange),
|
|
onFocus: ($event) => isFocused.value = true,
|
|
onBlur: ($event) => isFocused.value = false,
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, null, 42, ["onUpdate:modelValue", "name", "tabindex", "disabled", "true-value", "false-value", "onChange", "onFocus", "onBlur", "onClick"])), [
|
|
[vModelCheckbox, unref(model)]
|
|
]) : withDirectives((openBlock(), createElementBlock("input", {
|
|
key: 1,
|
|
"onUpdate:modelValue": ($event) => isRef(model) ? model.value = $event : null,
|
|
class: normalizeClass(unref(ns).be("button", "original")),
|
|
type: "checkbox",
|
|
name: _ctx.name,
|
|
tabindex: _ctx.tabindex,
|
|
disabled: unref(isDisabled),
|
|
value: unref(actualValue),
|
|
onChange: unref(handleChange),
|
|
onFocus: ($event) => isFocused.value = true,
|
|
onBlur: ($event) => isFocused.value = false,
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, null, 42, ["onUpdate:modelValue", "name", "tabindex", "disabled", "value", "onChange", "onFocus", "onBlur", "onClick"])), [
|
|
[vModelCheckbox, unref(model)]
|
|
]),
|
|
_ctx.$slots.default || _ctx.label ? (openBlock(), createElementBlock("span", {
|
|
key: 2,
|
|
class: normalizeClass(unref(ns).be("button", "inner")),
|
|
style: normalizeStyle(unref(isChecked) ? unref(activeStyle) : void 0)
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.label), 1)
|
|
])
|
|
], 6)) : createCommentVNode("v-if", true)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var CheckboxButton = _export_sfc(_sfc_main31, [["__file", "checkbox-button.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/checkbox-group2.mjs
|
|
var __default__28 = defineComponent({
|
|
name: "ElCheckboxGroup"
|
|
});
|
|
var _sfc_main32 = defineComponent({
|
|
...__default__28,
|
|
props: checkboxGroupProps,
|
|
emits: checkboxGroupEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("checkbox");
|
|
const { formItem } = useFormItem();
|
|
const { inputId: groupId, isLabeledByFormItem } = useFormItemInputId(props2, {
|
|
formItemContext: formItem
|
|
});
|
|
const changeEvent = async (value) => {
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
await nextTick();
|
|
emit(CHANGE_EVENT, value);
|
|
};
|
|
const modelValue = computed({
|
|
get() {
|
|
return props2.modelValue;
|
|
},
|
|
set(val) {
|
|
changeEvent(val);
|
|
}
|
|
});
|
|
provide(checkboxGroupContextKey, {
|
|
...pick_default(toRefs(props2), [
|
|
"size",
|
|
"min",
|
|
"max",
|
|
"disabled",
|
|
"validateEvent",
|
|
"fill",
|
|
"textColor"
|
|
]),
|
|
modelValue,
|
|
changeEvent
|
|
});
|
|
watch(() => props2.modelValue, () => {
|
|
if (props2.validateEvent) {
|
|
formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
|
|
}
|
|
});
|
|
return (_ctx, _cache) => {
|
|
var _a2;
|
|
return openBlock(), createBlock(resolveDynamicComponent(_ctx.tag), {
|
|
id: unref(groupId),
|
|
class: normalizeClass(unref(ns).b("group")),
|
|
role: "group",
|
|
"aria-label": !unref(isLabeledByFormItem) ? _ctx.ariaLabel || "checkbox-group" : void 0,
|
|
"aria-labelledby": unref(isLabeledByFormItem) ? (_a2 = unref(formItem)) == null ? void 0 : _a2.labelId : void 0
|
|
}, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 8, ["id", "class", "aria-label", "aria-labelledby"]);
|
|
};
|
|
}
|
|
});
|
|
var CheckboxGroup = _export_sfc(_sfc_main32, [["__file", "checkbox-group.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/checkbox/index.mjs
|
|
var ElCheckbox = withInstall(Checkbox, {
|
|
CheckboxButton,
|
|
CheckboxGroup
|
|
});
|
|
var ElCheckboxButton = withNoopInstall(CheckboxButton);
|
|
var ElCheckboxGroup = withNoopInstall(CheckboxGroup);
|
|
|
|
// node_modules/element-plus/es/components/radio/src/radio.mjs
|
|
var radioPropsBase = buildProps({
|
|
modelValue: {
|
|
type: [String, Number, Boolean],
|
|
default: void 0
|
|
},
|
|
size: useSizeProp,
|
|
disabled: Boolean,
|
|
label: {
|
|
type: [String, Number, Boolean],
|
|
default: void 0
|
|
},
|
|
value: {
|
|
type: [String, Number, Boolean],
|
|
default: void 0
|
|
},
|
|
name: {
|
|
type: String,
|
|
default: void 0
|
|
}
|
|
});
|
|
var radioProps = buildProps({
|
|
...radioPropsBase,
|
|
border: Boolean
|
|
});
|
|
var radioEmits = {
|
|
[UPDATE_MODEL_EVENT]: (val) => isString(val) || isNumber2(val) || isBoolean2(val),
|
|
[CHANGE_EVENT]: (val) => isString(val) || isNumber2(val) || isBoolean2(val)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/radio/src/constants.mjs
|
|
var radioGroupKey = Symbol("radioGroupKey");
|
|
|
|
// node_modules/element-plus/es/components/radio/src/radio-button.mjs
|
|
var radioButtonProps = buildProps({
|
|
...radioPropsBase
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/radio/src/radio-group.mjs
|
|
var radioGroupProps = buildProps({
|
|
id: {
|
|
type: String,
|
|
default: void 0
|
|
},
|
|
size: useSizeProp,
|
|
disabled: Boolean,
|
|
modelValue: {
|
|
type: [String, Number, Boolean],
|
|
default: void 0
|
|
},
|
|
fill: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
textColor: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
name: {
|
|
type: String,
|
|
default: void 0
|
|
},
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
...useAriaProps(["ariaLabel"])
|
|
});
|
|
var radioGroupEmits = radioEmits;
|
|
|
|
// node_modules/element-plus/es/components/radio/src/use-radio.mjs
|
|
var useRadio = (props2, emit) => {
|
|
const radioRef = ref();
|
|
const radioGroup = inject(radioGroupKey, void 0);
|
|
const isGroup = computed(() => !!radioGroup);
|
|
const actualValue = computed(() => {
|
|
if (!isPropAbsent(props2.value)) {
|
|
return props2.value;
|
|
}
|
|
return props2.label;
|
|
});
|
|
const modelValue = computed({
|
|
get() {
|
|
return isGroup.value ? radioGroup.modelValue : props2.modelValue;
|
|
},
|
|
set(val) {
|
|
if (isGroup.value) {
|
|
radioGroup.changeEvent(val);
|
|
} else {
|
|
emit && emit(UPDATE_MODEL_EVENT, val);
|
|
}
|
|
radioRef.value.checked = props2.modelValue === actualValue.value;
|
|
}
|
|
});
|
|
const size3 = useFormSize(computed(() => radioGroup == null ? void 0 : radioGroup.size));
|
|
const disabled = useFormDisabled(computed(() => radioGroup == null ? void 0 : radioGroup.disabled));
|
|
const focus = ref(false);
|
|
const tabIndex = computed(() => {
|
|
return disabled.value || isGroup.value && modelValue.value !== actualValue.value ? -1 : 0;
|
|
});
|
|
useDeprecated({
|
|
from: "label act as value",
|
|
replacement: "value",
|
|
version: "3.0.0",
|
|
scope: "el-radio",
|
|
ref: "https://element-plus.org/en-US/component/radio.html"
|
|
}, computed(() => isGroup.value && isPropAbsent(props2.value)));
|
|
return {
|
|
radioRef,
|
|
isGroup,
|
|
radioGroup,
|
|
focus,
|
|
size: size3,
|
|
disabled,
|
|
tabIndex,
|
|
modelValue,
|
|
actualValue
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/radio/src/radio2.mjs
|
|
var __default__29 = defineComponent({
|
|
name: "ElRadio"
|
|
});
|
|
var _sfc_main33 = defineComponent({
|
|
...__default__29,
|
|
props: radioProps,
|
|
emits: radioEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("radio");
|
|
const { radioRef, radioGroup, focus, size: size3, disabled, modelValue, actualValue } = useRadio(props2, emit);
|
|
function handleChange() {
|
|
nextTick(() => emit(CHANGE_EVENT, modelValue.value));
|
|
}
|
|
return (_ctx, _cache) => {
|
|
var _a2;
|
|
return openBlock(), createElementBlock("label", {
|
|
class: normalizeClass([
|
|
unref(ns).b(),
|
|
unref(ns).is("disabled", unref(disabled)),
|
|
unref(ns).is("focus", unref(focus)),
|
|
unref(ns).is("bordered", _ctx.border),
|
|
unref(ns).is("checked", unref(modelValue) === unref(actualValue)),
|
|
unref(ns).m(unref(size3))
|
|
])
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass([
|
|
unref(ns).e("input"),
|
|
unref(ns).is("disabled", unref(disabled)),
|
|
unref(ns).is("checked", unref(modelValue) === unref(actualValue))
|
|
])
|
|
}, [
|
|
withDirectives(createBaseVNode("input", {
|
|
ref_key: "radioRef",
|
|
ref: radioRef,
|
|
"onUpdate:modelValue": ($event) => isRef(modelValue) ? modelValue.value = $event : null,
|
|
class: normalizeClass(unref(ns).e("original")),
|
|
value: unref(actualValue),
|
|
name: _ctx.name || ((_a2 = unref(radioGroup)) == null ? void 0 : _a2.name),
|
|
disabled: unref(disabled),
|
|
checked: unref(modelValue) === unref(actualValue),
|
|
type: "radio",
|
|
onFocus: ($event) => focus.value = true,
|
|
onBlur: ($event) => focus.value = false,
|
|
onChange: handleChange,
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, null, 42, ["onUpdate:modelValue", "value", "name", "disabled", "checked", "onFocus", "onBlur", "onClick"]), [
|
|
[vModelRadio, unref(modelValue)]
|
|
]),
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(ns).e("inner"))
|
|
}, null, 2)
|
|
], 2),
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(ns).e("label")),
|
|
onKeydown: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.label), 1)
|
|
])
|
|
], 42, ["onKeydown"])
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Radio = _export_sfc(_sfc_main33, [["__file", "radio.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/radio/src/radio-button2.mjs
|
|
var __default__30 = defineComponent({
|
|
name: "ElRadioButton"
|
|
});
|
|
var _sfc_main34 = defineComponent({
|
|
...__default__30,
|
|
props: radioButtonProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("radio");
|
|
const { radioRef, focus, size: size3, disabled, modelValue, radioGroup, actualValue } = useRadio(props2);
|
|
const activeStyle = computed(() => {
|
|
return {
|
|
backgroundColor: (radioGroup == null ? void 0 : radioGroup.fill) || "",
|
|
borderColor: (radioGroup == null ? void 0 : radioGroup.fill) || "",
|
|
boxShadow: (radioGroup == null ? void 0 : radioGroup.fill) ? `-1px 0 0 0 ${radioGroup.fill}` : "",
|
|
color: (radioGroup == null ? void 0 : radioGroup.textColor) || ""
|
|
};
|
|
});
|
|
return (_ctx, _cache) => {
|
|
var _a2;
|
|
return openBlock(), createElementBlock("label", {
|
|
class: normalizeClass([
|
|
unref(ns).b("button"),
|
|
unref(ns).is("active", unref(modelValue) === unref(actualValue)),
|
|
unref(ns).is("disabled", unref(disabled)),
|
|
unref(ns).is("focus", unref(focus)),
|
|
unref(ns).bm("button", unref(size3))
|
|
])
|
|
}, [
|
|
withDirectives(createBaseVNode("input", {
|
|
ref_key: "radioRef",
|
|
ref: radioRef,
|
|
"onUpdate:modelValue": ($event) => isRef(modelValue) ? modelValue.value = $event : null,
|
|
class: normalizeClass(unref(ns).be("button", "original-radio")),
|
|
value: unref(actualValue),
|
|
type: "radio",
|
|
name: _ctx.name || ((_a2 = unref(radioGroup)) == null ? void 0 : _a2.name),
|
|
disabled: unref(disabled),
|
|
onFocus: ($event) => focus.value = true,
|
|
onBlur: ($event) => focus.value = false,
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, null, 42, ["onUpdate:modelValue", "value", "name", "disabled", "onFocus", "onBlur", "onClick"]), [
|
|
[vModelRadio, unref(modelValue)]
|
|
]),
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(ns).be("button", "inner")),
|
|
style: normalizeStyle(unref(modelValue) === unref(actualValue) ? unref(activeStyle) : {}),
|
|
onKeydown: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.label), 1)
|
|
])
|
|
], 46, ["onKeydown"])
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var RadioButton = _export_sfc(_sfc_main34, [["__file", "radio-button.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/radio/src/radio-group2.mjs
|
|
var __default__31 = defineComponent({
|
|
name: "ElRadioGroup"
|
|
});
|
|
var _sfc_main35 = defineComponent({
|
|
...__default__31,
|
|
props: radioGroupProps,
|
|
emits: radioGroupEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("radio");
|
|
const radioId = useId();
|
|
const radioGroupRef = ref();
|
|
const { formItem } = useFormItem();
|
|
const { inputId: groupId, isLabeledByFormItem } = useFormItemInputId(props2, {
|
|
formItemContext: formItem
|
|
});
|
|
const changeEvent = (value) => {
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
nextTick(() => emit(CHANGE_EVENT, value));
|
|
};
|
|
onMounted(() => {
|
|
const radios = radioGroupRef.value.querySelectorAll("[type=radio]");
|
|
const firstLabel = radios[0];
|
|
if (!Array.from(radios).some((radio) => radio.checked) && firstLabel) {
|
|
firstLabel.tabIndex = 0;
|
|
}
|
|
});
|
|
const name = computed(() => {
|
|
return props2.name || radioId.value;
|
|
});
|
|
provide(radioGroupKey, reactive({
|
|
...toRefs(props2),
|
|
changeEvent,
|
|
name
|
|
}));
|
|
watch(() => props2.modelValue, () => {
|
|
if (props2.validateEvent) {
|
|
formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
|
|
}
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
id: unref(groupId),
|
|
ref_key: "radioGroupRef",
|
|
ref: radioGroupRef,
|
|
class: normalizeClass(unref(ns).b("group")),
|
|
role: "radiogroup",
|
|
"aria-label": !unref(isLabeledByFormItem) ? _ctx.ariaLabel || "radio-group" : void 0,
|
|
"aria-labelledby": unref(isLabeledByFormItem) ? unref(formItem).labelId : void 0
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 10, ["id", "aria-label", "aria-labelledby"]);
|
|
};
|
|
}
|
|
});
|
|
var RadioGroup = _export_sfc(_sfc_main35, [["__file", "radio-group.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/radio/index.mjs
|
|
var ElRadio = withInstall(Radio, {
|
|
RadioButton,
|
|
RadioGroup
|
|
});
|
|
var ElRadioGroup = withNoopInstall(RadioGroup);
|
|
var ElRadioButton = withNoopInstall(RadioButton);
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/src/types.mjs
|
|
var CASCADER_PANEL_INJECTION_KEY = Symbol();
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/src/config.mjs
|
|
var CommonProps = buildProps({
|
|
modelValue: {
|
|
type: definePropType([Number, String, Array])
|
|
},
|
|
options: {
|
|
type: definePropType(Array),
|
|
default: () => []
|
|
},
|
|
props: {
|
|
type: definePropType(Object),
|
|
default: () => ({})
|
|
}
|
|
});
|
|
var DefaultProps = {
|
|
expandTrigger: "click",
|
|
multiple: false,
|
|
checkStrictly: false,
|
|
emitPath: true,
|
|
lazy: false,
|
|
lazyLoad: NOOP,
|
|
value: "value",
|
|
label: "label",
|
|
children: "children",
|
|
leaf: "leaf",
|
|
disabled: "disabled",
|
|
hoverThreshold: 500
|
|
};
|
|
var useCascaderConfig = (props2) => {
|
|
return computed(() => ({
|
|
...DefaultProps,
|
|
...props2.props
|
|
}));
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/src/node-content.mjs
|
|
var NodeContent = defineComponent({
|
|
name: "NodeContent",
|
|
setup() {
|
|
const ns = useNamespace("cascader-node");
|
|
return {
|
|
ns
|
|
};
|
|
},
|
|
render() {
|
|
const { ns } = this;
|
|
const { node, panel } = this.$parent;
|
|
const { data, label } = node;
|
|
const { renderLabelFn } = panel;
|
|
return h("span", { class: ns.e("label") }, renderLabelFn ? renderLabelFn({ node, data }) : label);
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/src/node.mjs
|
|
var _sfc_main36 = defineComponent({
|
|
name: "ElCascaderNode",
|
|
components: {
|
|
ElCheckbox,
|
|
ElRadio,
|
|
NodeContent,
|
|
ElIcon,
|
|
Check: check_default,
|
|
Loading: loading_default,
|
|
ArrowRight: arrow_right_default
|
|
},
|
|
props: {
|
|
node: {
|
|
type: Object,
|
|
required: true
|
|
},
|
|
menuId: String
|
|
},
|
|
emits: ["expand"],
|
|
setup(props2, { emit }) {
|
|
const panel = inject(CASCADER_PANEL_INJECTION_KEY);
|
|
const ns = useNamespace("cascader-node");
|
|
const isHoverMenu = computed(() => panel.isHoverMenu);
|
|
const multiple = computed(() => panel.config.multiple);
|
|
const checkStrictly = computed(() => panel.config.checkStrictly);
|
|
const checkedNodeId = computed(() => {
|
|
var _a2;
|
|
return (_a2 = panel.checkedNodes[0]) == null ? void 0 : _a2.uid;
|
|
});
|
|
const isDisabled = computed(() => props2.node.isDisabled);
|
|
const isLeaf2 = computed(() => props2.node.isLeaf);
|
|
const expandable = computed(() => checkStrictly.value && !isLeaf2.value || !isDisabled.value);
|
|
const inExpandingPath = computed(() => isInPath(panel.expandingNode));
|
|
const inCheckedPath = computed(() => checkStrictly.value && panel.checkedNodes.some(isInPath));
|
|
const isInPath = (node) => {
|
|
var _a2;
|
|
const { level, uid: uid2 } = props2.node;
|
|
return ((_a2 = node == null ? void 0 : node.pathNodes[level - 1]) == null ? void 0 : _a2.uid) === uid2;
|
|
};
|
|
const doExpand = () => {
|
|
if (inExpandingPath.value)
|
|
return;
|
|
panel.expandNode(props2.node);
|
|
};
|
|
const doCheck = (checked) => {
|
|
const { node } = props2;
|
|
if (checked === node.checked)
|
|
return;
|
|
panel.handleCheckChange(node, checked);
|
|
};
|
|
const doLoad = () => {
|
|
panel.lazyLoad(props2.node, () => {
|
|
if (!isLeaf2.value)
|
|
doExpand();
|
|
});
|
|
};
|
|
const handleHoverExpand = (e) => {
|
|
if (!isHoverMenu.value)
|
|
return;
|
|
handleExpand();
|
|
!isLeaf2.value && emit("expand", e);
|
|
};
|
|
const handleExpand = () => {
|
|
const { node } = props2;
|
|
if (!expandable.value || node.loading)
|
|
return;
|
|
node.loaded ? doExpand() : doLoad();
|
|
};
|
|
const handleClick = () => {
|
|
if (isHoverMenu.value && !isLeaf2.value)
|
|
return;
|
|
if (isLeaf2.value && !isDisabled.value && !checkStrictly.value && !multiple.value) {
|
|
handleCheck(true);
|
|
} else {
|
|
handleExpand();
|
|
}
|
|
};
|
|
const handleSelectCheck = (checked) => {
|
|
if (checkStrictly.value) {
|
|
doCheck(checked);
|
|
if (props2.node.loaded) {
|
|
doExpand();
|
|
}
|
|
} else {
|
|
handleCheck(checked);
|
|
}
|
|
};
|
|
const handleCheck = (checked) => {
|
|
if (!props2.node.loaded) {
|
|
doLoad();
|
|
} else {
|
|
doCheck(checked);
|
|
!checkStrictly.value && doExpand();
|
|
}
|
|
};
|
|
return {
|
|
panel,
|
|
isHoverMenu,
|
|
multiple,
|
|
checkStrictly,
|
|
checkedNodeId,
|
|
isDisabled,
|
|
isLeaf: isLeaf2,
|
|
expandable,
|
|
inExpandingPath,
|
|
inCheckedPath,
|
|
ns,
|
|
handleHoverExpand,
|
|
handleExpand,
|
|
handleClick,
|
|
handleCheck,
|
|
handleSelectCheck
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render2(_ctx, _cache, $props, $setup, $data, $options) {
|
|
const _component_el_checkbox = resolveComponent("el-checkbox");
|
|
const _component_el_radio = resolveComponent("el-radio");
|
|
const _component_check = resolveComponent("check");
|
|
const _component_el_icon = resolveComponent("el-icon");
|
|
const _component_node_content = resolveComponent("node-content");
|
|
const _component_loading = resolveComponent("loading");
|
|
const _component_arrow_right = resolveComponent("arrow-right");
|
|
return openBlock(), createElementBlock("li", {
|
|
id: `${_ctx.menuId}-${_ctx.node.uid}`,
|
|
role: "menuitem",
|
|
"aria-haspopup": !_ctx.isLeaf,
|
|
"aria-owns": _ctx.isLeaf ? void 0 : _ctx.menuId,
|
|
"aria-expanded": _ctx.inExpandingPath,
|
|
tabindex: _ctx.expandable ? -1 : void 0,
|
|
class: normalizeClass([
|
|
_ctx.ns.b(),
|
|
_ctx.ns.is("selectable", _ctx.checkStrictly),
|
|
_ctx.ns.is("active", _ctx.node.checked),
|
|
_ctx.ns.is("disabled", !_ctx.expandable),
|
|
_ctx.inExpandingPath && "in-active-path",
|
|
_ctx.inCheckedPath && "in-checked-path"
|
|
]),
|
|
onMouseenter: _ctx.handleHoverExpand,
|
|
onFocus: _ctx.handleHoverExpand,
|
|
onClick: _ctx.handleClick
|
|
}, [
|
|
createCommentVNode(" prefix "),
|
|
_ctx.multiple ? (openBlock(), createBlock(_component_el_checkbox, {
|
|
key: 0,
|
|
"model-value": _ctx.node.checked,
|
|
indeterminate: _ctx.node.indeterminate,
|
|
disabled: _ctx.isDisabled,
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"]),
|
|
"onUpdate:modelValue": _ctx.handleSelectCheck
|
|
}, null, 8, ["model-value", "indeterminate", "disabled", "onClick", "onUpdate:modelValue"])) : _ctx.checkStrictly ? (openBlock(), createBlock(_component_el_radio, {
|
|
key: 1,
|
|
"model-value": _ctx.checkedNodeId,
|
|
label: _ctx.node.uid,
|
|
disabled: _ctx.isDisabled,
|
|
"onUpdate:modelValue": _ctx.handleSelectCheck,
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createCommentVNode("\n Add an empty element to avoid render label,\n do not use empty fragment here for https://github.com/vuejs/vue-next/pull/2485\n "),
|
|
createBaseVNode("span")
|
|
]),
|
|
_: 1
|
|
}, 8, ["model-value", "label", "disabled", "onUpdate:modelValue", "onClick"])) : _ctx.isLeaf && _ctx.node.checked ? (openBlock(), createBlock(_component_el_icon, {
|
|
key: 2,
|
|
class: normalizeClass(_ctx.ns.e("prefix"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(_component_check)
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true),
|
|
createCommentVNode(" content "),
|
|
createVNode(_component_node_content),
|
|
createCommentVNode(" postfix "),
|
|
!_ctx.isLeaf ? (openBlock(), createElementBlock(Fragment, { key: 3 }, [
|
|
_ctx.node.loading ? (openBlock(), createBlock(_component_el_icon, {
|
|
key: 0,
|
|
class: normalizeClass([_ctx.ns.is("loading"), _ctx.ns.e("postfix")])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(_component_loading)
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : (openBlock(), createBlock(_component_el_icon, {
|
|
key: 1,
|
|
class: normalizeClass(["arrow-right", _ctx.ns.e("postfix")])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(_component_arrow_right)
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"]))
|
|
], 64)) : createCommentVNode("v-if", true)
|
|
], 42, ["id", "aria-haspopup", "aria-owns", "aria-expanded", "tabindex", "onMouseenter", "onFocus", "onClick"]);
|
|
}
|
|
var ElCascaderNode = _export_sfc(_sfc_main36, [["render", _sfc_render2], ["__file", "node.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/src/menu.mjs
|
|
var _sfc_main37 = defineComponent({
|
|
name: "ElCascaderMenu",
|
|
components: {
|
|
Loading: loading_default,
|
|
ElIcon,
|
|
ElScrollbar,
|
|
ElCascaderNode
|
|
},
|
|
props: {
|
|
nodes: {
|
|
type: Array,
|
|
required: true
|
|
},
|
|
index: {
|
|
type: Number,
|
|
required: true
|
|
}
|
|
},
|
|
setup(props2) {
|
|
const instance = getCurrentInstance();
|
|
const ns = useNamespace("cascader-menu");
|
|
const { t } = useLocale();
|
|
const id = useId();
|
|
let activeNode = null;
|
|
let hoverTimer = null;
|
|
const panel = inject(CASCADER_PANEL_INJECTION_KEY);
|
|
const hoverZone = ref(null);
|
|
const isEmpty3 = computed(() => !props2.nodes.length);
|
|
const isLoading = computed(() => !panel.initialLoaded);
|
|
const menuId = computed(() => `${id.value}-${props2.index}`);
|
|
const handleExpand = (e) => {
|
|
activeNode = e.target;
|
|
};
|
|
const handleMouseMove = (e) => {
|
|
if (!panel.isHoverMenu || !activeNode || !hoverZone.value)
|
|
return;
|
|
if (activeNode.contains(e.target)) {
|
|
clearHoverTimer();
|
|
const el = instance.vnode.el;
|
|
const { left } = el.getBoundingClientRect();
|
|
const { offsetWidth, offsetHeight } = el;
|
|
const startX = e.clientX - left;
|
|
const top = activeNode.offsetTop;
|
|
const bottom = top + activeNode.offsetHeight;
|
|
hoverZone.value.innerHTML = `
|
|
<path style="pointer-events: auto;" fill="transparent" d="M${startX} ${top} L${offsetWidth} 0 V${top} Z" />
|
|
<path style="pointer-events: auto;" fill="transparent" d="M${startX} ${bottom} L${offsetWidth} ${offsetHeight} V${bottom} Z" />
|
|
`;
|
|
} else if (!hoverTimer) {
|
|
hoverTimer = window.setTimeout(clearHoverZone, panel.config.hoverThreshold);
|
|
}
|
|
};
|
|
const clearHoverTimer = () => {
|
|
if (!hoverTimer)
|
|
return;
|
|
clearTimeout(hoverTimer);
|
|
hoverTimer = null;
|
|
};
|
|
const clearHoverZone = () => {
|
|
if (!hoverZone.value)
|
|
return;
|
|
hoverZone.value.innerHTML = "";
|
|
clearHoverTimer();
|
|
};
|
|
return {
|
|
ns,
|
|
panel,
|
|
hoverZone,
|
|
isEmpty: isEmpty3,
|
|
isLoading,
|
|
menuId,
|
|
t,
|
|
handleExpand,
|
|
handleMouseMove,
|
|
clearHoverZone
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render3(_ctx, _cache, $props, $setup, $data, $options) {
|
|
const _component_el_cascader_node = resolveComponent("el-cascader-node");
|
|
const _component_loading = resolveComponent("loading");
|
|
const _component_el_icon = resolveComponent("el-icon");
|
|
const _component_el_scrollbar = resolveComponent("el-scrollbar");
|
|
return openBlock(), createBlock(_component_el_scrollbar, {
|
|
key: _ctx.menuId,
|
|
tag: "ul",
|
|
role: "menu",
|
|
class: normalizeClass(_ctx.ns.b()),
|
|
"wrap-class": _ctx.ns.e("wrap"),
|
|
"view-class": [_ctx.ns.e("list"), _ctx.ns.is("empty", _ctx.isEmpty)],
|
|
onMousemove: _ctx.handleMouseMove,
|
|
onMouseleave: _ctx.clearHoverZone
|
|
}, {
|
|
default: withCtx(() => {
|
|
var _a2;
|
|
return [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.nodes, (node) => {
|
|
return openBlock(), createBlock(_component_el_cascader_node, {
|
|
key: node.uid,
|
|
node,
|
|
"menu-id": _ctx.menuId,
|
|
onExpand: _ctx.handleExpand
|
|
}, null, 8, ["node", "menu-id", "onExpand"]);
|
|
}), 128)),
|
|
_ctx.isLoading ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(_ctx.ns.e("empty-text"))
|
|
}, [
|
|
createVNode(_component_el_icon, {
|
|
size: "14",
|
|
class: normalizeClass(_ctx.ns.is("loading"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(_component_loading)
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"]),
|
|
createTextVNode(" " + toDisplayString(_ctx.t("el.cascader.loading")), 1)
|
|
], 2)) : _ctx.isEmpty ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(_ctx.ns.e("empty-text"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "empty", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.t("el.cascader.noData")), 1)
|
|
])
|
|
], 2)) : ((_a2 = _ctx.panel) == null ? void 0 : _a2.isHoverMenu) ? (openBlock(), createElementBlock(Fragment, { key: 2 }, [
|
|
createCommentVNode(" eslint-disable-next-line vue/html-self-closing "),
|
|
(openBlock(), createElementBlock("svg", {
|
|
ref: "hoverZone",
|
|
class: normalizeClass(_ctx.ns.e("hover-zone"))
|
|
}, null, 2))
|
|
], 2112)) : createCommentVNode("v-if", true)
|
|
];
|
|
}),
|
|
_: 3
|
|
}, 8, ["class", "wrap-class", "view-class", "onMousemove", "onMouseleave"]);
|
|
}
|
|
var ElCascaderMenu = _export_sfc(_sfc_main37, [["render", _sfc_render3], ["__file", "menu.vue"]]);
|
|
|
|
// node_modules/element-plus/es/utils/strings.mjs
|
|
var escapeStringRegexp = (string3 = "") => string3.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
|
|
var capitalize3 = (str) => capitalize(str);
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/src/node2.mjs
|
|
var uid = 0;
|
|
var calculatePathNodes = (node) => {
|
|
const nodes = [node];
|
|
let { parent: parent2 } = node;
|
|
while (parent2) {
|
|
nodes.unshift(parent2);
|
|
parent2 = parent2.parent;
|
|
}
|
|
return nodes;
|
|
};
|
|
var Node2 = class {
|
|
constructor(data, config, parent2, root2 = false) {
|
|
this.data = data;
|
|
this.config = config;
|
|
this.parent = parent2;
|
|
this.root = root2;
|
|
this.uid = uid++;
|
|
this.checked = false;
|
|
this.indeterminate = false;
|
|
this.loading = false;
|
|
const { value: valueKey, label: labelKey, children: childrenKey } = config;
|
|
const childrenData = data[childrenKey];
|
|
const pathNodes = calculatePathNodes(this);
|
|
this.level = root2 ? 0 : parent2 ? parent2.level + 1 : 1;
|
|
this.value = data[valueKey];
|
|
this.label = data[labelKey];
|
|
this.pathNodes = pathNodes;
|
|
this.pathValues = pathNodes.map((node) => node.value);
|
|
this.pathLabels = pathNodes.map((node) => node.label);
|
|
this.childrenData = childrenData;
|
|
this.children = (childrenData || []).map((child) => new Node2(child, config, this));
|
|
this.loaded = !config.lazy || this.isLeaf || !isEmpty2(childrenData);
|
|
}
|
|
get isDisabled() {
|
|
const { data, parent: parent2, config } = this;
|
|
const { disabled, checkStrictly } = config;
|
|
const isDisabled = isFunction(disabled) ? disabled(data, this) : !!data[disabled];
|
|
return isDisabled || !checkStrictly && (parent2 == null ? void 0 : parent2.isDisabled);
|
|
}
|
|
get isLeaf() {
|
|
const { data, config, childrenData, loaded } = this;
|
|
const { lazy, leaf } = config;
|
|
const isLeaf2 = isFunction(leaf) ? leaf(data, this) : data[leaf];
|
|
return isUndefined2(isLeaf2) ? lazy && !loaded ? false : !(isArray(childrenData) && childrenData.length) : !!isLeaf2;
|
|
}
|
|
get valueByOption() {
|
|
return this.config.emitPath ? this.pathValues : this.value;
|
|
}
|
|
appendChild(childData) {
|
|
const { childrenData, children } = this;
|
|
const node = new Node2(childData, this.config, this);
|
|
if (isArray(childrenData)) {
|
|
childrenData.push(childData);
|
|
} else {
|
|
this.childrenData = [childData];
|
|
}
|
|
children.push(node);
|
|
return node;
|
|
}
|
|
calcText(allLevels, separator) {
|
|
const text = allLevels ? this.pathLabels.join(separator) : this.label;
|
|
this.text = text;
|
|
return text;
|
|
}
|
|
broadcast(event, ...args) {
|
|
const handlerName = `onParent${capitalize3(event)}`;
|
|
this.children.forEach((child) => {
|
|
if (child) {
|
|
child.broadcast(event, ...args);
|
|
child[handlerName] && child[handlerName](...args);
|
|
}
|
|
});
|
|
}
|
|
emit(event, ...args) {
|
|
const { parent: parent2 } = this;
|
|
const handlerName = `onChild${capitalize3(event)}`;
|
|
if (parent2) {
|
|
parent2[handlerName] && parent2[handlerName](...args);
|
|
parent2.emit(event, ...args);
|
|
}
|
|
}
|
|
onParentCheck(checked) {
|
|
if (!this.isDisabled) {
|
|
this.setCheckState(checked);
|
|
}
|
|
}
|
|
onChildCheck() {
|
|
const { children } = this;
|
|
const validChildren = children.filter((child) => !child.isDisabled);
|
|
const checked = validChildren.length ? validChildren.every((child) => child.checked) : false;
|
|
this.setCheckState(checked);
|
|
}
|
|
setCheckState(checked) {
|
|
const totalNum = this.children.length;
|
|
const checkedNum = this.children.reduce((c2, p2) => {
|
|
const num = p2.checked ? 1 : p2.indeterminate ? 0.5 : 0;
|
|
return c2 + num;
|
|
}, 0);
|
|
this.checked = this.loaded && this.children.filter((child) => !child.isDisabled).every((child) => child.loaded && child.checked) && checked;
|
|
this.indeterminate = this.loaded && checkedNum !== totalNum && checkedNum > 0;
|
|
}
|
|
doCheck(checked) {
|
|
if (this.checked === checked)
|
|
return;
|
|
const { checkStrictly, multiple } = this.config;
|
|
if (checkStrictly || !multiple) {
|
|
this.checked = checked;
|
|
} else {
|
|
this.broadcast("check", checked);
|
|
this.setCheckState(checked);
|
|
this.emit("check");
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/src/store.mjs
|
|
var flatNodes = (nodes, leafOnly) => {
|
|
return nodes.reduce((res, node) => {
|
|
if (node.isLeaf) {
|
|
res.push(node);
|
|
} else {
|
|
!leafOnly && res.push(node);
|
|
res = res.concat(flatNodes(node.children, leafOnly));
|
|
}
|
|
return res;
|
|
}, []);
|
|
};
|
|
var Store = class {
|
|
constructor(data, config) {
|
|
this.config = config;
|
|
const nodes = (data || []).map((nodeData) => new Node2(nodeData, this.config));
|
|
this.nodes = nodes;
|
|
this.allNodes = flatNodes(nodes, false);
|
|
this.leafNodes = flatNodes(nodes, true);
|
|
}
|
|
getNodes() {
|
|
return this.nodes;
|
|
}
|
|
getFlattedNodes(leafOnly) {
|
|
return leafOnly ? this.leafNodes : this.allNodes;
|
|
}
|
|
appendNode(nodeData, parentNode) {
|
|
const node = parentNode ? parentNode.appendChild(nodeData) : new Node2(nodeData, this.config);
|
|
if (!parentNode)
|
|
this.nodes.push(node);
|
|
this.appendAllNodesAndLeafNodes(node);
|
|
}
|
|
appendNodes(nodeDataList, parentNode) {
|
|
nodeDataList.forEach((nodeData) => this.appendNode(nodeData, parentNode));
|
|
}
|
|
appendAllNodesAndLeafNodes(node) {
|
|
this.allNodes.push(node);
|
|
node.isLeaf && this.leafNodes.push(node);
|
|
if (node.children) {
|
|
node.children.forEach((subNode) => {
|
|
this.appendAllNodesAndLeafNodes(subNode);
|
|
});
|
|
}
|
|
}
|
|
getNodeByValue(value, leafOnly = false) {
|
|
if (isPropAbsent(value))
|
|
return null;
|
|
const node = this.getFlattedNodes(leafOnly).find((node2) => isEqual_default(node2.value, value) || isEqual_default(node2.pathValues, value));
|
|
return node || null;
|
|
}
|
|
getSameNode(node) {
|
|
if (!node)
|
|
return null;
|
|
const node_ = this.getFlattedNodes(false).find(({ value, level }) => isEqual_default(node.value, value) && node.level === level);
|
|
return node_ || null;
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/src/utils.mjs
|
|
var getMenuIndex = (el) => {
|
|
if (!el)
|
|
return 0;
|
|
const pieces = el.id.split("-");
|
|
return Number(pieces[pieces.length - 2]);
|
|
};
|
|
var checkNode = (el) => {
|
|
if (!el)
|
|
return;
|
|
const input = el.querySelector("input");
|
|
if (input) {
|
|
input.click();
|
|
} else if (isLeaf(el)) {
|
|
el.click();
|
|
}
|
|
};
|
|
var sortByOriginalOrder = (oldNodes, newNodes) => {
|
|
const newNodesCopy = newNodes.slice(0);
|
|
const newIds = newNodesCopy.map((node) => node.uid);
|
|
const res = oldNodes.reduce((acc, item) => {
|
|
const index = newIds.indexOf(item.uid);
|
|
if (index > -1) {
|
|
acc.push(item);
|
|
newNodesCopy.splice(index, 1);
|
|
newIds.splice(index, 1);
|
|
}
|
|
return acc;
|
|
}, []);
|
|
res.push(...newNodesCopy);
|
|
return res;
|
|
};
|
|
|
|
// node_modules/element-plus/es/utils/arrays.mjs
|
|
var unique = (arr) => [...new Set(arr)];
|
|
var castArray2 = (arr) => {
|
|
if (!arr && arr !== 0)
|
|
return [];
|
|
return isArray(arr) ? arr : [arr];
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/src/index.mjs
|
|
var _sfc_main38 = defineComponent({
|
|
name: "ElCascaderPanel",
|
|
components: {
|
|
ElCascaderMenu
|
|
},
|
|
props: {
|
|
...CommonProps,
|
|
border: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
renderLabel: Function
|
|
},
|
|
emits: [UPDATE_MODEL_EVENT, CHANGE_EVENT, "close", "expand-change"],
|
|
setup(props2, { emit, slots }) {
|
|
let manualChecked = false;
|
|
const ns = useNamespace("cascader");
|
|
const config = useCascaderConfig(props2);
|
|
let store = null;
|
|
const initialLoaded = ref(true);
|
|
const menuList = ref([]);
|
|
const checkedValue = ref(null);
|
|
const menus = ref([]);
|
|
const expandingNode = ref(null);
|
|
const checkedNodes = ref([]);
|
|
const isHoverMenu = computed(() => config.value.expandTrigger === "hover");
|
|
const renderLabelFn = computed(() => props2.renderLabel || slots.default);
|
|
const initStore = () => {
|
|
const { options } = props2;
|
|
const cfg = config.value;
|
|
manualChecked = false;
|
|
store = new Store(options, cfg);
|
|
menus.value = [store.getNodes()];
|
|
if (cfg.lazy && isEmpty2(props2.options)) {
|
|
initialLoaded.value = false;
|
|
lazyLoad(void 0, (list) => {
|
|
if (list) {
|
|
store = new Store(list, cfg);
|
|
menus.value = [store.getNodes()];
|
|
}
|
|
initialLoaded.value = true;
|
|
syncCheckedValue(false, true);
|
|
});
|
|
} else {
|
|
syncCheckedValue(false, true);
|
|
}
|
|
};
|
|
const lazyLoad = (node, cb) => {
|
|
const cfg = config.value;
|
|
node = node || new Node2({}, cfg, void 0, true);
|
|
node.loading = true;
|
|
const resolve = (dataList) => {
|
|
const _node = node;
|
|
const parent2 = _node.root ? null : _node;
|
|
dataList && (store == null ? void 0 : store.appendNodes(dataList, parent2));
|
|
_node.loading = false;
|
|
_node.loaded = true;
|
|
_node.childrenData = _node.childrenData || [];
|
|
cb && cb(dataList);
|
|
};
|
|
cfg.lazyLoad(node, resolve);
|
|
};
|
|
const expandNode = (node, silent) => {
|
|
var _a2;
|
|
const { level } = node;
|
|
const newMenus = menus.value.slice(0, level);
|
|
let newExpandingNode;
|
|
if (node.isLeaf) {
|
|
newExpandingNode = node.pathNodes[level - 2];
|
|
} else {
|
|
newExpandingNode = node;
|
|
newMenus.push(node.children);
|
|
}
|
|
if (((_a2 = expandingNode.value) == null ? void 0 : _a2.uid) !== (newExpandingNode == null ? void 0 : newExpandingNode.uid)) {
|
|
expandingNode.value = node;
|
|
menus.value = newMenus;
|
|
!silent && emit("expand-change", (node == null ? void 0 : node.pathValues) || []);
|
|
}
|
|
};
|
|
const handleCheckChange = (node, checked, emitClose = true) => {
|
|
const { checkStrictly, multiple } = config.value;
|
|
const oldNode = checkedNodes.value[0];
|
|
manualChecked = true;
|
|
!multiple && (oldNode == null ? void 0 : oldNode.doCheck(false));
|
|
node.doCheck(checked);
|
|
calculateCheckedValue();
|
|
emitClose && !multiple && !checkStrictly && emit("close");
|
|
!emitClose && !multiple && !checkStrictly && expandParentNode(node);
|
|
};
|
|
const expandParentNode = (node) => {
|
|
if (!node)
|
|
return;
|
|
node = node.parent;
|
|
expandParentNode(node);
|
|
node && expandNode(node);
|
|
};
|
|
const getFlattedNodes = (leafOnly) => {
|
|
return store == null ? void 0 : store.getFlattedNodes(leafOnly);
|
|
};
|
|
const getCheckedNodes = (leafOnly) => {
|
|
var _a2;
|
|
return (_a2 = getFlattedNodes(leafOnly)) == null ? void 0 : _a2.filter((node) => node.checked !== false);
|
|
};
|
|
const clearCheckedNodes = () => {
|
|
checkedNodes.value.forEach((node) => node.doCheck(false));
|
|
calculateCheckedValue();
|
|
menus.value = menus.value.slice(0, 1);
|
|
expandingNode.value = null;
|
|
emit("expand-change", []);
|
|
};
|
|
const calculateCheckedValue = () => {
|
|
var _a2;
|
|
const { checkStrictly, multiple } = config.value;
|
|
const oldNodes = checkedNodes.value;
|
|
const newNodes = getCheckedNodes(!checkStrictly);
|
|
const nodes = sortByOriginalOrder(oldNodes, newNodes);
|
|
const values2 = nodes.map((node) => node.valueByOption);
|
|
checkedNodes.value = nodes;
|
|
checkedValue.value = multiple ? values2 : (_a2 = values2[0]) != null ? _a2 : null;
|
|
};
|
|
const syncCheckedValue = (loaded = false, forced = false) => {
|
|
const { modelValue } = props2;
|
|
const { lazy, multiple, checkStrictly } = config.value;
|
|
const leafOnly = !checkStrictly;
|
|
if (!initialLoaded.value || manualChecked || !forced && isEqual_default(modelValue, checkedValue.value))
|
|
return;
|
|
if (lazy && !loaded) {
|
|
const values2 = unique(flattenDeep_default(castArray2(modelValue)));
|
|
const nodes = values2.map((val) => store == null ? void 0 : store.getNodeByValue(val)).filter((node) => !!node && !node.loaded && !node.loading);
|
|
if (nodes.length) {
|
|
nodes.forEach((node) => {
|
|
lazyLoad(node, () => syncCheckedValue(false, forced));
|
|
});
|
|
} else {
|
|
syncCheckedValue(true, forced);
|
|
}
|
|
} else {
|
|
const values2 = multiple ? castArray2(modelValue) : [modelValue];
|
|
const nodes = unique(values2.map((val) => store == null ? void 0 : store.getNodeByValue(val, leafOnly)));
|
|
syncMenuState(nodes, forced);
|
|
checkedValue.value = cloneDeep_default(modelValue);
|
|
}
|
|
};
|
|
const syncMenuState = (newCheckedNodes, reserveExpandingState = true) => {
|
|
const { checkStrictly } = config.value;
|
|
const oldNodes = checkedNodes.value;
|
|
const newNodes = newCheckedNodes.filter((node) => !!node && (checkStrictly || node.isLeaf));
|
|
const oldExpandingNode = store == null ? void 0 : store.getSameNode(expandingNode.value);
|
|
const newExpandingNode = reserveExpandingState && oldExpandingNode || newNodes[0];
|
|
if (newExpandingNode) {
|
|
newExpandingNode.pathNodes.forEach((node) => expandNode(node, true));
|
|
} else {
|
|
expandingNode.value = null;
|
|
}
|
|
oldNodes.forEach((node) => node.doCheck(false));
|
|
reactive(newNodes).forEach((node) => node.doCheck(true));
|
|
checkedNodes.value = newNodes;
|
|
nextTick(scrollToExpandingNode);
|
|
};
|
|
const scrollToExpandingNode = () => {
|
|
if (!isClient)
|
|
return;
|
|
menuList.value.forEach((menu) => {
|
|
const menuElement = menu == null ? void 0 : menu.$el;
|
|
if (menuElement) {
|
|
const container = menuElement.querySelector(`.${ns.namespace.value}-scrollbar__wrap`);
|
|
const activeNode = menuElement.querySelector(`.${ns.b("node")}.${ns.is("active")}`) || menuElement.querySelector(`.${ns.b("node")}.in-active-path`);
|
|
scrollIntoView(container, activeNode);
|
|
}
|
|
});
|
|
};
|
|
const handleKeyDown = (e) => {
|
|
const target2 = e.target;
|
|
const { code } = e;
|
|
switch (code) {
|
|
case EVENT_CODE.up:
|
|
case EVENT_CODE.down: {
|
|
e.preventDefault();
|
|
const distance = code === EVENT_CODE.up ? -1 : 1;
|
|
focusNode(getSibling(target2, distance, `.${ns.b("node")}[tabindex="-1"]`));
|
|
break;
|
|
}
|
|
case EVENT_CODE.left: {
|
|
e.preventDefault();
|
|
const preMenu = menuList.value[getMenuIndex(target2) - 1];
|
|
const expandedNode = preMenu == null ? void 0 : preMenu.$el.querySelector(`.${ns.b("node")}[aria-expanded="true"]`);
|
|
focusNode(expandedNode);
|
|
break;
|
|
}
|
|
case EVENT_CODE.right: {
|
|
e.preventDefault();
|
|
const nextMenu = menuList.value[getMenuIndex(target2) + 1];
|
|
const firstNode = nextMenu == null ? void 0 : nextMenu.$el.querySelector(`.${ns.b("node")}[tabindex="-1"]`);
|
|
focusNode(firstNode);
|
|
break;
|
|
}
|
|
case EVENT_CODE.enter:
|
|
case EVENT_CODE.numpadEnter:
|
|
checkNode(target2);
|
|
break;
|
|
}
|
|
};
|
|
provide(CASCADER_PANEL_INJECTION_KEY, reactive({
|
|
config,
|
|
expandingNode,
|
|
checkedNodes,
|
|
isHoverMenu,
|
|
initialLoaded,
|
|
renderLabelFn,
|
|
lazyLoad,
|
|
expandNode,
|
|
handleCheckChange
|
|
}));
|
|
watch([config, () => props2.options], initStore, {
|
|
deep: true,
|
|
immediate: true
|
|
});
|
|
watch(() => props2.modelValue, () => {
|
|
manualChecked = false;
|
|
syncCheckedValue();
|
|
}, {
|
|
deep: true
|
|
});
|
|
watch(() => checkedValue.value, (val) => {
|
|
if (!isEqual_default(val, props2.modelValue)) {
|
|
emit(UPDATE_MODEL_EVENT, val);
|
|
emit(CHANGE_EVENT, val);
|
|
}
|
|
});
|
|
onBeforeUpdate(() => menuList.value = []);
|
|
onMounted(() => !isEmpty2(props2.modelValue) && syncCheckedValue());
|
|
return {
|
|
ns,
|
|
menuList,
|
|
menus,
|
|
checkedNodes,
|
|
handleKeyDown,
|
|
handleCheckChange,
|
|
getFlattedNodes,
|
|
getCheckedNodes,
|
|
clearCheckedNodes,
|
|
calculateCheckedValue,
|
|
scrollToExpandingNode
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render4(_ctx, _cache, $props, $setup, $data, $options) {
|
|
const _component_el_cascader_menu = resolveComponent("el-cascader-menu");
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([_ctx.ns.b("panel"), _ctx.ns.is("bordered", _ctx.border)]),
|
|
onKeydown: _ctx.handleKeyDown
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.menus, (menu, index) => {
|
|
return openBlock(), createBlock(_component_el_cascader_menu, {
|
|
key: index,
|
|
ref_for: true,
|
|
ref: (item) => _ctx.menuList[index] = item,
|
|
index,
|
|
nodes: [...menu]
|
|
}, {
|
|
empty: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "empty")
|
|
]),
|
|
_: 2
|
|
}, 1032, ["index", "nodes"]);
|
|
}), 128))
|
|
], 42, ["onKeydown"]);
|
|
}
|
|
var CascaderPanel = _export_sfc(_sfc_main38, [["render", _sfc_render4], ["__file", "index.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/index.mjs
|
|
var ElCascaderPanel = withInstall(CascaderPanel);
|
|
|
|
// node_modules/element-plus/es/components/tag/src/tag2.mjs
|
|
var tagProps = buildProps({
|
|
type: {
|
|
type: String,
|
|
values: ["primary", "success", "info", "warning", "danger"],
|
|
default: "primary"
|
|
},
|
|
closable: Boolean,
|
|
disableTransitions: Boolean,
|
|
hit: Boolean,
|
|
color: String,
|
|
size: {
|
|
type: String,
|
|
values: componentSizes
|
|
},
|
|
effect: {
|
|
type: String,
|
|
values: ["dark", "light", "plain"],
|
|
default: "light"
|
|
},
|
|
round: Boolean
|
|
});
|
|
var tagEmits = {
|
|
close: (evt) => evt instanceof MouseEvent,
|
|
click: (evt) => evt instanceof MouseEvent
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/tag/src/tag.mjs
|
|
var __default__32 = defineComponent({
|
|
name: "ElTag"
|
|
});
|
|
var _sfc_main39 = defineComponent({
|
|
...__default__32,
|
|
props: tagProps,
|
|
emits: tagEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const tagSize = useFormSize();
|
|
const ns = useNamespace("tag");
|
|
const containerKls = computed(() => {
|
|
const { type: type4, hit, effect, closable, round: round3 } = props2;
|
|
return [
|
|
ns.b(),
|
|
ns.is("closable", closable),
|
|
ns.m(type4 || "primary"),
|
|
ns.m(tagSize.value),
|
|
ns.m(effect),
|
|
ns.is("hit", hit),
|
|
ns.is("round", round3)
|
|
];
|
|
});
|
|
const handleClose = (event) => {
|
|
emit("close", event);
|
|
};
|
|
const handleClick = (event) => {
|
|
emit("click", event);
|
|
};
|
|
const handleVNodeMounted = (vnode) => {
|
|
var _a2, _b, _c;
|
|
if ((_c = (_b = (_a2 = vnode == null ? void 0 : vnode.component) == null ? void 0 : _a2.subTree) == null ? void 0 : _b.component) == null ? void 0 : _c.bum) {
|
|
vnode.component.subTree.component.bum = null;
|
|
}
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return _ctx.disableTransitions ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
class: normalizeClass(unref(containerKls)),
|
|
style: normalizeStyle({ backgroundColor: _ctx.color }),
|
|
onClick: handleClick
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(ns).e("content"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2),
|
|
_ctx.closable ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("close")),
|
|
onClick: withModifiers(handleClose, ["stop"])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(close_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "onClick"])) : createCommentVNode("v-if", true)
|
|
], 6)) : (openBlock(), createBlock(Transition, {
|
|
key: 1,
|
|
name: `${unref(ns).namespace.value}-zoom-in-center`,
|
|
appear: "",
|
|
onVnodeMounted: handleVNodeMounted
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(containerKls)),
|
|
style: normalizeStyle({ backgroundColor: _ctx.color }),
|
|
onClick: handleClick
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(ns).e("content"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2),
|
|
_ctx.closable ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("close")),
|
|
onClick: withModifiers(handleClose, ["stop"])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(close_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "onClick"])) : createCommentVNode("v-if", true)
|
|
], 6)
|
|
]),
|
|
_: 3
|
|
}, 8, ["name"]));
|
|
};
|
|
}
|
|
});
|
|
var Tag = _export_sfc(_sfc_main39, [["__file", "tag.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tag/index.mjs
|
|
var ElTag = withInstall(Tag);
|
|
|
|
// node_modules/element-plus/es/components/cascader/src/cascader.mjs
|
|
var cascaderProps = buildProps({
|
|
...CommonProps,
|
|
size: useSizeProp,
|
|
placeholder: String,
|
|
disabled: Boolean,
|
|
clearable: Boolean,
|
|
filterable: Boolean,
|
|
filterMethod: {
|
|
type: definePropType(Function),
|
|
default: (node, keyword) => node.text.includes(keyword)
|
|
},
|
|
separator: {
|
|
type: String,
|
|
default: " / "
|
|
},
|
|
showAllLevels: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
collapseTags: Boolean,
|
|
maxCollapseTags: {
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
collapseTagsTooltip: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
debounce: {
|
|
type: Number,
|
|
default: 300
|
|
},
|
|
beforeFilter: {
|
|
type: definePropType(Function),
|
|
default: () => true
|
|
},
|
|
placement: {
|
|
type: definePropType(String),
|
|
values: Ee,
|
|
default: "bottom-start"
|
|
},
|
|
fallbackPlacements: {
|
|
type: definePropType(Array),
|
|
default: ["bottom-start", "bottom", "top-start", "top", "right", "left"]
|
|
},
|
|
popperClass: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
teleported: useTooltipContentProps.teleported,
|
|
tagType: { ...tagProps.type, default: "info" },
|
|
tagEffect: { ...tagProps.effect, default: "light" },
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
persistent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
...useEmptyValuesProps
|
|
});
|
|
var cascaderEmits = {
|
|
[UPDATE_MODEL_EVENT]: (_2) => true,
|
|
[CHANGE_EVENT]: (_2) => true,
|
|
focus: (evt) => evt instanceof FocusEvent,
|
|
blur: (evt) => evt instanceof FocusEvent,
|
|
clear: () => true,
|
|
visibleChange: (val) => isBoolean2(val),
|
|
expandChange: (val) => !!val,
|
|
removeTag: (val) => !!val
|
|
};
|
|
|
|
// node_modules/element-plus/es/directives/click-outside/index.mjs
|
|
var nodeList = new Map();
|
|
if (isClient) {
|
|
let startClick;
|
|
document.addEventListener("mousedown", (e) => startClick = e);
|
|
document.addEventListener("mouseup", (e) => {
|
|
if (startClick) {
|
|
for (const handlers2 of nodeList.values()) {
|
|
for (const { documentHandler } of handlers2) {
|
|
documentHandler(e, startClick);
|
|
}
|
|
}
|
|
startClick = void 0;
|
|
}
|
|
});
|
|
}
|
|
function createDocumentHandler(el, binding) {
|
|
let excludes = [];
|
|
if (isArray(binding.arg)) {
|
|
excludes = binding.arg;
|
|
} else if (isElement2(binding.arg)) {
|
|
excludes.push(binding.arg);
|
|
}
|
|
return function(mouseup, mousedown) {
|
|
const popperRef = binding.instance.popperRef;
|
|
const mouseUpTarget = mouseup.target;
|
|
const mouseDownTarget = mousedown == null ? void 0 : mousedown.target;
|
|
const isBound = !binding || !binding.instance;
|
|
const isTargetExists = !mouseUpTarget || !mouseDownTarget;
|
|
const isContainedByEl = el.contains(mouseUpTarget) || el.contains(mouseDownTarget);
|
|
const isSelf = el === mouseUpTarget;
|
|
const isTargetExcluded = excludes.length && excludes.some((item) => item == null ? void 0 : item.contains(mouseUpTarget)) || excludes.length && excludes.includes(mouseDownTarget);
|
|
const isContainedByPopper = popperRef && (popperRef.contains(mouseUpTarget) || popperRef.contains(mouseDownTarget));
|
|
if (isBound || isTargetExists || isContainedByEl || isSelf || isTargetExcluded || isContainedByPopper) {
|
|
return;
|
|
}
|
|
binding.value(mouseup, mousedown);
|
|
};
|
|
}
|
|
var ClickOutside = {
|
|
beforeMount(el, binding) {
|
|
if (!nodeList.has(el)) {
|
|
nodeList.set(el, []);
|
|
}
|
|
nodeList.get(el).push({
|
|
documentHandler: createDocumentHandler(el, binding),
|
|
bindingFn: binding.value
|
|
});
|
|
},
|
|
updated(el, binding) {
|
|
if (!nodeList.has(el)) {
|
|
nodeList.set(el, []);
|
|
}
|
|
const handlers2 = nodeList.get(el);
|
|
const oldHandlerIndex = handlers2.findIndex((item) => item.bindingFn === binding.oldValue);
|
|
const newHandler = {
|
|
documentHandler: createDocumentHandler(el, binding),
|
|
bindingFn: binding.value
|
|
};
|
|
if (oldHandlerIndex >= 0) {
|
|
handlers2.splice(oldHandlerIndex, 1, newHandler);
|
|
} else {
|
|
handlers2.push(newHandler);
|
|
}
|
|
},
|
|
unmounted(el) {
|
|
nodeList.delete(el);
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/cascader/src/cascader2.mjs
|
|
var COMPONENT_NAME9 = "ElCascader";
|
|
var __default__33 = defineComponent({
|
|
name: COMPONENT_NAME9
|
|
});
|
|
var _sfc_main40 = defineComponent({
|
|
...__default__33,
|
|
props: cascaderProps,
|
|
emits: cascaderEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const popperOptions = {
|
|
modifiers: [
|
|
{
|
|
name: "arrowPosition",
|
|
enabled: true,
|
|
phase: "main",
|
|
fn: ({ state }) => {
|
|
const { modifiersData, placement } = state;
|
|
if (["right", "left", "bottom", "top"].includes(placement))
|
|
return;
|
|
if (modifiersData.arrow) {
|
|
modifiersData.arrow.x = 35;
|
|
}
|
|
},
|
|
requires: ["arrow"]
|
|
}
|
|
]
|
|
};
|
|
const attrs = useAttrs();
|
|
let inputInitialHeight = 0;
|
|
let pressDeleteCount = 0;
|
|
const nsCascader = useNamespace("cascader");
|
|
const nsInput = useNamespace("input");
|
|
const { t } = useLocale();
|
|
const { form, formItem } = useFormItem();
|
|
const { valueOnClear } = useEmptyValues(props2);
|
|
const { isComposing, handleComposition } = useComposition({
|
|
afterComposition(event) {
|
|
var _a2;
|
|
const text = (_a2 = event.target) == null ? void 0 : _a2.value;
|
|
handleInput(text);
|
|
}
|
|
});
|
|
const tooltipRef = ref(null);
|
|
const input = ref(null);
|
|
const tagWrapper = ref(null);
|
|
const cascaderPanelRef = ref(null);
|
|
const suggestionPanel = ref(null);
|
|
const popperVisible = ref(false);
|
|
const inputHover = ref(false);
|
|
const filtering = ref(false);
|
|
const filterFocus = ref(false);
|
|
const inputValue = ref("");
|
|
const searchInputValue = ref("");
|
|
const presentTags = ref([]);
|
|
const allPresentTags = ref([]);
|
|
const suggestions = ref([]);
|
|
const cascaderStyle = computed(() => {
|
|
return attrs.style;
|
|
});
|
|
const isDisabled = computed(() => props2.disabled || (form == null ? void 0 : form.disabled));
|
|
const inputPlaceholder = computed(() => props2.placeholder || t("el.cascader.placeholder"));
|
|
const currentPlaceholder = computed(() => searchInputValue.value || presentTags.value.length > 0 || isComposing.value ? "" : inputPlaceholder.value);
|
|
const realSize = useFormSize();
|
|
const tagSize = computed(() => realSize.value === "small" ? "small" : "default");
|
|
const multiple = computed(() => !!props2.props.multiple);
|
|
const readonly2 = computed(() => !props2.filterable || multiple.value);
|
|
const searchKeyword = computed(() => multiple.value ? searchInputValue.value : inputValue.value);
|
|
const checkedNodes = computed(() => {
|
|
var _a2;
|
|
return ((_a2 = cascaderPanelRef.value) == null ? void 0 : _a2.checkedNodes) || [];
|
|
});
|
|
const clearBtnVisible = computed(() => {
|
|
if (!props2.clearable || isDisabled.value || filtering.value || !inputHover.value)
|
|
return false;
|
|
return !!checkedNodes.value.length;
|
|
});
|
|
const presentText = computed(() => {
|
|
const { showAllLevels, separator } = props2;
|
|
const nodes = checkedNodes.value;
|
|
return nodes.length ? multiple.value ? "" : nodes[0].calcText(showAllLevels, separator) : "";
|
|
});
|
|
const validateState = computed(() => (formItem == null ? void 0 : formItem.validateState) || "");
|
|
const checkedValue = computed({
|
|
get() {
|
|
return cloneDeep_default(props2.modelValue);
|
|
},
|
|
set(val) {
|
|
const value = val != null ? val : valueOnClear.value;
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emit(CHANGE_EVENT, value);
|
|
if (props2.validateEvent) {
|
|
formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
|
|
}
|
|
}
|
|
});
|
|
const cascaderKls = computed(() => {
|
|
return [
|
|
nsCascader.b(),
|
|
nsCascader.m(realSize.value),
|
|
nsCascader.is("disabled", isDisabled.value),
|
|
attrs.class
|
|
];
|
|
});
|
|
const cascaderIconKls = computed(() => {
|
|
return [
|
|
nsInput.e("icon"),
|
|
"icon-arrow-down",
|
|
nsCascader.is("reverse", popperVisible.value)
|
|
];
|
|
});
|
|
const inputClass = computed(() => {
|
|
return nsCascader.is("focus", popperVisible.value || filterFocus.value);
|
|
});
|
|
const contentRef = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = tooltipRef.value) == null ? void 0 : _a2.popperRef) == null ? void 0 : _b.contentRef;
|
|
});
|
|
const togglePopperVisible = (visible) => {
|
|
var _a2, _b, _c;
|
|
if (isDisabled.value)
|
|
return;
|
|
visible = visible != null ? visible : !popperVisible.value;
|
|
if (visible !== popperVisible.value) {
|
|
popperVisible.value = visible;
|
|
(_b = (_a2 = input.value) == null ? void 0 : _a2.input) == null ? void 0 : _b.setAttribute("aria-expanded", `${visible}`);
|
|
if (visible) {
|
|
updatePopperPosition();
|
|
nextTick((_c = cascaderPanelRef.value) == null ? void 0 : _c.scrollToExpandingNode);
|
|
} else if (props2.filterable) {
|
|
syncPresentTextValue();
|
|
}
|
|
emit("visibleChange", visible);
|
|
}
|
|
};
|
|
const updatePopperPosition = () => {
|
|
nextTick(() => {
|
|
var _a2;
|
|
(_a2 = tooltipRef.value) == null ? void 0 : _a2.updatePopper();
|
|
});
|
|
};
|
|
const hideSuggestionPanel = () => {
|
|
filtering.value = false;
|
|
};
|
|
const genTag3 = (node) => {
|
|
const { showAllLevels, separator } = props2;
|
|
return {
|
|
node,
|
|
key: node.uid,
|
|
text: node.calcText(showAllLevels, separator),
|
|
hitState: false,
|
|
closable: !isDisabled.value && !node.isDisabled,
|
|
isCollapseTag: false
|
|
};
|
|
};
|
|
const deleteTag = (tag) => {
|
|
var _a2;
|
|
const node = tag.node;
|
|
node.doCheck(false);
|
|
(_a2 = cascaderPanelRef.value) == null ? void 0 : _a2.calculateCheckedValue();
|
|
emit("removeTag", node.valueByOption);
|
|
};
|
|
const calculatePresentTags = () => {
|
|
if (!multiple.value)
|
|
return;
|
|
const nodes = checkedNodes.value;
|
|
const tags = [];
|
|
const allTags = [];
|
|
nodes.forEach((node) => allTags.push(genTag3(node)));
|
|
allPresentTags.value = allTags;
|
|
if (nodes.length) {
|
|
nodes.slice(0, props2.maxCollapseTags).forEach((node) => tags.push(genTag3(node)));
|
|
const rest2 = nodes.slice(props2.maxCollapseTags);
|
|
const restCount = rest2.length;
|
|
if (restCount) {
|
|
if (props2.collapseTags) {
|
|
tags.push({
|
|
key: -1,
|
|
text: `+ ${restCount}`,
|
|
closable: false,
|
|
isCollapseTag: true
|
|
});
|
|
} else {
|
|
rest2.forEach((node) => tags.push(genTag3(node)));
|
|
}
|
|
}
|
|
}
|
|
presentTags.value = tags;
|
|
};
|
|
const calculateSuggestions = () => {
|
|
var _a2, _b;
|
|
const { filterMethod, showAllLevels, separator } = props2;
|
|
const res = (_b = (_a2 = cascaderPanelRef.value) == null ? void 0 : _a2.getFlattedNodes(!props2.props.checkStrictly)) == null ? void 0 : _b.filter((node) => {
|
|
if (node.isDisabled)
|
|
return false;
|
|
node.calcText(showAllLevels, separator);
|
|
return filterMethod(node, searchKeyword.value);
|
|
});
|
|
if (multiple.value) {
|
|
presentTags.value.forEach((tag) => {
|
|
tag.hitState = false;
|
|
});
|
|
allPresentTags.value.forEach((tag) => {
|
|
tag.hitState = false;
|
|
});
|
|
}
|
|
filtering.value = true;
|
|
suggestions.value = res;
|
|
updatePopperPosition();
|
|
};
|
|
const focusFirstNode = () => {
|
|
var _a2;
|
|
let firstNode;
|
|
if (filtering.value && suggestionPanel.value) {
|
|
firstNode = suggestionPanel.value.$el.querySelector(`.${nsCascader.e("suggestion-item")}`);
|
|
} else {
|
|
firstNode = (_a2 = cascaderPanelRef.value) == null ? void 0 : _a2.$el.querySelector(`.${nsCascader.b("node")}[tabindex="-1"]`);
|
|
}
|
|
if (firstNode) {
|
|
firstNode.focus();
|
|
!filtering.value && firstNode.click();
|
|
}
|
|
};
|
|
const updateStyle = () => {
|
|
var _a2, _b;
|
|
const inputInner = (_a2 = input.value) == null ? void 0 : _a2.input;
|
|
const tagWrapperEl = tagWrapper.value;
|
|
const suggestionPanelEl = (_b = suggestionPanel.value) == null ? void 0 : _b.$el;
|
|
if (!isClient || !inputInner)
|
|
return;
|
|
if (suggestionPanelEl) {
|
|
const suggestionList = suggestionPanelEl.querySelector(`.${nsCascader.e("suggestion-list")}`);
|
|
suggestionList.style.minWidth = `${inputInner.offsetWidth}px`;
|
|
}
|
|
if (tagWrapperEl) {
|
|
const { offsetHeight } = tagWrapperEl;
|
|
const height = presentTags.value.length > 0 ? `${Math.max(offsetHeight, inputInitialHeight) - 2}px` : `${inputInitialHeight}px`;
|
|
inputInner.style.height = height;
|
|
updatePopperPosition();
|
|
}
|
|
};
|
|
const getCheckedNodes = (leafOnly) => {
|
|
var _a2;
|
|
return (_a2 = cascaderPanelRef.value) == null ? void 0 : _a2.getCheckedNodes(leafOnly);
|
|
};
|
|
const handleExpandChange = (value) => {
|
|
updatePopperPosition();
|
|
emit("expandChange", value);
|
|
};
|
|
const handleKeyDown = (e) => {
|
|
if (isComposing.value)
|
|
return;
|
|
switch (e.code) {
|
|
case EVENT_CODE.enter:
|
|
case EVENT_CODE.numpadEnter:
|
|
togglePopperVisible();
|
|
break;
|
|
case EVENT_CODE.down:
|
|
togglePopperVisible(true);
|
|
nextTick(focusFirstNode);
|
|
e.preventDefault();
|
|
break;
|
|
case EVENT_CODE.esc:
|
|
if (popperVisible.value === true) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
togglePopperVisible(false);
|
|
}
|
|
break;
|
|
case EVENT_CODE.tab:
|
|
togglePopperVisible(false);
|
|
break;
|
|
}
|
|
};
|
|
const handleClear = () => {
|
|
var _a2;
|
|
(_a2 = cascaderPanelRef.value) == null ? void 0 : _a2.clearCheckedNodes();
|
|
if (!popperVisible.value && props2.filterable) {
|
|
syncPresentTextValue();
|
|
}
|
|
togglePopperVisible(false);
|
|
emit("clear");
|
|
};
|
|
const syncPresentTextValue = () => {
|
|
const { value } = presentText;
|
|
inputValue.value = value;
|
|
searchInputValue.value = value;
|
|
};
|
|
const handleSuggestionClick = (node) => {
|
|
var _a2, _b;
|
|
const { checked } = node;
|
|
if (multiple.value) {
|
|
(_a2 = cascaderPanelRef.value) == null ? void 0 : _a2.handleCheckChange(node, !checked, false);
|
|
} else {
|
|
!checked && ((_b = cascaderPanelRef.value) == null ? void 0 : _b.handleCheckChange(node, true, false));
|
|
togglePopperVisible(false);
|
|
}
|
|
};
|
|
const handleSuggestionKeyDown = (e) => {
|
|
const target2 = e.target;
|
|
const { code } = e;
|
|
switch (code) {
|
|
case EVENT_CODE.up:
|
|
case EVENT_CODE.down: {
|
|
e.preventDefault();
|
|
const distance = code === EVENT_CODE.up ? -1 : 1;
|
|
focusNode(getSibling(target2, distance, `.${nsCascader.e("suggestion-item")}[tabindex="-1"]`));
|
|
break;
|
|
}
|
|
case EVENT_CODE.enter:
|
|
case EVENT_CODE.numpadEnter:
|
|
target2.click();
|
|
break;
|
|
}
|
|
};
|
|
const handleDelete = () => {
|
|
const tags = presentTags.value;
|
|
const lastTag = tags[tags.length - 1];
|
|
pressDeleteCount = searchInputValue.value ? 0 : pressDeleteCount + 1;
|
|
if (!lastTag || !pressDeleteCount || props2.collapseTags && tags.length > 1)
|
|
return;
|
|
if (lastTag.hitState) {
|
|
deleteTag(lastTag);
|
|
} else {
|
|
lastTag.hitState = true;
|
|
}
|
|
};
|
|
const handleFocus = (e) => {
|
|
const el = e.target;
|
|
const name = nsCascader.e("search-input");
|
|
if (el.className === name) {
|
|
filterFocus.value = true;
|
|
}
|
|
emit("focus", e);
|
|
};
|
|
const handleBlur = (e) => {
|
|
filterFocus.value = false;
|
|
emit("blur", e);
|
|
};
|
|
const handleFilter = debounce_default(() => {
|
|
const { value } = searchKeyword;
|
|
if (!value)
|
|
return;
|
|
const passed = props2.beforeFilter(value);
|
|
if (isPromise(passed)) {
|
|
passed.then(calculateSuggestions).catch(() => {
|
|
});
|
|
} else if (passed !== false) {
|
|
calculateSuggestions();
|
|
} else {
|
|
hideSuggestionPanel();
|
|
}
|
|
}, props2.debounce);
|
|
const handleInput = (val, e) => {
|
|
!popperVisible.value && togglePopperVisible(true);
|
|
if (e == null ? void 0 : e.isComposing)
|
|
return;
|
|
val ? handleFilter() : hideSuggestionPanel();
|
|
};
|
|
const getInputInnerHeight = (inputInner) => Number.parseFloat(useCssVar(nsInput.cssVarName("input-height"), inputInner).value) - 2;
|
|
watch(filtering, updatePopperPosition);
|
|
watch([checkedNodes, isDisabled, () => props2.collapseTags], calculatePresentTags);
|
|
watch(presentTags, () => {
|
|
nextTick(() => updateStyle());
|
|
});
|
|
watch(realSize, async () => {
|
|
await nextTick();
|
|
const inputInner = input.value.input;
|
|
inputInitialHeight = getInputInnerHeight(inputInner) || inputInitialHeight;
|
|
updateStyle();
|
|
});
|
|
watch(presentText, syncPresentTextValue, { immediate: true });
|
|
onMounted(() => {
|
|
const inputInner = input.value.input;
|
|
const inputInnerHeight = getInputInnerHeight(inputInner);
|
|
inputInitialHeight = inputInner.offsetHeight || inputInnerHeight;
|
|
useResizeObserver(inputInner, updateStyle);
|
|
});
|
|
expose({
|
|
getCheckedNodes,
|
|
cascaderPanelRef,
|
|
togglePopperVisible,
|
|
contentRef,
|
|
presentText
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElTooltip), {
|
|
ref_key: "tooltipRef",
|
|
ref: tooltipRef,
|
|
visible: popperVisible.value,
|
|
teleported: _ctx.teleported,
|
|
"popper-class": [unref(nsCascader).e("dropdown"), _ctx.popperClass],
|
|
"popper-options": popperOptions,
|
|
"fallback-placements": _ctx.fallbackPlacements,
|
|
"stop-popper-mouse-event": false,
|
|
"gpu-acceleration": false,
|
|
placement: _ctx.placement,
|
|
transition: `${unref(nsCascader).namespace.value}-zoom-in-top`,
|
|
effect: "light",
|
|
pure: "",
|
|
persistent: _ctx.persistent,
|
|
onHide: hideSuggestionPanel
|
|
}, {
|
|
default: withCtx(() => [
|
|
withDirectives((openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(unref(cascaderKls)),
|
|
style: normalizeStyle(unref(cascaderStyle)),
|
|
onClick: () => togglePopperVisible(unref(readonly2) ? void 0 : true),
|
|
onKeydown: handleKeyDown,
|
|
onMouseenter: ($event) => inputHover.value = true,
|
|
onMouseleave: ($event) => inputHover.value = false
|
|
}, [
|
|
createVNode(unref(ElInput), {
|
|
ref_key: "input",
|
|
ref: input,
|
|
modelValue: inputValue.value,
|
|
"onUpdate:modelValue": ($event) => inputValue.value = $event,
|
|
placeholder: unref(currentPlaceholder),
|
|
readonly: unref(readonly2),
|
|
disabled: unref(isDisabled),
|
|
"validate-event": false,
|
|
size: unref(realSize),
|
|
class: normalizeClass(unref(inputClass)),
|
|
tabindex: unref(multiple) && _ctx.filterable && !unref(isDisabled) ? -1 : void 0,
|
|
onCompositionstart: unref(handleComposition),
|
|
onCompositionupdate: unref(handleComposition),
|
|
onCompositionend: unref(handleComposition),
|
|
onFocus: handleFocus,
|
|
onBlur: handleBlur,
|
|
onInput: handleInput
|
|
}, createSlots({
|
|
suffix: withCtx(() => [
|
|
unref(clearBtnVisible) ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: "clear",
|
|
class: normalizeClass([unref(nsInput).e("icon"), "icon-circle-close"]),
|
|
onClick: withModifiers(handleClear, ["stop"])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(circle_close_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "onClick"])) : (openBlock(), createBlock(unref(ElIcon), {
|
|
key: "arrow-down",
|
|
class: normalizeClass(unref(cascaderIconKls)),
|
|
onClick: withModifiers(($event) => togglePopperVisible(), ["stop"])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(arrow_down_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "onClick"]))
|
|
]),
|
|
_: 2
|
|
}, [
|
|
_ctx.$slots.prefix ? {
|
|
name: "prefix",
|
|
fn: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "prefix")
|
|
])
|
|
} : void 0
|
|
]), 1032, ["modelValue", "onUpdate:modelValue", "placeholder", "readonly", "disabled", "size", "class", "tabindex", "onCompositionstart", "onCompositionupdate", "onCompositionend"]),
|
|
unref(multiple) ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
ref_key: "tagWrapper",
|
|
ref: tagWrapper,
|
|
class: normalizeClass([
|
|
unref(nsCascader).e("tags"),
|
|
unref(nsCascader).is("validate", Boolean(unref(validateState)))
|
|
])
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(presentTags.value, (tag) => {
|
|
return openBlock(), createBlock(unref(ElTag), {
|
|
key: tag.key,
|
|
type: _ctx.tagType,
|
|
size: unref(tagSize),
|
|
effect: _ctx.tagEffect,
|
|
hit: tag.hitState,
|
|
closable: tag.closable,
|
|
"disable-transitions": "",
|
|
onClose: ($event) => deleteTag(tag)
|
|
}, {
|
|
default: withCtx(() => [
|
|
tag.isCollapseTag === false ? (openBlock(), createElementBlock("span", { key: 0 }, toDisplayString(tag.text), 1)) : (openBlock(), createBlock(unref(ElTooltip), {
|
|
key: 1,
|
|
disabled: popperVisible.value || !_ctx.collapseTagsTooltip,
|
|
"fallback-placements": ["bottom", "top", "right", "left"],
|
|
placement: "bottom",
|
|
effect: "light"
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("span", null, toDisplayString(tag.text), 1)
|
|
]),
|
|
content: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(nsCascader).e("collapse-tags"))
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(allPresentTags.value.slice(_ctx.maxCollapseTags), (tag2, idx) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
key: idx,
|
|
class: normalizeClass(unref(nsCascader).e("collapse-tag"))
|
|
}, [
|
|
(openBlock(), createBlock(unref(ElTag), {
|
|
key: tag2.key,
|
|
class: "in-tooltip",
|
|
type: _ctx.tagType,
|
|
size: unref(tagSize),
|
|
effect: _ctx.tagEffect,
|
|
hit: tag2.hitState,
|
|
closable: tag2.closable,
|
|
"disable-transitions": "",
|
|
onClose: ($event) => deleteTag(tag2)
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("span", null, toDisplayString(tag2.text), 1)
|
|
]),
|
|
_: 2
|
|
}, 1032, ["type", "size", "effect", "hit", "closable", "onClose"]))
|
|
], 2);
|
|
}), 128))
|
|
], 2)
|
|
]),
|
|
_: 2
|
|
}, 1032, ["disabled"]))
|
|
]),
|
|
_: 2
|
|
}, 1032, ["type", "size", "effect", "hit", "closable", "onClose"]);
|
|
}), 128)),
|
|
_ctx.filterable && !unref(isDisabled) ? withDirectives((openBlock(), createElementBlock("input", {
|
|
key: 0,
|
|
"onUpdate:modelValue": ($event) => searchInputValue.value = $event,
|
|
type: "text",
|
|
class: normalizeClass(unref(nsCascader).e("search-input")),
|
|
placeholder: unref(presentText) ? "" : unref(inputPlaceholder),
|
|
onInput: (e) => handleInput(searchInputValue.value, e),
|
|
onClick: withModifiers(($event) => togglePopperVisible(true), ["stop"]),
|
|
onKeydown: withKeys(handleDelete, ["delete"]),
|
|
onCompositionstart: unref(handleComposition),
|
|
onCompositionupdate: unref(handleComposition),
|
|
onCompositionend: unref(handleComposition),
|
|
onFocus: handleFocus,
|
|
onBlur: handleBlur
|
|
}, null, 42, ["onUpdate:modelValue", "placeholder", "onInput", "onClick", "onKeydown", "onCompositionstart", "onCompositionupdate", "onCompositionend"])), [
|
|
[vModelText, searchInputValue.value]
|
|
]) : createCommentVNode("v-if", true)
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 46, ["onClick", "onMouseenter", "onMouseleave"])), [
|
|
[unref(ClickOutside), () => togglePopperVisible(false), unref(contentRef)]
|
|
])
|
|
]),
|
|
content: withCtx(() => [
|
|
withDirectives(createVNode(unref(ElCascaderPanel), {
|
|
ref_key: "cascaderPanelRef",
|
|
ref: cascaderPanelRef,
|
|
modelValue: unref(checkedValue),
|
|
"onUpdate:modelValue": ($event) => isRef(checkedValue) ? checkedValue.value = $event : null,
|
|
options: _ctx.options,
|
|
props: props2.props,
|
|
border: false,
|
|
"render-label": _ctx.$slots.default,
|
|
onExpandChange: handleExpandChange,
|
|
onClose: ($event) => _ctx.$nextTick(() => togglePopperVisible(false))
|
|
}, {
|
|
empty: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "empty")
|
|
]),
|
|
_: 3
|
|
}, 8, ["modelValue", "onUpdate:modelValue", "options", "props", "render-label", "onClose"]), [
|
|
[vShow, !filtering.value]
|
|
]),
|
|
_ctx.filterable ? withDirectives((openBlock(), createBlock(unref(ElScrollbar), {
|
|
key: 0,
|
|
ref_key: "suggestionPanel",
|
|
ref: suggestionPanel,
|
|
tag: "ul",
|
|
class: normalizeClass(unref(nsCascader).e("suggestion-panel")),
|
|
"view-class": unref(nsCascader).e("suggestion-list"),
|
|
onKeydown: handleSuggestionKeyDown
|
|
}, {
|
|
default: withCtx(() => [
|
|
suggestions.value.length ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(suggestions.value, (item) => {
|
|
return openBlock(), createElementBlock("li", {
|
|
key: item.uid,
|
|
class: normalizeClass([
|
|
unref(nsCascader).e("suggestion-item"),
|
|
unref(nsCascader).is("checked", item.checked)
|
|
]),
|
|
tabindex: -1,
|
|
onClick: ($event) => handleSuggestionClick(item)
|
|
}, [
|
|
renderSlot(_ctx.$slots, "suggestion-item", { item }, () => [
|
|
createBaseVNode("span", null, toDisplayString(item.text), 1),
|
|
item.checked ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(check_default))
|
|
]),
|
|
_: 1
|
|
})) : createCommentVNode("v-if", true)
|
|
])
|
|
], 10, ["onClick"]);
|
|
}), 128)) : renderSlot(_ctx.$slots, "empty", { key: 1 }, () => [
|
|
createBaseVNode("li", {
|
|
class: normalizeClass(unref(nsCascader).e("empty-text"))
|
|
}, toDisplayString(unref(t)("el.cascader.noMatch")), 3)
|
|
])
|
|
]),
|
|
_: 3
|
|
}, 8, ["class", "view-class"])), [
|
|
[vShow, filtering.value]
|
|
]) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 8, ["visible", "teleported", "popper-class", "fallback-placements", "placement", "transition", "persistent"]);
|
|
};
|
|
}
|
|
});
|
|
var Cascader = _export_sfc(_sfc_main40, [["__file", "cascader.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/cascader/index.mjs
|
|
var ElCascader = withInstall(Cascader);
|
|
|
|
// node_modules/element-plus/es/components/check-tag/src/check-tag.mjs
|
|
var checkTagProps = buildProps({
|
|
checked: Boolean,
|
|
disabled: Boolean,
|
|
type: {
|
|
type: String,
|
|
values: ["primary", "success", "info", "warning", "danger"],
|
|
default: "primary"
|
|
}
|
|
});
|
|
var checkTagEmits = {
|
|
"update:checked": (value) => isBoolean2(value),
|
|
[CHANGE_EVENT]: (value) => isBoolean2(value)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/check-tag/src/check-tag2.mjs
|
|
var __default__34 = defineComponent({
|
|
name: "ElCheckTag"
|
|
});
|
|
var _sfc_main41 = defineComponent({
|
|
...__default__34,
|
|
props: checkTagProps,
|
|
emits: checkTagEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("check-tag");
|
|
const isDisabled = computed(() => props2.disabled);
|
|
const containerKls = computed(() => [
|
|
ns.b(),
|
|
ns.is("checked", props2.checked),
|
|
ns.is("disabled", isDisabled.value),
|
|
ns.m(props2.type || "primary")
|
|
]);
|
|
const handleChange = () => {
|
|
if (isDisabled.value)
|
|
return;
|
|
const checked = !props2.checked;
|
|
emit(CHANGE_EVENT, checked);
|
|
emit("update:checked", checked);
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("span", {
|
|
class: normalizeClass(unref(containerKls)),
|
|
onClick: handleChange
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var CheckTag = _export_sfc(_sfc_main41, [["__file", "check-tag.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/check-tag/index.mjs
|
|
var ElCheckTag = withInstall(CheckTag);
|
|
|
|
// node_modules/element-plus/es/components/col/src/col.mjs
|
|
var colProps = buildProps({
|
|
tag: {
|
|
type: String,
|
|
default: "div"
|
|
},
|
|
span: {
|
|
type: Number,
|
|
default: 24
|
|
},
|
|
offset: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
pull: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
push: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
xs: {
|
|
type: definePropType([Number, Object]),
|
|
default: () => mutable({})
|
|
},
|
|
sm: {
|
|
type: definePropType([Number, Object]),
|
|
default: () => mutable({})
|
|
},
|
|
md: {
|
|
type: definePropType([Number, Object]),
|
|
default: () => mutable({})
|
|
},
|
|
lg: {
|
|
type: definePropType([Number, Object]),
|
|
default: () => mutable({})
|
|
},
|
|
xl: {
|
|
type: definePropType([Number, Object]),
|
|
default: () => mutable({})
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/row/src/constants.mjs
|
|
var rowContextKey = Symbol("rowContextKey");
|
|
|
|
// node_modules/element-plus/es/components/col/src/col2.mjs
|
|
var __default__35 = defineComponent({
|
|
name: "ElCol"
|
|
});
|
|
var _sfc_main42 = defineComponent({
|
|
...__default__35,
|
|
props: colProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const { gutter } = inject(rowContextKey, { gutter: computed(() => 0) });
|
|
const ns = useNamespace("col");
|
|
const style = computed(() => {
|
|
const styles = {};
|
|
if (gutter.value) {
|
|
styles.paddingLeft = styles.paddingRight = `${gutter.value / 2}px`;
|
|
}
|
|
return styles;
|
|
});
|
|
const colKls = computed(() => {
|
|
const classes = [];
|
|
const pos = ["span", "offset", "pull", "push"];
|
|
pos.forEach((prop) => {
|
|
const size3 = props2[prop];
|
|
if (isNumber2(size3)) {
|
|
if (prop === "span")
|
|
classes.push(ns.b(`${props2[prop]}`));
|
|
else if (size3 > 0)
|
|
classes.push(ns.b(`${prop}-${props2[prop]}`));
|
|
}
|
|
});
|
|
const sizes = ["xs", "sm", "md", "lg", "xl"];
|
|
sizes.forEach((size3) => {
|
|
if (isNumber2(props2[size3])) {
|
|
classes.push(ns.b(`${size3}-${props2[size3]}`));
|
|
} else if (isObject(props2[size3])) {
|
|
Object.entries(props2[size3]).forEach(([prop, sizeProp]) => {
|
|
classes.push(prop !== "span" ? ns.b(`${size3}-${prop}-${sizeProp}`) : ns.b(`${size3}-${sizeProp}`));
|
|
});
|
|
}
|
|
});
|
|
if (gutter.value) {
|
|
classes.push(ns.is("guttered"));
|
|
}
|
|
return [ns.b(), classes];
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(resolveDynamicComponent(_ctx.tag), {
|
|
class: normalizeClass(unref(colKls)),
|
|
style: normalizeStyle(unref(style))
|
|
}, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 8, ["class", "style"]);
|
|
};
|
|
}
|
|
});
|
|
var Col = _export_sfc(_sfc_main42, [["__file", "col.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/col/index.mjs
|
|
var ElCol = withInstall(Col);
|
|
|
|
// node_modules/element-plus/es/components/collapse/src/collapse2.mjs
|
|
var emitChangeFn = (value) => isNumber2(value) || isString(value) || isArray(value);
|
|
var collapseProps = buildProps({
|
|
accordion: Boolean,
|
|
modelValue: {
|
|
type: definePropType([Array, String, Number]),
|
|
default: () => mutable([])
|
|
},
|
|
expandIconPosition: {
|
|
type: definePropType([String]),
|
|
default: "right"
|
|
},
|
|
beforeCollapse: {
|
|
type: definePropType(Function)
|
|
}
|
|
});
|
|
var collapseEmits = {
|
|
[UPDATE_MODEL_EVENT]: emitChangeFn,
|
|
[CHANGE_EVENT]: emitChangeFn
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/collapse/src/constants.mjs
|
|
var collapseContextKey = Symbol("collapseContextKey");
|
|
|
|
// node_modules/element-plus/es/components/collapse-transition/src/collapse-transition.mjs
|
|
var __default__36 = defineComponent({
|
|
name: "ElCollapseTransition"
|
|
});
|
|
var _sfc_main43 = defineComponent({
|
|
...__default__36,
|
|
setup(__props) {
|
|
const ns = useNamespace("collapse-transition");
|
|
const reset = (el) => {
|
|
el.style.maxHeight = "";
|
|
el.style.overflow = el.dataset.oldOverflow;
|
|
el.style.paddingTop = el.dataset.oldPaddingTop;
|
|
el.style.paddingBottom = el.dataset.oldPaddingBottom;
|
|
};
|
|
const on2 = {
|
|
beforeEnter(el) {
|
|
if (!el.dataset)
|
|
el.dataset = {};
|
|
el.dataset.oldPaddingTop = el.style.paddingTop;
|
|
el.dataset.oldPaddingBottom = el.style.paddingBottom;
|
|
if (el.style.height)
|
|
el.dataset.elExistsHeight = el.style.height;
|
|
el.style.maxHeight = 0;
|
|
el.style.paddingTop = 0;
|
|
el.style.paddingBottom = 0;
|
|
},
|
|
enter(el) {
|
|
requestAnimationFrame(() => {
|
|
el.dataset.oldOverflow = el.style.overflow;
|
|
if (el.dataset.elExistsHeight) {
|
|
el.style.maxHeight = el.dataset.elExistsHeight;
|
|
} else if (el.scrollHeight !== 0) {
|
|
el.style.maxHeight = `${el.scrollHeight}px`;
|
|
} else {
|
|
el.style.maxHeight = 0;
|
|
}
|
|
el.style.paddingTop = el.dataset.oldPaddingTop;
|
|
el.style.paddingBottom = el.dataset.oldPaddingBottom;
|
|
el.style.overflow = "hidden";
|
|
});
|
|
},
|
|
afterEnter(el) {
|
|
el.style.maxHeight = "";
|
|
el.style.overflow = el.dataset.oldOverflow;
|
|
},
|
|
enterCancelled(el) {
|
|
reset(el);
|
|
},
|
|
beforeLeave(el) {
|
|
if (!el.dataset)
|
|
el.dataset = {};
|
|
el.dataset.oldPaddingTop = el.style.paddingTop;
|
|
el.dataset.oldPaddingBottom = el.style.paddingBottom;
|
|
el.dataset.oldOverflow = el.style.overflow;
|
|
el.style.maxHeight = `${el.scrollHeight}px`;
|
|
el.style.overflow = "hidden";
|
|
},
|
|
leave(el) {
|
|
if (el.scrollHeight !== 0) {
|
|
el.style.maxHeight = 0;
|
|
el.style.paddingTop = 0;
|
|
el.style.paddingBottom = 0;
|
|
}
|
|
},
|
|
afterLeave(el) {
|
|
reset(el);
|
|
},
|
|
leaveCancelled(el) {
|
|
reset(el);
|
|
}
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(Transition, mergeProps({
|
|
name: unref(ns).b()
|
|
}, toHandlers(on2)), {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 16, ["name"]);
|
|
};
|
|
}
|
|
});
|
|
var CollapseTransition = _export_sfc(_sfc_main43, [["__file", "collapse-transition.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/collapse-transition/index.mjs
|
|
var ElCollapseTransition = withInstall(CollapseTransition);
|
|
|
|
// node_modules/element-plus/es/components/collapse/src/collapse-item.mjs
|
|
var collapseItemProps = buildProps({
|
|
title: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
name: {
|
|
type: definePropType([String, Number]),
|
|
default: void 0
|
|
},
|
|
icon: {
|
|
type: iconPropType,
|
|
default: arrow_right_default
|
|
},
|
|
disabled: Boolean
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/collapse/src/use-collapse.mjs
|
|
var SCOPE4 = "ElCollapse";
|
|
var useCollapse = (props2, emit) => {
|
|
const activeNames = ref(castArray_default(props2.modelValue));
|
|
const setActiveNames = (_activeNames) => {
|
|
activeNames.value = _activeNames;
|
|
const value = props2.accordion ? activeNames.value[0] : activeNames.value;
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emit(CHANGE_EVENT, value);
|
|
};
|
|
const handleChange = (name) => {
|
|
if (props2.accordion) {
|
|
setActiveNames([activeNames.value[0] === name ? "" : name]);
|
|
} else {
|
|
const _activeNames = [...activeNames.value];
|
|
const index = _activeNames.indexOf(name);
|
|
if (index > -1) {
|
|
_activeNames.splice(index, 1);
|
|
} else {
|
|
_activeNames.push(name);
|
|
}
|
|
setActiveNames(_activeNames);
|
|
}
|
|
};
|
|
const handleItemClick = async (name) => {
|
|
const { beforeCollapse } = props2;
|
|
if (!beforeCollapse) {
|
|
handleChange(name);
|
|
return;
|
|
}
|
|
const shouldChange = beforeCollapse(name);
|
|
const isPromiseOrBool = [
|
|
isPromise(shouldChange),
|
|
isBoolean2(shouldChange)
|
|
].includes(true);
|
|
if (!isPromiseOrBool) {
|
|
throwError(SCOPE4, "beforeCollapse must return type `Promise<boolean>` or `boolean`");
|
|
}
|
|
if (isPromise(shouldChange)) {
|
|
shouldChange.then((result2) => {
|
|
if (result2 !== false) {
|
|
handleChange(name);
|
|
}
|
|
}).catch((e) => {
|
|
debugWarn(SCOPE4, `some error occurred: ${e}`);
|
|
});
|
|
} else if (shouldChange) {
|
|
handleChange(name);
|
|
}
|
|
};
|
|
watch(() => props2.modelValue, () => activeNames.value = castArray_default(props2.modelValue), { deep: true });
|
|
provide(collapseContextKey, {
|
|
activeNames,
|
|
handleItemClick
|
|
});
|
|
return {
|
|
activeNames,
|
|
setActiveNames
|
|
};
|
|
};
|
|
var useCollapseDOM = (props2) => {
|
|
const ns = useNamespace("collapse");
|
|
const rootKls = computed(() => [
|
|
ns.b(),
|
|
ns.b(`icon-position-${props2.expandIconPosition}`)
|
|
]);
|
|
return {
|
|
rootKls
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/collapse/src/collapse.mjs
|
|
var __default__37 = defineComponent({
|
|
name: "ElCollapse"
|
|
});
|
|
var _sfc_main44 = defineComponent({
|
|
...__default__37,
|
|
props: collapseProps,
|
|
emits: collapseEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const { activeNames, setActiveNames } = useCollapse(props2, emit);
|
|
const { rootKls } = useCollapseDOM(props2);
|
|
expose({
|
|
activeNames,
|
|
setActiveNames
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(unref(rootKls))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Collapse = _export_sfc(_sfc_main44, [["__file", "collapse.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/collapse/src/use-collapse-item.mjs
|
|
var useCollapseItem = (props2) => {
|
|
const collapse = inject(collapseContextKey);
|
|
const { namespace } = useNamespace("collapse");
|
|
const focusing = ref(false);
|
|
const isClick = ref(false);
|
|
const idInjection = useIdInjection();
|
|
const id = computed(() => idInjection.current++);
|
|
const name = computed(() => {
|
|
var _a2;
|
|
return (_a2 = props2.name) != null ? _a2 : `${namespace.value}-id-${idInjection.prefix}-${unref(id)}`;
|
|
});
|
|
const isActive = computed(() => collapse == null ? void 0 : collapse.activeNames.value.includes(unref(name)));
|
|
const handleFocus = () => {
|
|
setTimeout(() => {
|
|
if (!isClick.value) {
|
|
focusing.value = true;
|
|
} else {
|
|
isClick.value = false;
|
|
}
|
|
}, 50);
|
|
};
|
|
const handleHeaderClick = () => {
|
|
if (props2.disabled)
|
|
return;
|
|
collapse == null ? void 0 : collapse.handleItemClick(unref(name));
|
|
focusing.value = false;
|
|
isClick.value = true;
|
|
};
|
|
const handleEnterClick = () => {
|
|
collapse == null ? void 0 : collapse.handleItemClick(unref(name));
|
|
};
|
|
return {
|
|
focusing,
|
|
id,
|
|
isActive,
|
|
handleFocus,
|
|
handleHeaderClick,
|
|
handleEnterClick
|
|
};
|
|
};
|
|
var useCollapseItemDOM = (props2, { focusing, isActive, id }) => {
|
|
const ns = useNamespace("collapse");
|
|
const rootKls = computed(() => [
|
|
ns.b("item"),
|
|
ns.is("active", unref(isActive)),
|
|
ns.is("disabled", props2.disabled)
|
|
]);
|
|
const headKls = computed(() => [
|
|
ns.be("item", "header"),
|
|
ns.is("active", unref(isActive)),
|
|
{ focusing: unref(focusing) && !props2.disabled }
|
|
]);
|
|
const arrowKls = computed(() => [
|
|
ns.be("item", "arrow"),
|
|
ns.is("active", unref(isActive))
|
|
]);
|
|
const itemTitleKls = computed(() => [ns.be("item", "title")]);
|
|
const itemWrapperKls = computed(() => ns.be("item", "wrap"));
|
|
const itemContentKls = computed(() => ns.be("item", "content"));
|
|
const scopedContentId = computed(() => ns.b(`content-${unref(id)}`));
|
|
const scopedHeadId = computed(() => ns.b(`head-${unref(id)}`));
|
|
return {
|
|
itemTitleKls,
|
|
arrowKls,
|
|
headKls,
|
|
rootKls,
|
|
itemWrapperKls,
|
|
itemContentKls,
|
|
scopedContentId,
|
|
scopedHeadId
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/collapse/src/collapse-item2.mjs
|
|
var __default__38 = defineComponent({
|
|
name: "ElCollapseItem"
|
|
});
|
|
var _sfc_main45 = defineComponent({
|
|
...__default__38,
|
|
props: collapseItemProps,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const {
|
|
focusing,
|
|
id,
|
|
isActive,
|
|
handleFocus,
|
|
handleHeaderClick,
|
|
handleEnterClick
|
|
} = useCollapseItem(props2);
|
|
const {
|
|
arrowKls,
|
|
headKls,
|
|
rootKls,
|
|
itemTitleKls,
|
|
itemWrapperKls,
|
|
itemContentKls,
|
|
scopedContentId,
|
|
scopedHeadId
|
|
} = useCollapseItemDOM(props2, { focusing, isActive, id });
|
|
expose({
|
|
isActive
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(unref(rootKls))
|
|
}, [
|
|
createBaseVNode("button", {
|
|
id: unref(scopedHeadId),
|
|
class: normalizeClass(unref(headKls)),
|
|
"aria-expanded": unref(isActive),
|
|
"aria-controls": unref(scopedContentId),
|
|
"aria-describedby": unref(scopedContentId),
|
|
tabindex: _ctx.disabled ? -1 : 0,
|
|
type: "button",
|
|
onClick: unref(handleHeaderClick),
|
|
onKeydown: withKeys(withModifiers(unref(handleEnterClick), ["stop", "prevent"]), ["space", "enter"]),
|
|
onFocus: unref(handleFocus),
|
|
onBlur: ($event) => focusing.value = false
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(itemTitleKls))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "title", { isActive: unref(isActive) }, () => [
|
|
createTextVNode(toDisplayString(_ctx.title), 1)
|
|
])
|
|
], 2),
|
|
renderSlot(_ctx.$slots, "icon", { isActive: unref(isActive) }, () => [
|
|
createVNode(unref(ElIcon), {
|
|
class: normalizeClass(unref(arrowKls))
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])
|
|
])
|
|
], 42, ["id", "aria-expanded", "aria-controls", "aria-describedby", "tabindex", "onClick", "onKeydown", "onFocus", "onBlur"]),
|
|
createVNode(unref(ElCollapseTransition), null, {
|
|
default: withCtx(() => [
|
|
withDirectives(createBaseVNode("div", {
|
|
id: unref(scopedContentId),
|
|
role: "region",
|
|
class: normalizeClass(unref(itemWrapperKls)),
|
|
"aria-hidden": !unref(isActive),
|
|
"aria-labelledby": unref(scopedHeadId)
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(itemContentKls))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2)
|
|
], 10, ["id", "aria-hidden", "aria-labelledby"]), [
|
|
[vShow, unref(isActive)]
|
|
])
|
|
]),
|
|
_: 3
|
|
})
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var CollapseItem = _export_sfc(_sfc_main45, [["__file", "collapse-item.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/collapse/index.mjs
|
|
var ElCollapse = withInstall(Collapse, {
|
|
CollapseItem
|
|
});
|
|
var ElCollapseItem = withNoopInstall(CollapseItem);
|
|
|
|
// node_modules/element-plus/es/components/color-picker/src/color-picker.mjs
|
|
var colorPickerProps = buildProps({
|
|
modelValue: String,
|
|
id: String,
|
|
showAlpha: Boolean,
|
|
colorFormat: String,
|
|
disabled: Boolean,
|
|
size: useSizeProp,
|
|
popperClass: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
tabindex: {
|
|
type: [String, Number],
|
|
default: 0
|
|
},
|
|
teleported: useTooltipContentProps.teleported,
|
|
predefine: {
|
|
type: definePropType(Array)
|
|
},
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
...useAriaProps(["ariaLabel"])
|
|
});
|
|
var colorPickerEmits = {
|
|
[UPDATE_MODEL_EVENT]: (val) => isString(val) || isNil_default(val),
|
|
[CHANGE_EVENT]: (val) => isString(val) || isNil_default(val),
|
|
activeChange: (val) => isString(val) || isNil_default(val),
|
|
focus: (evt) => evt instanceof FocusEvent,
|
|
blur: (evt) => evt instanceof FocusEvent
|
|
};
|
|
var colorPickerContextKey = Symbol("colorPickerContextKey");
|
|
|
|
// node_modules/element-plus/es/components/color-picker/src/props/alpha-slider.mjs
|
|
var alphaSliderProps = buildProps({
|
|
color: {
|
|
type: definePropType(Object),
|
|
required: true
|
|
},
|
|
vertical: {
|
|
type: Boolean,
|
|
default: false
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/color-picker/src/utils/draggable.mjs
|
|
var isDragging = false;
|
|
function draggable(element, options) {
|
|
if (!isClient)
|
|
return;
|
|
const moveFn = function(event) {
|
|
var _a2;
|
|
(_a2 = options.drag) == null ? void 0 : _a2.call(options, event);
|
|
};
|
|
const upFn = function(event) {
|
|
var _a2;
|
|
document.removeEventListener("mousemove", moveFn);
|
|
document.removeEventListener("mouseup", upFn);
|
|
document.removeEventListener("touchmove", moveFn);
|
|
document.removeEventListener("touchend", upFn);
|
|
document.onselectstart = null;
|
|
document.ondragstart = null;
|
|
isDragging = false;
|
|
(_a2 = options.end) == null ? void 0 : _a2.call(options, event);
|
|
};
|
|
const downFn = function(event) {
|
|
var _a2;
|
|
if (isDragging)
|
|
return;
|
|
event.preventDefault();
|
|
document.onselectstart = () => false;
|
|
document.ondragstart = () => false;
|
|
document.addEventListener("mousemove", moveFn);
|
|
document.addEventListener("mouseup", upFn);
|
|
document.addEventListener("touchmove", moveFn);
|
|
document.addEventListener("touchend", upFn);
|
|
isDragging = true;
|
|
(_a2 = options.start) == null ? void 0 : _a2.call(options, event);
|
|
};
|
|
element.addEventListener("mousedown", downFn);
|
|
element.addEventListener("touchstart", downFn, { passive: false });
|
|
}
|
|
|
|
// node_modules/element-plus/es/utils/dom/position.mjs
|
|
var isInContainer = (el, container) => {
|
|
if (!isClient || !el || !container)
|
|
return false;
|
|
const elRect = el.getBoundingClientRect();
|
|
let containerRect;
|
|
if (container instanceof Element) {
|
|
containerRect = container.getBoundingClientRect();
|
|
} else {
|
|
containerRect = {
|
|
top: 0,
|
|
right: window.innerWidth,
|
|
bottom: window.innerHeight,
|
|
left: 0
|
|
};
|
|
}
|
|
return elRect.top < containerRect.bottom && elRect.bottom > containerRect.top && elRect.right > containerRect.left && elRect.left < containerRect.right;
|
|
};
|
|
var getOffsetTop = (el) => {
|
|
let offset3 = 0;
|
|
let parent2 = el;
|
|
while (parent2) {
|
|
offset3 += parent2.offsetTop;
|
|
parent2 = parent2.offsetParent;
|
|
}
|
|
return offset3;
|
|
};
|
|
var getOffsetTopDistance = (el, containerEl) => {
|
|
return Math.abs(getOffsetTop(el) - getOffsetTop(containerEl));
|
|
};
|
|
var getClientXY = (event) => {
|
|
let clientX;
|
|
let clientY;
|
|
if (event.type === "touchend") {
|
|
clientY = event.changedTouches[0].clientY;
|
|
clientX = event.changedTouches[0].clientX;
|
|
} else if (event.type.startsWith("touch")) {
|
|
clientY = event.touches[0].clientY;
|
|
clientX = event.touches[0].clientX;
|
|
} else {
|
|
clientY = event.clientY;
|
|
clientX = event.clientX;
|
|
}
|
|
return {
|
|
clientX,
|
|
clientY
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/color-picker/src/composables/use-alpha-slider.mjs
|
|
var useAlphaSlider = (props2) => {
|
|
const instance = getCurrentInstance();
|
|
const { t } = useLocale();
|
|
const thumb = shallowRef();
|
|
const bar = shallowRef();
|
|
const alpha = computed(() => props2.color.get("alpha"));
|
|
const alphaLabel = computed(() => t("el.colorpicker.alphaLabel"));
|
|
function handleClick(event) {
|
|
var _a2;
|
|
const target2 = event.target;
|
|
if (target2 !== thumb.value) {
|
|
handleDrag(event);
|
|
}
|
|
(_a2 = thumb.value) == null ? void 0 : _a2.focus();
|
|
}
|
|
function handleDrag(event) {
|
|
if (!bar.value || !thumb.value)
|
|
return;
|
|
const el = instance.vnode.el;
|
|
const rect = el.getBoundingClientRect();
|
|
const { clientX, clientY } = getClientXY(event);
|
|
if (!props2.vertical) {
|
|
let left = clientX - rect.left;
|
|
left = Math.max(thumb.value.offsetWidth / 2, left);
|
|
left = Math.min(left, rect.width - thumb.value.offsetWidth / 2);
|
|
props2.color.set("alpha", Math.round((left - thumb.value.offsetWidth / 2) / (rect.width - thumb.value.offsetWidth) * 100));
|
|
} else {
|
|
let top = clientY - rect.top;
|
|
top = Math.max(thumb.value.offsetHeight / 2, top);
|
|
top = Math.min(top, rect.height - thumb.value.offsetHeight / 2);
|
|
props2.color.set("alpha", Math.round((top - thumb.value.offsetHeight / 2) / (rect.height - thumb.value.offsetHeight) * 100));
|
|
}
|
|
}
|
|
function handleKeydown(event) {
|
|
const { code, shiftKey } = event;
|
|
const step = shiftKey ? 10 : 1;
|
|
switch (code) {
|
|
case EVENT_CODE.left:
|
|
case EVENT_CODE.down:
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
incrementPosition(-step);
|
|
break;
|
|
case EVENT_CODE.right:
|
|
case EVENT_CODE.up:
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
incrementPosition(step);
|
|
break;
|
|
}
|
|
}
|
|
function incrementPosition(step) {
|
|
let next = alpha.value + step;
|
|
next = next < 0 ? 0 : next > 100 ? 100 : next;
|
|
props2.color.set("alpha", next);
|
|
}
|
|
return {
|
|
thumb,
|
|
bar,
|
|
alpha,
|
|
alphaLabel,
|
|
handleDrag,
|
|
handleClick,
|
|
handleKeydown
|
|
};
|
|
};
|
|
var useAlphaSliderDOM = (props2, {
|
|
bar,
|
|
thumb,
|
|
handleDrag
|
|
}) => {
|
|
const instance = getCurrentInstance();
|
|
const ns = useNamespace("color-alpha-slider");
|
|
const thumbLeft = ref(0);
|
|
const thumbTop = ref(0);
|
|
const background = ref();
|
|
function getThumbLeft() {
|
|
if (!thumb.value)
|
|
return 0;
|
|
if (props2.vertical)
|
|
return 0;
|
|
const el = instance.vnode.el;
|
|
const alpha = props2.color.get("alpha");
|
|
if (!el)
|
|
return 0;
|
|
return Math.round(alpha * (el.offsetWidth - thumb.value.offsetWidth / 2) / 100);
|
|
}
|
|
function getThumbTop() {
|
|
if (!thumb.value)
|
|
return 0;
|
|
const el = instance.vnode.el;
|
|
if (!props2.vertical)
|
|
return 0;
|
|
const alpha = props2.color.get("alpha");
|
|
if (!el)
|
|
return 0;
|
|
return Math.round(alpha * (el.offsetHeight - thumb.value.offsetHeight / 2) / 100);
|
|
}
|
|
function getBackground() {
|
|
if (props2.color && props2.color.value) {
|
|
const { r, g, b: b2 } = props2.color.toRgb();
|
|
return `linear-gradient(to right, rgba(${r}, ${g}, ${b2}, 0) 0%, rgba(${r}, ${g}, ${b2}, 1) 100%)`;
|
|
}
|
|
return "";
|
|
}
|
|
function update2() {
|
|
thumbLeft.value = getThumbLeft();
|
|
thumbTop.value = getThumbTop();
|
|
background.value = getBackground();
|
|
}
|
|
onMounted(() => {
|
|
if (!bar.value || !thumb.value)
|
|
return;
|
|
const dragConfig = {
|
|
drag: (event) => {
|
|
handleDrag(event);
|
|
},
|
|
end: (event) => {
|
|
handleDrag(event);
|
|
}
|
|
};
|
|
draggable(bar.value, dragConfig);
|
|
draggable(thumb.value, dragConfig);
|
|
update2();
|
|
});
|
|
watch(() => props2.color.get("alpha"), () => update2());
|
|
watch(() => props2.color.value, () => update2());
|
|
const rootKls = computed(() => [ns.b(), ns.is("vertical", props2.vertical)]);
|
|
const barKls = computed(() => ns.e("bar"));
|
|
const thumbKls = computed(() => ns.e("thumb"));
|
|
const barStyle = computed(() => ({ background: background.value }));
|
|
const thumbStyle = computed(() => ({
|
|
left: addUnit(thumbLeft.value),
|
|
top: addUnit(thumbTop.value)
|
|
}));
|
|
return { rootKls, barKls, barStyle, thumbKls, thumbStyle, update: update2 };
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/color-picker/src/components/alpha-slider.mjs
|
|
var COMPONENT_NAME10 = "ElColorAlphaSlider";
|
|
var __default__39 = defineComponent({
|
|
name: COMPONENT_NAME10
|
|
});
|
|
var _sfc_main46 = defineComponent({
|
|
...__default__39,
|
|
props: alphaSliderProps,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const {
|
|
alpha,
|
|
alphaLabel,
|
|
bar,
|
|
thumb,
|
|
handleDrag,
|
|
handleClick,
|
|
handleKeydown
|
|
} = useAlphaSlider(props2);
|
|
const { rootKls, barKls, barStyle, thumbKls, thumbStyle, update: update2 } = useAlphaSliderDOM(props2, {
|
|
bar,
|
|
thumb,
|
|
handleDrag
|
|
});
|
|
expose({
|
|
update: update2,
|
|
bar,
|
|
thumb
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(unref(rootKls))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
ref_key: "bar",
|
|
ref: bar,
|
|
class: normalizeClass(unref(barKls)),
|
|
style: normalizeStyle(unref(barStyle)),
|
|
onClick: unref(handleClick)
|
|
}, null, 14, ["onClick"]),
|
|
createBaseVNode("div", {
|
|
ref_key: "thumb",
|
|
ref: thumb,
|
|
class: normalizeClass(unref(thumbKls)),
|
|
style: normalizeStyle(unref(thumbStyle)),
|
|
"aria-label": unref(alphaLabel),
|
|
"aria-valuenow": unref(alpha),
|
|
"aria-orientation": _ctx.vertical ? "vertical" : "horizontal",
|
|
"aria-valuemin": "0",
|
|
"aria-valuemax": "100",
|
|
role: "slider",
|
|
tabindex: "0",
|
|
onKeydown: unref(handleKeydown)
|
|
}, null, 46, ["aria-label", "aria-valuenow", "aria-orientation", "onKeydown"])
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var AlphaSlider = _export_sfc(_sfc_main46, [["__file", "alpha-slider.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/color-picker/src/components/hue-slider.mjs
|
|
var _sfc_main47 = defineComponent({
|
|
name: "ElColorHueSlider",
|
|
props: {
|
|
color: {
|
|
type: Object,
|
|
required: true
|
|
},
|
|
vertical: Boolean
|
|
},
|
|
setup(props2) {
|
|
const ns = useNamespace("color-hue-slider");
|
|
const instance = getCurrentInstance();
|
|
const thumb = ref();
|
|
const bar = ref();
|
|
const thumbLeft = ref(0);
|
|
const thumbTop = ref(0);
|
|
const hueValue = computed(() => {
|
|
return props2.color.get("hue");
|
|
});
|
|
watch(() => hueValue.value, () => {
|
|
update2();
|
|
});
|
|
function handleClick(event) {
|
|
const target2 = event.target;
|
|
if (target2 !== thumb.value) {
|
|
handleDrag(event);
|
|
}
|
|
}
|
|
function handleDrag(event) {
|
|
if (!bar.value || !thumb.value)
|
|
return;
|
|
const el = instance.vnode.el;
|
|
const rect = el.getBoundingClientRect();
|
|
const { clientX, clientY } = getClientXY(event);
|
|
let hue;
|
|
if (!props2.vertical) {
|
|
let left = clientX - rect.left;
|
|
left = Math.min(left, rect.width - thumb.value.offsetWidth / 2);
|
|
left = Math.max(thumb.value.offsetWidth / 2, left);
|
|
hue = Math.round((left - thumb.value.offsetWidth / 2) / (rect.width - thumb.value.offsetWidth) * 360);
|
|
} else {
|
|
let top = clientY - rect.top;
|
|
top = Math.min(top, rect.height - thumb.value.offsetHeight / 2);
|
|
top = Math.max(thumb.value.offsetHeight / 2, top);
|
|
hue = Math.round((top - thumb.value.offsetHeight / 2) / (rect.height - thumb.value.offsetHeight) * 360);
|
|
}
|
|
props2.color.set("hue", hue);
|
|
}
|
|
function getThumbLeft() {
|
|
if (!thumb.value)
|
|
return 0;
|
|
const el = instance.vnode.el;
|
|
if (props2.vertical)
|
|
return 0;
|
|
const hue = props2.color.get("hue");
|
|
if (!el)
|
|
return 0;
|
|
return Math.round(hue * (el.offsetWidth - thumb.value.offsetWidth / 2) / 360);
|
|
}
|
|
function getThumbTop() {
|
|
if (!thumb.value)
|
|
return 0;
|
|
const el = instance.vnode.el;
|
|
if (!props2.vertical)
|
|
return 0;
|
|
const hue = props2.color.get("hue");
|
|
if (!el)
|
|
return 0;
|
|
return Math.round(hue * (el.offsetHeight - thumb.value.offsetHeight / 2) / 360);
|
|
}
|
|
function update2() {
|
|
thumbLeft.value = getThumbLeft();
|
|
thumbTop.value = getThumbTop();
|
|
}
|
|
onMounted(() => {
|
|
if (!bar.value || !thumb.value)
|
|
return;
|
|
const dragConfig = {
|
|
drag: (event) => {
|
|
handleDrag(event);
|
|
},
|
|
end: (event) => {
|
|
handleDrag(event);
|
|
}
|
|
};
|
|
draggable(bar.value, dragConfig);
|
|
draggable(thumb.value, dragConfig);
|
|
update2();
|
|
});
|
|
return {
|
|
bar,
|
|
thumb,
|
|
thumbLeft,
|
|
thumbTop,
|
|
hueValue,
|
|
handleClick,
|
|
update: update2,
|
|
ns
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render5(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([_ctx.ns.b(), _ctx.ns.is("vertical", _ctx.vertical)])
|
|
}, [
|
|
createBaseVNode("div", {
|
|
ref: "bar",
|
|
class: normalizeClass(_ctx.ns.e("bar")),
|
|
onClick: _ctx.handleClick
|
|
}, null, 10, ["onClick"]),
|
|
createBaseVNode("div", {
|
|
ref: "thumb",
|
|
class: normalizeClass(_ctx.ns.e("thumb")),
|
|
style: normalizeStyle({
|
|
left: _ctx.thumbLeft + "px",
|
|
top: _ctx.thumbTop + "px"
|
|
})
|
|
}, null, 6)
|
|
], 2);
|
|
}
|
|
var HueSlider = _export_sfc(_sfc_main47, [["render", _sfc_render5], ["__file", "hue-slider.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/color-picker/src/utils/color.mjs
|
|
var hsv2hsl = function(hue, sat, val) {
|
|
return [
|
|
hue,
|
|
sat * val / ((hue = (2 - sat) * val) < 1 ? hue : 2 - hue) || 0,
|
|
hue / 2
|
|
];
|
|
};
|
|
var isOnePointZero2 = function(n) {
|
|
return isString(n) && n.includes(".") && Number.parseFloat(n) === 1;
|
|
};
|
|
var isPercentage2 = function(n) {
|
|
return isString(n) && n.includes("%");
|
|
};
|
|
var bound012 = function(value, max4) {
|
|
if (isOnePointZero2(value))
|
|
value = "100%";
|
|
const processPercent = isPercentage2(value);
|
|
value = Math.min(max4, Math.max(0, Number.parseFloat(`${value}`)));
|
|
if (processPercent) {
|
|
value = Number.parseInt(`${value * max4}`, 10) / 100;
|
|
}
|
|
if (Math.abs(value - max4) < 1e-6) {
|
|
return 1;
|
|
}
|
|
return value % max4 / Number.parseFloat(max4);
|
|
};
|
|
var INT_HEX_MAP = {
|
|
10: "A",
|
|
11: "B",
|
|
12: "C",
|
|
13: "D",
|
|
14: "E",
|
|
15: "F"
|
|
};
|
|
var hexOne = (value) => {
|
|
value = Math.min(Math.round(value), 255);
|
|
const high = Math.floor(value / 16);
|
|
const low = value % 16;
|
|
return `${INT_HEX_MAP[high] || high}${INT_HEX_MAP[low] || low}`;
|
|
};
|
|
var toHex = function({ r, g, b: b2 }) {
|
|
if (Number.isNaN(+r) || Number.isNaN(+g) || Number.isNaN(+b2))
|
|
return "";
|
|
return `#${hexOne(r)}${hexOne(g)}${hexOne(b2)}`;
|
|
};
|
|
var HEX_INT_MAP = {
|
|
A: 10,
|
|
B: 11,
|
|
C: 12,
|
|
D: 13,
|
|
E: 14,
|
|
F: 15
|
|
};
|
|
var parseHexChannel = function(hex2) {
|
|
if (hex2.length === 2) {
|
|
return (HEX_INT_MAP[hex2[0].toUpperCase()] || +hex2[0]) * 16 + (HEX_INT_MAP[hex2[1].toUpperCase()] || +hex2[1]);
|
|
}
|
|
return HEX_INT_MAP[hex2[1].toUpperCase()] || +hex2[1];
|
|
};
|
|
var hsl2hsv = function(hue, sat, light) {
|
|
sat = sat / 100;
|
|
light = light / 100;
|
|
let smin = sat;
|
|
const lmin = Math.max(light, 0.01);
|
|
light *= 2;
|
|
sat *= light <= 1 ? light : 2 - light;
|
|
smin *= lmin <= 1 ? lmin : 2 - lmin;
|
|
const v2 = (light + sat) / 2;
|
|
const sv = light === 0 ? 2 * smin / (lmin + smin) : 2 * sat / (light + sat);
|
|
return {
|
|
h: hue,
|
|
s: sv * 100,
|
|
v: v2 * 100
|
|
};
|
|
};
|
|
var rgb2hsv = (r, g, b2) => {
|
|
r = bound012(r, 255);
|
|
g = bound012(g, 255);
|
|
b2 = bound012(b2, 255);
|
|
const max4 = Math.max(r, g, b2);
|
|
const min4 = Math.min(r, g, b2);
|
|
let h3;
|
|
const v2 = max4;
|
|
const d2 = max4 - min4;
|
|
const s2 = max4 === 0 ? 0 : d2 / max4;
|
|
if (max4 === min4) {
|
|
h3 = 0;
|
|
} else {
|
|
switch (max4) {
|
|
case r: {
|
|
h3 = (g - b2) / d2 + (g < b2 ? 6 : 0);
|
|
break;
|
|
}
|
|
case g: {
|
|
h3 = (b2 - r) / d2 + 2;
|
|
break;
|
|
}
|
|
case b2: {
|
|
h3 = (r - g) / d2 + 4;
|
|
break;
|
|
}
|
|
}
|
|
h3 /= 6;
|
|
}
|
|
return { h: h3 * 360, s: s2 * 100, v: v2 * 100 };
|
|
};
|
|
var hsv2rgb = function(h3, s2, v2) {
|
|
h3 = bound012(h3, 360) * 6;
|
|
s2 = bound012(s2, 100);
|
|
v2 = bound012(v2, 100);
|
|
const i = Math.floor(h3);
|
|
const f2 = h3 - i;
|
|
const p2 = v2 * (1 - s2);
|
|
const q2 = v2 * (1 - f2 * s2);
|
|
const t = v2 * (1 - (1 - f2) * s2);
|
|
const mod = i % 6;
|
|
const r = [v2, q2, p2, p2, t, v2][mod];
|
|
const g = [t, v2, v2, q2, p2, p2][mod];
|
|
const b2 = [p2, p2, t, v2, v2, q2][mod];
|
|
return {
|
|
r: Math.round(r * 255),
|
|
g: Math.round(g * 255),
|
|
b: Math.round(b2 * 255)
|
|
};
|
|
};
|
|
var Color = class {
|
|
constructor(options = {}) {
|
|
this._hue = 0;
|
|
this._saturation = 100;
|
|
this._value = 100;
|
|
this._alpha = 100;
|
|
this.enableAlpha = false;
|
|
this.format = "hex";
|
|
this.value = "";
|
|
for (const option in options) {
|
|
if (hasOwn(options, option)) {
|
|
this[option] = options[option];
|
|
}
|
|
}
|
|
if (options.value) {
|
|
this.fromString(options.value);
|
|
} else {
|
|
this.doOnChange();
|
|
}
|
|
}
|
|
set(prop, value) {
|
|
if (arguments.length === 1 && typeof prop === "object") {
|
|
for (const p2 in prop) {
|
|
if (hasOwn(prop, p2)) {
|
|
this.set(p2, prop[p2]);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
this[`_${prop}`] = value;
|
|
this.doOnChange();
|
|
}
|
|
get(prop) {
|
|
if (prop === "alpha") {
|
|
return Math.floor(this[`_${prop}`]);
|
|
}
|
|
return this[`_${prop}`];
|
|
}
|
|
toRgb() {
|
|
return hsv2rgb(this._hue, this._saturation, this._value);
|
|
}
|
|
fromString(value) {
|
|
if (!value) {
|
|
this._hue = 0;
|
|
this._saturation = 100;
|
|
this._value = 100;
|
|
this.doOnChange();
|
|
return;
|
|
}
|
|
const fromHSV = (h3, s2, v2) => {
|
|
this._hue = Math.max(0, Math.min(360, h3));
|
|
this._saturation = Math.max(0, Math.min(100, s2));
|
|
this._value = Math.max(0, Math.min(100, v2));
|
|
this.doOnChange();
|
|
};
|
|
if (value.includes("hsl")) {
|
|
const parts = value.replace(/hsla|hsl|\(|\)/gm, "").split(/\s|,/g).filter((val) => val !== "").map((val, index) => index > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10));
|
|
if (parts.length === 4) {
|
|
this._alpha = Number.parseFloat(parts[3]) * 100;
|
|
} else if (parts.length === 3) {
|
|
this._alpha = 100;
|
|
}
|
|
if (parts.length >= 3) {
|
|
const { h: h3, s: s2, v: v2 } = hsl2hsv(parts[0], parts[1], parts[2]);
|
|
fromHSV(h3, s2, v2);
|
|
}
|
|
} else if (value.includes("hsv")) {
|
|
const parts = value.replace(/hsva|hsv|\(|\)/gm, "").split(/\s|,/g).filter((val) => val !== "").map((val, index) => index > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10));
|
|
if (parts.length === 4) {
|
|
this._alpha = Number.parseFloat(parts[3]) * 100;
|
|
} else if (parts.length === 3) {
|
|
this._alpha = 100;
|
|
}
|
|
if (parts.length >= 3) {
|
|
fromHSV(parts[0], parts[1], parts[2]);
|
|
}
|
|
} else if (value.includes("rgb")) {
|
|
const parts = value.replace(/rgba|rgb|\(|\)/gm, "").split(/\s|,/g).filter((val) => val !== "").map((val, index) => index > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10));
|
|
if (parts.length === 4) {
|
|
this._alpha = Number.parseFloat(parts[3]) * 100;
|
|
} else if (parts.length === 3) {
|
|
this._alpha = 100;
|
|
}
|
|
if (parts.length >= 3) {
|
|
const { h: h3, s: s2, v: v2 } = rgb2hsv(parts[0], parts[1], parts[2]);
|
|
fromHSV(h3, s2, v2);
|
|
}
|
|
} else if (value.includes("#")) {
|
|
const hex2 = value.replace("#", "").trim();
|
|
if (!/^[0-9a-fA-F]{3}$|^[0-9a-fA-F]{6}$|^[0-9a-fA-F]{8}$/.test(hex2))
|
|
return;
|
|
let r, g, b2;
|
|
if (hex2.length === 3) {
|
|
r = parseHexChannel(hex2[0] + hex2[0]);
|
|
g = parseHexChannel(hex2[1] + hex2[1]);
|
|
b2 = parseHexChannel(hex2[2] + hex2[2]);
|
|
} else if (hex2.length === 6 || hex2.length === 8) {
|
|
r = parseHexChannel(hex2.slice(0, 2));
|
|
g = parseHexChannel(hex2.slice(2, 4));
|
|
b2 = parseHexChannel(hex2.slice(4, 6));
|
|
}
|
|
if (hex2.length === 8) {
|
|
this._alpha = parseHexChannel(hex2.slice(6)) / 255 * 100;
|
|
} else if (hex2.length === 3 || hex2.length === 6) {
|
|
this._alpha = 100;
|
|
}
|
|
const { h: h3, s: s2, v: v2 } = rgb2hsv(r, g, b2);
|
|
fromHSV(h3, s2, v2);
|
|
}
|
|
}
|
|
compare(color) {
|
|
return Math.abs(color._hue - this._hue) < 2 && Math.abs(color._saturation - this._saturation) < 1 && Math.abs(color._value - this._value) < 1 && Math.abs(color._alpha - this._alpha) < 1;
|
|
}
|
|
doOnChange() {
|
|
const { _hue, _saturation, _value, _alpha, format: format2 } = this;
|
|
if (this.enableAlpha) {
|
|
switch (format2) {
|
|
case "hsl": {
|
|
const hsl = hsv2hsl(_hue, _saturation / 100, _value / 100);
|
|
this.value = `hsla(${_hue}, ${Math.round(hsl[1] * 100)}%, ${Math.round(hsl[2] * 100)}%, ${this.get("alpha") / 100})`;
|
|
break;
|
|
}
|
|
case "hsv": {
|
|
this.value = `hsva(${_hue}, ${Math.round(_saturation)}%, ${Math.round(_value)}%, ${this.get("alpha") / 100})`;
|
|
break;
|
|
}
|
|
case "hex": {
|
|
this.value = `${toHex(hsv2rgb(_hue, _saturation, _value))}${hexOne(_alpha * 255 / 100)}`;
|
|
break;
|
|
}
|
|
default: {
|
|
const { r, g, b: b2 } = hsv2rgb(_hue, _saturation, _value);
|
|
this.value = `rgba(${r}, ${g}, ${b2}, ${this.get("alpha") / 100})`;
|
|
}
|
|
}
|
|
} else {
|
|
switch (format2) {
|
|
case "hsl": {
|
|
const hsl = hsv2hsl(_hue, _saturation / 100, _value / 100);
|
|
this.value = `hsl(${_hue}, ${Math.round(hsl[1] * 100)}%, ${Math.round(hsl[2] * 100)}%)`;
|
|
break;
|
|
}
|
|
case "hsv": {
|
|
this.value = `hsv(${_hue}, ${Math.round(_saturation)}%, ${Math.round(_value)}%)`;
|
|
break;
|
|
}
|
|
case "rgb": {
|
|
const { r, g, b: b2 } = hsv2rgb(_hue, _saturation, _value);
|
|
this.value = `rgb(${r}, ${g}, ${b2})`;
|
|
break;
|
|
}
|
|
default: {
|
|
this.value = toHex(hsv2rgb(_hue, _saturation, _value));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/color-picker/src/components/predefine.mjs
|
|
var _sfc_main48 = defineComponent({
|
|
props: {
|
|
colors: {
|
|
type: Array,
|
|
required: true
|
|
},
|
|
color: {
|
|
type: Object,
|
|
required: true
|
|
},
|
|
enableAlpha: {
|
|
type: Boolean,
|
|
required: true
|
|
}
|
|
},
|
|
setup(props2) {
|
|
const ns = useNamespace("color-predefine");
|
|
const { currentColor } = inject(colorPickerContextKey);
|
|
const rgbaColors = ref(parseColors(props2.colors, props2.color));
|
|
watch(() => currentColor.value, (val) => {
|
|
const color = new Color();
|
|
color.fromString(val);
|
|
rgbaColors.value.forEach((item) => {
|
|
item.selected = color.compare(item);
|
|
});
|
|
});
|
|
watchEffect(() => {
|
|
rgbaColors.value = parseColors(props2.colors, props2.color);
|
|
});
|
|
function handleSelect(index) {
|
|
props2.color.fromString(props2.colors[index]);
|
|
}
|
|
function parseColors(colors, color) {
|
|
return colors.map((value) => {
|
|
const c2 = new Color();
|
|
c2.enableAlpha = props2.enableAlpha;
|
|
c2.format = "rgba";
|
|
c2.fromString(value);
|
|
c2.selected = c2.value === color.value;
|
|
return c2;
|
|
});
|
|
}
|
|
return {
|
|
rgbaColors,
|
|
handleSelect,
|
|
ns
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render6(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(_ctx.ns.b())
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.ns.e("colors"))
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.rgbaColors, (item, index) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
key: _ctx.colors[index],
|
|
class: normalizeClass([
|
|
_ctx.ns.e("color-selector"),
|
|
_ctx.ns.is("alpha", item._alpha < 100),
|
|
{ selected: item.selected }
|
|
]),
|
|
onClick: ($event) => _ctx.handleSelect(index)
|
|
}, [
|
|
createBaseVNode("div", {
|
|
style: normalizeStyle({ backgroundColor: item.value })
|
|
}, null, 4)
|
|
], 10, ["onClick"]);
|
|
}), 128))
|
|
], 2)
|
|
], 2);
|
|
}
|
|
var Predefine = _export_sfc(_sfc_main48, [["render", _sfc_render6], ["__file", "predefine.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/color-picker/src/components/sv-panel.mjs
|
|
var _sfc_main49 = defineComponent({
|
|
name: "ElSlPanel",
|
|
props: {
|
|
color: {
|
|
type: Object,
|
|
required: true
|
|
}
|
|
},
|
|
setup(props2) {
|
|
const ns = useNamespace("color-svpanel");
|
|
const instance = getCurrentInstance();
|
|
const cursorTop = ref(0);
|
|
const cursorLeft = ref(0);
|
|
const background = ref("hsl(0, 100%, 50%)");
|
|
const colorValue = computed(() => {
|
|
const hue = props2.color.get("hue");
|
|
const value = props2.color.get("value");
|
|
return { hue, value };
|
|
});
|
|
function update2() {
|
|
const saturation = props2.color.get("saturation");
|
|
const value = props2.color.get("value");
|
|
const el = instance.vnode.el;
|
|
const { clientWidth: width, clientHeight: height } = el;
|
|
cursorLeft.value = saturation * width / 100;
|
|
cursorTop.value = (100 - value) * height / 100;
|
|
background.value = `hsl(${props2.color.get("hue")}, 100%, 50%)`;
|
|
}
|
|
function handleDrag(event) {
|
|
const el = instance.vnode.el;
|
|
const rect = el.getBoundingClientRect();
|
|
const { clientX, clientY } = getClientXY(event);
|
|
let left = clientX - rect.left;
|
|
let top = clientY - rect.top;
|
|
left = Math.max(0, left);
|
|
left = Math.min(left, rect.width);
|
|
top = Math.max(0, top);
|
|
top = Math.min(top, rect.height);
|
|
cursorLeft.value = left;
|
|
cursorTop.value = top;
|
|
props2.color.set({
|
|
saturation: left / rect.width * 100,
|
|
value: 100 - top / rect.height * 100
|
|
});
|
|
}
|
|
watch(() => colorValue.value, () => {
|
|
update2();
|
|
});
|
|
onMounted(() => {
|
|
draggable(instance.vnode.el, {
|
|
drag: (event) => {
|
|
handleDrag(event);
|
|
},
|
|
end: (event) => {
|
|
handleDrag(event);
|
|
}
|
|
});
|
|
update2();
|
|
});
|
|
return {
|
|
cursorTop,
|
|
cursorLeft,
|
|
background,
|
|
colorValue,
|
|
handleDrag,
|
|
update: update2,
|
|
ns
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render7(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(_ctx.ns.b()),
|
|
style: normalizeStyle({
|
|
backgroundColor: _ctx.background
|
|
})
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.ns.e("white"))
|
|
}, null, 2),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.ns.e("black"))
|
|
}, null, 2),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.ns.e("cursor")),
|
|
style: normalizeStyle({
|
|
top: _ctx.cursorTop + "px",
|
|
left: _ctx.cursorLeft + "px"
|
|
})
|
|
}, [
|
|
createBaseVNode("div")
|
|
], 6)
|
|
], 6);
|
|
}
|
|
var SvPanel = _export_sfc(_sfc_main49, [["render", _sfc_render7], ["__file", "sv-panel.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/color-picker/src/color-picker2.mjs
|
|
var __default__40 = defineComponent({
|
|
name: "ElColorPicker"
|
|
});
|
|
var _sfc_main50 = defineComponent({
|
|
...__default__40,
|
|
props: colorPickerProps,
|
|
emits: colorPickerEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("color");
|
|
const { formItem } = useFormItem();
|
|
const colorSize = useFormSize();
|
|
const colorDisabled = useFormDisabled();
|
|
const { inputId: buttonId, isLabeledByFormItem } = useFormItemInputId(props2, {
|
|
formItemContext: formItem
|
|
});
|
|
const hue = ref();
|
|
const sv = ref();
|
|
const alpha = ref();
|
|
const popper = ref();
|
|
const triggerRef = ref();
|
|
const inputRef = ref();
|
|
const { isFocused, handleFocus, handleBlur } = useFocusController(triggerRef, {
|
|
beforeFocus() {
|
|
return colorDisabled.value;
|
|
},
|
|
beforeBlur(event) {
|
|
var _a2;
|
|
return (_a2 = popper.value) == null ? void 0 : _a2.isFocusInsideContent(event);
|
|
},
|
|
afterBlur() {
|
|
setShowPicker(false);
|
|
resetColor();
|
|
}
|
|
});
|
|
let shouldActiveChange = true;
|
|
const color = reactive(new Color({
|
|
enableAlpha: props2.showAlpha,
|
|
format: props2.colorFormat || "",
|
|
value: props2.modelValue
|
|
}));
|
|
const showPicker = ref(false);
|
|
const showPanelColor = ref(false);
|
|
const customInput = ref("");
|
|
const displayedColor = computed(() => {
|
|
if (!props2.modelValue && !showPanelColor.value) {
|
|
return "transparent";
|
|
}
|
|
return displayedRgb(color, props2.showAlpha);
|
|
});
|
|
const currentColor = computed(() => {
|
|
return !props2.modelValue && !showPanelColor.value ? "" : color.value;
|
|
});
|
|
const buttonAriaLabel = computed(() => {
|
|
return !isLabeledByFormItem.value ? props2.ariaLabel || t("el.colorpicker.defaultLabel") : void 0;
|
|
});
|
|
const buttonAriaLabelledby = computed(() => {
|
|
return isLabeledByFormItem.value ? formItem == null ? void 0 : formItem.labelId : void 0;
|
|
});
|
|
const btnKls = computed(() => {
|
|
return [
|
|
ns.b("picker"),
|
|
ns.is("disabled", colorDisabled.value),
|
|
ns.bm("picker", colorSize.value),
|
|
ns.is("focused", isFocused.value)
|
|
];
|
|
});
|
|
function displayedRgb(color2, showAlpha) {
|
|
if (!(color2 instanceof Color)) {
|
|
throw new TypeError("color should be instance of _color Class");
|
|
}
|
|
const { r, g, b: b2 } = color2.toRgb();
|
|
return showAlpha ? `rgba(${r}, ${g}, ${b2}, ${color2.get("alpha") / 100})` : `rgb(${r}, ${g}, ${b2})`;
|
|
}
|
|
function setShowPicker(value) {
|
|
showPicker.value = value;
|
|
}
|
|
const debounceSetShowPicker = debounce_default(setShowPicker, 100, { leading: true });
|
|
function show() {
|
|
if (colorDisabled.value)
|
|
return;
|
|
setShowPicker(true);
|
|
}
|
|
function hide2() {
|
|
debounceSetShowPicker(false);
|
|
resetColor();
|
|
}
|
|
function resetColor() {
|
|
nextTick(() => {
|
|
if (props2.modelValue) {
|
|
color.fromString(props2.modelValue);
|
|
} else {
|
|
color.value = "";
|
|
nextTick(() => {
|
|
showPanelColor.value = false;
|
|
});
|
|
}
|
|
});
|
|
}
|
|
function handleTrigger() {
|
|
if (colorDisabled.value)
|
|
return;
|
|
if (showPicker.value) {
|
|
resetColor();
|
|
}
|
|
debounceSetShowPicker(!showPicker.value);
|
|
}
|
|
function handleConfirm() {
|
|
color.fromString(customInput.value);
|
|
}
|
|
function confirmValue() {
|
|
const value = color.value;
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emit(CHANGE_EVENT, value);
|
|
if (props2.validateEvent) {
|
|
formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
|
|
}
|
|
debounceSetShowPicker(false);
|
|
nextTick(() => {
|
|
const newColor = new Color({
|
|
enableAlpha: props2.showAlpha,
|
|
format: props2.colorFormat || "",
|
|
value: props2.modelValue
|
|
});
|
|
if (!color.compare(newColor)) {
|
|
resetColor();
|
|
}
|
|
});
|
|
}
|
|
function clear() {
|
|
debounceSetShowPicker(false);
|
|
emit(UPDATE_MODEL_EVENT, null);
|
|
emit(CHANGE_EVENT, null);
|
|
if (props2.modelValue !== null && props2.validateEvent) {
|
|
formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
|
|
}
|
|
resetColor();
|
|
}
|
|
function handleClickOutside() {
|
|
if (!showPicker.value)
|
|
return;
|
|
hide2();
|
|
isFocused.value && focus();
|
|
}
|
|
function handleEsc(event) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
setShowPicker(false);
|
|
resetColor();
|
|
}
|
|
function handleKeyDown(event) {
|
|
switch (event.code) {
|
|
case EVENT_CODE.enter:
|
|
case EVENT_CODE.numpadEnter:
|
|
case EVENT_CODE.space:
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
show();
|
|
inputRef.value.focus();
|
|
break;
|
|
case EVENT_CODE.esc:
|
|
handleEsc(event);
|
|
break;
|
|
}
|
|
}
|
|
function focus() {
|
|
triggerRef.value.focus();
|
|
}
|
|
function blur() {
|
|
triggerRef.value.blur();
|
|
}
|
|
onMounted(() => {
|
|
if (props2.modelValue) {
|
|
customInput.value = currentColor.value;
|
|
}
|
|
});
|
|
watch(() => props2.modelValue, (newVal) => {
|
|
if (!newVal) {
|
|
showPanelColor.value = false;
|
|
} else if (newVal && newVal !== color.value) {
|
|
shouldActiveChange = false;
|
|
color.fromString(newVal);
|
|
}
|
|
});
|
|
watch(() => [props2.colorFormat, props2.showAlpha], () => {
|
|
color.enableAlpha = props2.showAlpha;
|
|
color.format = props2.colorFormat || color.format;
|
|
color.doOnChange();
|
|
emit(UPDATE_MODEL_EVENT, color.value);
|
|
});
|
|
watch(() => currentColor.value, (val) => {
|
|
customInput.value = val;
|
|
shouldActiveChange && emit("activeChange", val);
|
|
shouldActiveChange = true;
|
|
});
|
|
watch(() => color.value, () => {
|
|
if (!props2.modelValue && !showPanelColor.value) {
|
|
showPanelColor.value = true;
|
|
}
|
|
});
|
|
watch(() => showPicker.value, () => {
|
|
nextTick(() => {
|
|
var _a2, _b, _c;
|
|
(_a2 = hue.value) == null ? void 0 : _a2.update();
|
|
(_b = sv.value) == null ? void 0 : _b.update();
|
|
(_c = alpha.value) == null ? void 0 : _c.update();
|
|
});
|
|
});
|
|
provide(colorPickerContextKey, {
|
|
currentColor
|
|
});
|
|
expose({
|
|
color,
|
|
show,
|
|
hide: hide2,
|
|
focus,
|
|
blur
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElTooltip), {
|
|
ref_key: "popper",
|
|
ref: popper,
|
|
visible: showPicker.value,
|
|
"show-arrow": false,
|
|
"fallback-placements": ["bottom", "top", "right", "left"],
|
|
offset: 0,
|
|
"gpu-acceleration": false,
|
|
"popper-class": [unref(ns).be("picker", "panel"), unref(ns).b("dropdown"), _ctx.popperClass],
|
|
"stop-popper-mouse-event": false,
|
|
effect: "light",
|
|
trigger: "click",
|
|
teleported: _ctx.teleported,
|
|
transition: `${unref(ns).namespace.value}-zoom-in-top`,
|
|
persistent: "",
|
|
onHide: ($event) => setShowPicker(false)
|
|
}, {
|
|
content: withCtx(() => [
|
|
withDirectives((openBlock(), createElementBlock("div", {
|
|
onKeydown: withKeys(handleEsc, ["esc"])
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).be("dropdown", "main-wrapper"))
|
|
}, [
|
|
createVNode(HueSlider, {
|
|
ref_key: "hue",
|
|
ref: hue,
|
|
class: "hue-slider",
|
|
color: unref(color),
|
|
vertical: ""
|
|
}, null, 8, ["color"]),
|
|
createVNode(SvPanel, {
|
|
ref_key: "sv",
|
|
ref: sv,
|
|
color: unref(color)
|
|
}, null, 8, ["color"])
|
|
], 2),
|
|
_ctx.showAlpha ? (openBlock(), createBlock(AlphaSlider, {
|
|
key: 0,
|
|
ref_key: "alpha",
|
|
ref: alpha,
|
|
color: unref(color)
|
|
}, null, 8, ["color"])) : createCommentVNode("v-if", true),
|
|
_ctx.predefine ? (openBlock(), createBlock(Predefine, {
|
|
key: 1,
|
|
ref: "predefine",
|
|
"enable-alpha": _ctx.showAlpha,
|
|
color: unref(color),
|
|
colors: _ctx.predefine
|
|
}, null, 8, ["enable-alpha", "color", "colors"])) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).be("dropdown", "btns"))
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(ns).be("dropdown", "value"))
|
|
}, [
|
|
createVNode(unref(ElInput), {
|
|
ref_key: "inputRef",
|
|
ref: inputRef,
|
|
modelValue: customInput.value,
|
|
"onUpdate:modelValue": ($event) => customInput.value = $event,
|
|
"validate-event": false,
|
|
size: "small",
|
|
onKeyup: withKeys(handleConfirm, ["enter"]),
|
|
onBlur: handleConfirm
|
|
}, null, 8, ["modelValue", "onUpdate:modelValue", "onKeyup"])
|
|
], 2),
|
|
createVNode(unref(ElButton), {
|
|
class: normalizeClass(unref(ns).be("dropdown", "link-btn")),
|
|
text: "",
|
|
size: "small",
|
|
onClick: clear
|
|
}, {
|
|
default: withCtx(() => [
|
|
createTextVNode(toDisplayString(unref(t)("el.colorpicker.clear")), 1)
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"]),
|
|
createVNode(unref(ElButton), {
|
|
plain: "",
|
|
size: "small",
|
|
class: normalizeClass(unref(ns).be("dropdown", "btn")),
|
|
onClick: confirmValue
|
|
}, {
|
|
default: withCtx(() => [
|
|
createTextVNode(toDisplayString(unref(t)("el.colorpicker.confirm")), 1)
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])
|
|
], 2)
|
|
], 40, ["onKeydown"])), [
|
|
[unref(ClickOutside), handleClickOutside, triggerRef.value]
|
|
])
|
|
]),
|
|
default: withCtx(() => [
|
|
createBaseVNode("div", mergeProps({
|
|
id: unref(buttonId),
|
|
ref_key: "triggerRef",
|
|
ref: triggerRef
|
|
}, _ctx.$attrs, {
|
|
class: unref(btnKls),
|
|
role: "button",
|
|
"aria-label": unref(buttonAriaLabel),
|
|
"aria-labelledby": unref(buttonAriaLabelledby),
|
|
"aria-description": unref(t)("el.colorpicker.description", { color: _ctx.modelValue || "" }),
|
|
"aria-disabled": unref(colorDisabled),
|
|
tabindex: unref(colorDisabled) ? void 0 : _ctx.tabindex,
|
|
onKeydown: handleKeyDown,
|
|
onFocus: unref(handleFocus),
|
|
onBlur: unref(handleBlur)
|
|
}), [
|
|
unref(colorDisabled) ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).be("picker", "mask"))
|
|
}, null, 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).be("picker", "trigger")),
|
|
onClick: handleTrigger
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass([unref(ns).be("picker", "color"), unref(ns).is("alpha", _ctx.showAlpha)])
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(ns).be("picker", "color-inner")),
|
|
style: normalizeStyle({
|
|
backgroundColor: unref(displayedColor)
|
|
})
|
|
}, [
|
|
withDirectives(createVNode(unref(ElIcon), {
|
|
class: normalizeClass([unref(ns).be("picker", "icon"), unref(ns).is("icon-arrow-down")])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(arrow_down_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"]), [
|
|
[vShow, _ctx.modelValue || showPanelColor.value]
|
|
]),
|
|
withDirectives(createVNode(unref(ElIcon), {
|
|
class: normalizeClass([unref(ns).be("picker", "empty"), unref(ns).is("icon-close")])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(close_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"]), [
|
|
[vShow, !_ctx.modelValue && !showPanelColor.value]
|
|
])
|
|
], 6)
|
|
], 2)
|
|
], 2)
|
|
], 16, ["id", "aria-label", "aria-labelledby", "aria-description", "aria-disabled", "tabindex", "onFocus", "onBlur"])
|
|
]),
|
|
_: 1
|
|
}, 8, ["visible", "popper-class", "teleported", "transition", "onHide"]);
|
|
};
|
|
}
|
|
});
|
|
var ColorPicker = _export_sfc(_sfc_main50, [["__file", "color-picker.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/color-picker/index.mjs
|
|
var ElColorPicker = withInstall(ColorPicker);
|
|
|
|
// node_modules/element-plus/es/components/config-provider/src/config-provider-props.mjs
|
|
var configProviderProps = buildProps({
|
|
a11y: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
locale: {
|
|
type: definePropType(Object)
|
|
},
|
|
size: useSizeProp,
|
|
button: {
|
|
type: definePropType(Object)
|
|
},
|
|
link: {
|
|
type: definePropType(Object)
|
|
},
|
|
experimentalFeatures: {
|
|
type: definePropType(Object)
|
|
},
|
|
keyboardNavigation: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
message: {
|
|
type: definePropType(Object)
|
|
},
|
|
zIndex: Number,
|
|
namespace: {
|
|
type: String,
|
|
default: "el"
|
|
},
|
|
...useEmptyValuesProps
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/config-provider/src/config-provider.mjs
|
|
var messageConfig = {};
|
|
var ConfigProvider = defineComponent({
|
|
name: "ElConfigProvider",
|
|
props: configProviderProps,
|
|
setup(props2, { slots }) {
|
|
watch(() => props2.message, (val) => {
|
|
Object.assign(messageConfig, val != null ? val : {});
|
|
}, { immediate: true, deep: true });
|
|
const config = provideGlobalConfig(props2);
|
|
return () => renderSlot(slots, "default", { config: config == null ? void 0 : config.value });
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/config-provider/index.mjs
|
|
var ElConfigProvider = withInstall(ConfigProvider);
|
|
|
|
// node_modules/element-plus/es/components/container/src/container.mjs
|
|
var __default__41 = defineComponent({
|
|
name: "ElContainer"
|
|
});
|
|
var _sfc_main51 = defineComponent({
|
|
...__default__41,
|
|
props: {
|
|
direction: {
|
|
type: String
|
|
}
|
|
},
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const slots = useSlots();
|
|
const ns = useNamespace("container");
|
|
const isVertical = computed(() => {
|
|
if (props2.direction === "vertical") {
|
|
return true;
|
|
} else if (props2.direction === "horizontal") {
|
|
return false;
|
|
}
|
|
if (slots && slots.default) {
|
|
const vNodes = slots.default();
|
|
return vNodes.some((vNode) => {
|
|
const tag = vNode.type.name;
|
|
return tag === "ElHeader" || tag === "ElFooter";
|
|
});
|
|
} else {
|
|
return false;
|
|
}
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("section", {
|
|
class: normalizeClass([unref(ns).b(), unref(ns).is("vertical", unref(isVertical))])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Container = _export_sfc(_sfc_main51, [["__file", "container.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/container/src/aside.mjs
|
|
var __default__42 = defineComponent({
|
|
name: "ElAside"
|
|
});
|
|
var _sfc_main52 = defineComponent({
|
|
...__default__42,
|
|
props: {
|
|
width: {
|
|
type: String,
|
|
default: null
|
|
}
|
|
},
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("aside");
|
|
const style = computed(() => props2.width ? ns.cssVarBlock({ width: props2.width }) : {});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("aside", {
|
|
class: normalizeClass(unref(ns).b()),
|
|
style: normalizeStyle(unref(style))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 6);
|
|
};
|
|
}
|
|
});
|
|
var Aside = _export_sfc(_sfc_main52, [["__file", "aside.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/container/src/footer.mjs
|
|
var __default__43 = defineComponent({
|
|
name: "ElFooter"
|
|
});
|
|
var _sfc_main53 = defineComponent({
|
|
...__default__43,
|
|
props: {
|
|
height: {
|
|
type: String,
|
|
default: null
|
|
}
|
|
},
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("footer");
|
|
const style = computed(() => props2.height ? ns.cssVarBlock({ height: props2.height }) : {});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("footer", {
|
|
class: normalizeClass(unref(ns).b()),
|
|
style: normalizeStyle(unref(style))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 6);
|
|
};
|
|
}
|
|
});
|
|
var Footer = _export_sfc(_sfc_main53, [["__file", "footer.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/container/src/header.mjs
|
|
var __default__44 = defineComponent({
|
|
name: "ElHeader"
|
|
});
|
|
var _sfc_main54 = defineComponent({
|
|
...__default__44,
|
|
props: {
|
|
height: {
|
|
type: String,
|
|
default: null
|
|
}
|
|
},
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("header");
|
|
const style = computed(() => {
|
|
return props2.height ? ns.cssVarBlock({
|
|
height: props2.height
|
|
}) : {};
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("header", {
|
|
class: normalizeClass(unref(ns).b()),
|
|
style: normalizeStyle(unref(style))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 6);
|
|
};
|
|
}
|
|
});
|
|
var Header = _export_sfc(_sfc_main54, [["__file", "header.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/container/src/main.mjs
|
|
var __default__45 = defineComponent({
|
|
name: "ElMain"
|
|
});
|
|
var _sfc_main55 = defineComponent({
|
|
...__default__45,
|
|
setup(__props) {
|
|
const ns = useNamespace("main");
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("main", {
|
|
class: normalizeClass(unref(ns).b())
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Main = _export_sfc(_sfc_main55, [["__file", "main.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/container/index.mjs
|
|
var ElContainer = withInstall(Container, {
|
|
Aside,
|
|
Footer,
|
|
Header,
|
|
Main
|
|
});
|
|
var ElAside = withNoopInstall(Aside);
|
|
var ElFooter = withNoopInstall(Footer);
|
|
var ElHeader = withNoopInstall(Header);
|
|
var ElMain = withNoopInstall(Main);
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/constants.mjs
|
|
var timeUnits = ["hours", "minutes", "seconds"];
|
|
var DEFAULT_FORMATS_TIME = "HH:mm:ss";
|
|
var DEFAULT_FORMATS_DATE = "YYYY-MM-DD";
|
|
var DEFAULT_FORMATS_DATEPICKER = {
|
|
date: DEFAULT_FORMATS_DATE,
|
|
dates: DEFAULT_FORMATS_DATE,
|
|
week: "gggg[w]ww",
|
|
year: "YYYY",
|
|
years: "YYYY",
|
|
month: "YYYY-MM",
|
|
months: "YYYY-MM",
|
|
datetime: `${DEFAULT_FORMATS_DATE} ${DEFAULT_FORMATS_TIME}`,
|
|
monthrange: "YYYY-MM",
|
|
yearrange: "YYYY",
|
|
daterange: DEFAULT_FORMATS_DATE,
|
|
datetimerange: `${DEFAULT_FORMATS_DATE} ${DEFAULT_FORMATS_TIME}`
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/props/shared.mjs
|
|
var disabledTimeListsProps = buildProps({
|
|
disabledHours: {
|
|
type: definePropType(Function)
|
|
},
|
|
disabledMinutes: {
|
|
type: definePropType(Function)
|
|
},
|
|
disabledSeconds: {
|
|
type: definePropType(Function)
|
|
}
|
|
});
|
|
var timePanelSharedProps = buildProps({
|
|
visible: Boolean,
|
|
actualVisible: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
format: {
|
|
type: String,
|
|
default: ""
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/common/props.mjs
|
|
var timePickerDefaultProps = buildProps({
|
|
id: {
|
|
type: definePropType([Array, String])
|
|
},
|
|
name: {
|
|
type: definePropType([Array, String])
|
|
},
|
|
popperClass: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
format: String,
|
|
valueFormat: String,
|
|
dateFormat: String,
|
|
timeFormat: String,
|
|
type: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
clearable: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
clearIcon: {
|
|
type: definePropType([String, Object]),
|
|
default: circle_close_default
|
|
},
|
|
editable: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
prefixIcon: {
|
|
type: definePropType([String, Object]),
|
|
default: ""
|
|
},
|
|
size: useSizeProp,
|
|
readonly: Boolean,
|
|
disabled: Boolean,
|
|
placeholder: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
popperOptions: {
|
|
type: definePropType(Object),
|
|
default: () => ({})
|
|
},
|
|
modelValue: {
|
|
type: definePropType([Date, Array, String, Number]),
|
|
default: ""
|
|
},
|
|
rangeSeparator: {
|
|
type: String,
|
|
default: "-"
|
|
},
|
|
startPlaceholder: String,
|
|
endPlaceholder: String,
|
|
defaultValue: {
|
|
type: definePropType([Date, Array])
|
|
},
|
|
defaultTime: {
|
|
type: definePropType([Date, Array])
|
|
},
|
|
isRange: Boolean,
|
|
...disabledTimeListsProps,
|
|
disabledDate: {
|
|
type: Function
|
|
},
|
|
cellClassName: {
|
|
type: Function
|
|
},
|
|
shortcuts: {
|
|
type: Array,
|
|
default: () => []
|
|
},
|
|
arrowControl: Boolean,
|
|
tabindex: {
|
|
type: definePropType([String, Number]),
|
|
default: 0
|
|
},
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
unlinkPanels: Boolean,
|
|
placement: {
|
|
type: definePropType(String),
|
|
values: Ee,
|
|
default: "bottom"
|
|
},
|
|
fallbackPlacements: {
|
|
type: definePropType(Array),
|
|
default: ["bottom", "top", "right", "left"]
|
|
},
|
|
...useEmptyValuesProps,
|
|
...useAriaProps(["ariaLabel"]),
|
|
showNow: {
|
|
type: Boolean,
|
|
default: true
|
|
}
|
|
});
|
|
var timePickerRangeTriggerProps = buildProps({
|
|
id: {
|
|
type: definePropType(Array)
|
|
},
|
|
name: {
|
|
type: definePropType(Array)
|
|
},
|
|
modelValue: {
|
|
type: definePropType([Array, String])
|
|
},
|
|
startPlaceholder: String,
|
|
endPlaceholder: String,
|
|
disabled: Boolean
|
|
});
|
|
var timePickerRngeTriggerProps = timePickerRangeTriggerProps;
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/common/picker-range-trigger.mjs
|
|
var __default__46 = defineComponent({
|
|
name: "PickerRangeTrigger",
|
|
inheritAttrs: false
|
|
});
|
|
var _sfc_main56 = defineComponent({
|
|
...__default__46,
|
|
props: timePickerRangeTriggerProps,
|
|
emits: [
|
|
"mouseenter",
|
|
"mouseleave",
|
|
"click",
|
|
"touchstart",
|
|
"focus",
|
|
"blur",
|
|
"startInput",
|
|
"endInput",
|
|
"startChange",
|
|
"endChange"
|
|
],
|
|
setup(__props, { expose, emit }) {
|
|
const attrs = useAttrs2();
|
|
const nsDate = useNamespace("date");
|
|
const nsRange = useNamespace("range");
|
|
const inputRef = ref();
|
|
const endInputRef = ref();
|
|
const { wrapperRef, isFocused } = useFocusController(inputRef);
|
|
const handleClick = (evt) => {
|
|
emit("click", evt);
|
|
};
|
|
const handleMouseEnter = (evt) => {
|
|
emit("mouseenter", evt);
|
|
};
|
|
const handleMouseLeave = (evt) => {
|
|
emit("mouseleave", evt);
|
|
};
|
|
const handleTouchStart = (evt) => {
|
|
emit("mouseenter", evt);
|
|
};
|
|
const handleStartInput = (evt) => {
|
|
emit("startInput", evt);
|
|
};
|
|
const handleEndInput = (evt) => {
|
|
emit("endInput", evt);
|
|
};
|
|
const handleStartChange = (evt) => {
|
|
emit("startChange", evt);
|
|
};
|
|
const handleEndChange = (evt) => {
|
|
emit("endChange", evt);
|
|
};
|
|
const focus = () => {
|
|
var _a2;
|
|
(_a2 = inputRef.value) == null ? void 0 : _a2.focus();
|
|
};
|
|
const blur = () => {
|
|
var _a2, _b;
|
|
(_a2 = inputRef.value) == null ? void 0 : _a2.blur();
|
|
(_b = endInputRef.value) == null ? void 0 : _b.blur();
|
|
};
|
|
expose({
|
|
focus,
|
|
blur
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "wrapperRef",
|
|
ref: wrapperRef,
|
|
class: normalizeClass([unref(nsDate).is("active", unref(isFocused)), _ctx.$attrs.class]),
|
|
style: normalizeStyle(_ctx.$attrs.style),
|
|
onClick: handleClick,
|
|
onMouseenter: handleMouseEnter,
|
|
onMouseleave: handleMouseLeave,
|
|
onTouchstartPassive: handleTouchStart
|
|
}, [
|
|
renderSlot(_ctx.$slots, "prefix"),
|
|
createBaseVNode("input", mergeProps(unref(attrs), {
|
|
id: _ctx.id && _ctx.id[0],
|
|
ref_key: "inputRef",
|
|
ref: inputRef,
|
|
name: _ctx.name && _ctx.name[0],
|
|
placeholder: _ctx.startPlaceholder,
|
|
value: _ctx.modelValue && _ctx.modelValue[0],
|
|
class: unref(nsRange).b("input"),
|
|
disabled: _ctx.disabled,
|
|
onInput: handleStartInput,
|
|
onChange: handleStartChange
|
|
}), null, 16, ["id", "name", "placeholder", "value", "disabled"]),
|
|
renderSlot(_ctx.$slots, "range-separator"),
|
|
createBaseVNode("input", mergeProps(unref(attrs), {
|
|
id: _ctx.id && _ctx.id[1],
|
|
ref_key: "endInputRef",
|
|
ref: endInputRef,
|
|
name: _ctx.name && _ctx.name[1],
|
|
placeholder: _ctx.endPlaceholder,
|
|
value: _ctx.modelValue && _ctx.modelValue[1],
|
|
class: unref(nsRange).b("input"),
|
|
disabled: _ctx.disabled,
|
|
onInput: handleEndInput,
|
|
onChange: handleEndChange
|
|
}), null, 16, ["id", "name", "placeholder", "value", "disabled"]),
|
|
renderSlot(_ctx.$slots, "suffix")
|
|
], 38);
|
|
};
|
|
}
|
|
});
|
|
var PickerRangeTrigger = _export_sfc(_sfc_main56, [["__file", "picker-range-trigger.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/common/picker.mjs
|
|
var __default__47 = defineComponent({
|
|
name: "Picker"
|
|
});
|
|
var _sfc_main57 = defineComponent({
|
|
...__default__47,
|
|
props: timePickerDefaultProps,
|
|
emits: [
|
|
UPDATE_MODEL_EVENT,
|
|
CHANGE_EVENT,
|
|
"focus",
|
|
"blur",
|
|
"clear",
|
|
"calendar-change",
|
|
"panel-change",
|
|
"visible-change",
|
|
"keydown"
|
|
],
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const attrs = useAttrs();
|
|
const { lang } = useLocale();
|
|
const nsDate = useNamespace("date");
|
|
const nsInput = useNamespace("input");
|
|
const nsRange = useNamespace("range");
|
|
const { form, formItem } = useFormItem();
|
|
const elPopperOptions = inject("ElPopperOptions", {});
|
|
const { valueOnClear } = useEmptyValues(props2, null);
|
|
const refPopper = ref();
|
|
const inputRef = ref();
|
|
const pickerVisible = ref(false);
|
|
const pickerActualVisible = ref(false);
|
|
const valueOnOpen = ref(null);
|
|
let hasJustTabExitedInput = false;
|
|
const { isFocused, handleFocus, handleBlur } = useFocusController(inputRef, {
|
|
beforeFocus() {
|
|
return props2.readonly || pickerDisabled.value;
|
|
},
|
|
afterFocus() {
|
|
pickerVisible.value = true;
|
|
},
|
|
beforeBlur(event) {
|
|
var _a2;
|
|
return !hasJustTabExitedInput && ((_a2 = refPopper.value) == null ? void 0 : _a2.isFocusInsideContent(event));
|
|
},
|
|
afterBlur() {
|
|
handleChange();
|
|
pickerVisible.value = false;
|
|
hasJustTabExitedInput = false;
|
|
props2.validateEvent && (formItem == null ? void 0 : formItem.validate("blur").catch((err) => debugWarn(err)));
|
|
}
|
|
});
|
|
const rangeInputKls = computed(() => [
|
|
nsDate.b("editor"),
|
|
nsDate.bm("editor", props2.type),
|
|
nsInput.e("wrapper"),
|
|
nsDate.is("disabled", pickerDisabled.value),
|
|
nsDate.is("active", pickerVisible.value),
|
|
nsRange.b("editor"),
|
|
pickerSize ? nsRange.bm("editor", pickerSize.value) : "",
|
|
attrs.class
|
|
]);
|
|
const clearIconKls = computed(() => [
|
|
nsInput.e("icon"),
|
|
nsRange.e("close-icon"),
|
|
!showClose.value ? nsRange.e("close-icon--hidden") : ""
|
|
]);
|
|
watch(pickerVisible, (val) => {
|
|
if (!val) {
|
|
userInput.value = null;
|
|
nextTick(() => {
|
|
emitChange(props2.modelValue);
|
|
});
|
|
} else {
|
|
nextTick(() => {
|
|
if (val) {
|
|
valueOnOpen.value = props2.modelValue;
|
|
}
|
|
});
|
|
}
|
|
});
|
|
const emitChange = (val, isClear) => {
|
|
if (isClear || !valueEquals(val, valueOnOpen.value)) {
|
|
emit(CHANGE_EVENT, val);
|
|
isClear && (valueOnOpen.value = val);
|
|
props2.validateEvent && (formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err)));
|
|
}
|
|
};
|
|
const emitInput = (input) => {
|
|
if (!valueEquals(props2.modelValue, input)) {
|
|
let formatted;
|
|
if (isArray(input)) {
|
|
formatted = input.map((item) => formatter(item, props2.valueFormat, lang.value));
|
|
} else if (input) {
|
|
formatted = formatter(input, props2.valueFormat, lang.value);
|
|
}
|
|
emit(UPDATE_MODEL_EVENT, input ? formatted : input, lang.value);
|
|
}
|
|
};
|
|
const emitKeydown = (e) => {
|
|
emit("keydown", e);
|
|
};
|
|
const refInput = computed(() => {
|
|
if (inputRef.value) {
|
|
return Array.from(inputRef.value.$el.querySelectorAll("input"));
|
|
}
|
|
return [];
|
|
});
|
|
const setSelectionRange = (start, end, pos) => {
|
|
const _inputs = refInput.value;
|
|
if (!_inputs.length)
|
|
return;
|
|
if (!pos || pos === "min") {
|
|
_inputs[0].setSelectionRange(start, end);
|
|
_inputs[0].focus();
|
|
} else if (pos === "max") {
|
|
_inputs[1].setSelectionRange(start, end);
|
|
_inputs[1].focus();
|
|
}
|
|
};
|
|
const onPick = (date4 = "", visible = false) => {
|
|
pickerVisible.value = visible;
|
|
let result2;
|
|
if (isArray(date4)) {
|
|
result2 = date4.map((_2) => _2.toDate());
|
|
} else {
|
|
result2 = date4 ? date4.toDate() : date4;
|
|
}
|
|
userInput.value = null;
|
|
emitInput(result2);
|
|
};
|
|
const onBeforeShow = () => {
|
|
pickerActualVisible.value = true;
|
|
};
|
|
const onShow = () => {
|
|
emit("visible-change", true);
|
|
};
|
|
const onHide = () => {
|
|
pickerActualVisible.value = false;
|
|
pickerVisible.value = false;
|
|
emit("visible-change", false);
|
|
};
|
|
const handleOpen = () => {
|
|
pickerVisible.value = true;
|
|
};
|
|
const handleClose = () => {
|
|
pickerVisible.value = false;
|
|
};
|
|
const pickerDisabled = computed(() => {
|
|
return props2.disabled || (form == null ? void 0 : form.disabled);
|
|
});
|
|
const parsedValue = computed(() => {
|
|
let dayOrDays;
|
|
if (valueIsEmpty.value) {
|
|
if (pickerOptions.value.getDefaultValue) {
|
|
dayOrDays = pickerOptions.value.getDefaultValue();
|
|
}
|
|
} else {
|
|
if (isArray(props2.modelValue)) {
|
|
dayOrDays = props2.modelValue.map((d2) => parseDate(d2, props2.valueFormat, lang.value));
|
|
} else {
|
|
dayOrDays = parseDate(props2.modelValue, props2.valueFormat, lang.value);
|
|
}
|
|
}
|
|
if (pickerOptions.value.getRangeAvailableTime) {
|
|
const availableResult = pickerOptions.value.getRangeAvailableTime(dayOrDays);
|
|
if (!isEqual_default(availableResult, dayOrDays)) {
|
|
dayOrDays = availableResult;
|
|
if (!valueIsEmpty.value) {
|
|
emitInput(dayOrDaysToDate(dayOrDays));
|
|
}
|
|
}
|
|
}
|
|
if (isArray(dayOrDays) && dayOrDays.some((day) => !day)) {
|
|
dayOrDays = [];
|
|
}
|
|
return dayOrDays;
|
|
});
|
|
const displayValue = computed(() => {
|
|
if (!pickerOptions.value.panelReady)
|
|
return "";
|
|
const formattedValue = formatDayjsToString(parsedValue.value);
|
|
if (isArray(userInput.value)) {
|
|
return [
|
|
userInput.value[0] || formattedValue && formattedValue[0] || "",
|
|
userInput.value[1] || formattedValue && formattedValue[1] || ""
|
|
];
|
|
} else if (userInput.value !== null) {
|
|
return userInput.value;
|
|
}
|
|
if (!isTimePicker.value && valueIsEmpty.value)
|
|
return "";
|
|
if (!pickerVisible.value && valueIsEmpty.value)
|
|
return "";
|
|
if (formattedValue) {
|
|
return isDatesPicker.value || isMonthsPicker.value || isYearsPicker.value ? formattedValue.join(", ") : formattedValue;
|
|
}
|
|
return "";
|
|
});
|
|
const isTimeLikePicker = computed(() => props2.type.includes("time"));
|
|
const isTimePicker = computed(() => props2.type.startsWith("time"));
|
|
const isDatesPicker = computed(() => props2.type === "dates");
|
|
const isMonthsPicker = computed(() => props2.type === "months");
|
|
const isYearsPicker = computed(() => props2.type === "years");
|
|
const triggerIcon = computed(() => props2.prefixIcon || (isTimeLikePicker.value ? clock_default : calendar_default));
|
|
const showClose = ref(false);
|
|
const onClearIconClick = (event) => {
|
|
if (props2.readonly || pickerDisabled.value)
|
|
return;
|
|
if (showClose.value) {
|
|
event.stopPropagation();
|
|
if (pickerOptions.value.handleClear) {
|
|
pickerOptions.value.handleClear();
|
|
} else {
|
|
emitInput(valueOnClear.value);
|
|
}
|
|
emitChange(valueOnClear.value, true);
|
|
showClose.value = false;
|
|
onHide();
|
|
}
|
|
emit("clear");
|
|
};
|
|
const valueIsEmpty = computed(() => {
|
|
const { modelValue } = props2;
|
|
return !modelValue || isArray(modelValue) && !modelValue.filter(Boolean).length;
|
|
});
|
|
const onMouseDownInput = async (event) => {
|
|
var _a2;
|
|
if (props2.readonly || pickerDisabled.value)
|
|
return;
|
|
if (((_a2 = event.target) == null ? void 0 : _a2.tagName) !== "INPUT" || isFocused.value) {
|
|
pickerVisible.value = true;
|
|
}
|
|
};
|
|
const onMouseEnter = () => {
|
|
if (props2.readonly || pickerDisabled.value)
|
|
return;
|
|
if (!valueIsEmpty.value && props2.clearable) {
|
|
showClose.value = true;
|
|
}
|
|
};
|
|
const onMouseLeave = () => {
|
|
showClose.value = false;
|
|
};
|
|
const onTouchStartInput = (event) => {
|
|
var _a2;
|
|
if (props2.readonly || pickerDisabled.value)
|
|
return;
|
|
if (((_a2 = event.touches[0].target) == null ? void 0 : _a2.tagName) !== "INPUT" || isFocused.value) {
|
|
pickerVisible.value = true;
|
|
}
|
|
};
|
|
const isRangeInput = computed(() => {
|
|
return props2.type.includes("range");
|
|
});
|
|
const pickerSize = useFormSize();
|
|
const popperEl = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = unref(refPopper)) == null ? void 0 : _a2.popperRef) == null ? void 0 : _b.contentRef;
|
|
});
|
|
const stophandle = onClickOutside(inputRef, (e) => {
|
|
const unrefedPopperEl = unref(popperEl);
|
|
const inputEl = unrefElement(inputRef);
|
|
if (unrefedPopperEl && (e.target === unrefedPopperEl || e.composedPath().includes(unrefedPopperEl)) || e.target === inputEl || inputEl && e.composedPath().includes(inputEl))
|
|
return;
|
|
pickerVisible.value = false;
|
|
});
|
|
onBeforeUnmount(() => {
|
|
stophandle == null ? void 0 : stophandle();
|
|
});
|
|
const userInput = ref(null);
|
|
const handleChange = () => {
|
|
if (userInput.value) {
|
|
const value = parseUserInputToDayjs(displayValue.value);
|
|
if (value) {
|
|
if (isValidValue3(value)) {
|
|
emitInput(dayOrDaysToDate(value));
|
|
userInput.value = null;
|
|
}
|
|
}
|
|
}
|
|
if (userInput.value === "") {
|
|
emitInput(valueOnClear.value);
|
|
emitChange(valueOnClear.value, true);
|
|
userInput.value = null;
|
|
}
|
|
};
|
|
const parseUserInputToDayjs = (value) => {
|
|
if (!value)
|
|
return null;
|
|
return pickerOptions.value.parseUserInput(value);
|
|
};
|
|
const formatDayjsToString = (value) => {
|
|
if (!value)
|
|
return null;
|
|
return pickerOptions.value.formatToString(value);
|
|
};
|
|
const isValidValue3 = (value) => {
|
|
return pickerOptions.value.isValidValue(value);
|
|
};
|
|
const handleKeydownInput = async (event) => {
|
|
if (props2.readonly || pickerDisabled.value)
|
|
return;
|
|
const { code } = event;
|
|
emitKeydown(event);
|
|
if (code === EVENT_CODE.esc) {
|
|
if (pickerVisible.value === true) {
|
|
pickerVisible.value = false;
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
}
|
|
return;
|
|
}
|
|
if (code === EVENT_CODE.down) {
|
|
if (pickerOptions.value.handleFocusPicker) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
}
|
|
if (pickerVisible.value === false) {
|
|
pickerVisible.value = true;
|
|
await nextTick();
|
|
}
|
|
if (pickerOptions.value.handleFocusPicker) {
|
|
pickerOptions.value.handleFocusPicker();
|
|
return;
|
|
}
|
|
}
|
|
if (code === EVENT_CODE.tab) {
|
|
hasJustTabExitedInput = true;
|
|
return;
|
|
}
|
|
if (code === EVENT_CODE.enter || code === EVENT_CODE.numpadEnter) {
|
|
if (userInput.value === null || userInput.value === "" || isValidValue3(parseUserInputToDayjs(displayValue.value))) {
|
|
handleChange();
|
|
pickerVisible.value = false;
|
|
}
|
|
event.stopPropagation();
|
|
return;
|
|
}
|
|
if (userInput.value) {
|
|
event.stopPropagation();
|
|
return;
|
|
}
|
|
if (pickerOptions.value.handleKeydownInput) {
|
|
pickerOptions.value.handleKeydownInput(event);
|
|
}
|
|
};
|
|
const onUserInput = (e) => {
|
|
userInput.value = e;
|
|
if (!pickerVisible.value) {
|
|
pickerVisible.value = true;
|
|
}
|
|
};
|
|
const handleStartInput = (event) => {
|
|
const target2 = event.target;
|
|
if (userInput.value) {
|
|
userInput.value = [target2.value, userInput.value[1]];
|
|
} else {
|
|
userInput.value = [target2.value, null];
|
|
}
|
|
};
|
|
const handleEndInput = (event) => {
|
|
const target2 = event.target;
|
|
if (userInput.value) {
|
|
userInput.value = [userInput.value[0], target2.value];
|
|
} else {
|
|
userInput.value = [null, target2.value];
|
|
}
|
|
};
|
|
const handleStartChange = () => {
|
|
var _a2;
|
|
const values2 = userInput.value;
|
|
const value = parseUserInputToDayjs(values2 && values2[0]);
|
|
const parsedVal = unref(parsedValue);
|
|
if (value && value.isValid()) {
|
|
userInput.value = [
|
|
formatDayjsToString(value),
|
|
((_a2 = displayValue.value) == null ? void 0 : _a2[1]) || null
|
|
];
|
|
const newValue = [value, parsedVal && (parsedVal[1] || null)];
|
|
if (isValidValue3(newValue)) {
|
|
emitInput(dayOrDaysToDate(newValue));
|
|
userInput.value = null;
|
|
}
|
|
}
|
|
};
|
|
const handleEndChange = () => {
|
|
var _a2;
|
|
const values2 = unref(userInput);
|
|
const value = parseUserInputToDayjs(values2 && values2[1]);
|
|
const parsedVal = unref(parsedValue);
|
|
if (value && value.isValid()) {
|
|
userInput.value = [
|
|
((_a2 = unref(displayValue)) == null ? void 0 : _a2[0]) || null,
|
|
formatDayjsToString(value)
|
|
];
|
|
const newValue = [parsedVal && parsedVal[0], value];
|
|
if (isValidValue3(newValue)) {
|
|
emitInput(dayOrDaysToDate(newValue));
|
|
userInput.value = null;
|
|
}
|
|
}
|
|
};
|
|
const pickerOptions = ref({});
|
|
const onSetPickerOption = (e) => {
|
|
pickerOptions.value[e[0]] = e[1];
|
|
pickerOptions.value.panelReady = true;
|
|
};
|
|
const onCalendarChange = (e) => {
|
|
emit("calendar-change", e);
|
|
};
|
|
const onPanelChange = (value, mode, view) => {
|
|
emit("panel-change", value, mode, view);
|
|
};
|
|
const focus = () => {
|
|
var _a2;
|
|
(_a2 = inputRef.value) == null ? void 0 : _a2.focus();
|
|
};
|
|
const blur = () => {
|
|
var _a2;
|
|
(_a2 = inputRef.value) == null ? void 0 : _a2.blur();
|
|
};
|
|
provide("EP_PICKER_BASE", {
|
|
props: props2
|
|
});
|
|
expose({
|
|
focus,
|
|
blur,
|
|
handleOpen,
|
|
handleClose,
|
|
onPick
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElTooltip), mergeProps({
|
|
ref_key: "refPopper",
|
|
ref: refPopper,
|
|
visible: pickerVisible.value,
|
|
effect: "light",
|
|
pure: "",
|
|
trigger: "click"
|
|
}, _ctx.$attrs, {
|
|
role: "dialog",
|
|
teleported: "",
|
|
transition: `${unref(nsDate).namespace.value}-zoom-in-top`,
|
|
"popper-class": [`${unref(nsDate).namespace.value}-picker__popper`, _ctx.popperClass],
|
|
"popper-options": unref(elPopperOptions),
|
|
"fallback-placements": _ctx.fallbackPlacements,
|
|
"gpu-acceleration": false,
|
|
placement: _ctx.placement,
|
|
"stop-popper-mouse-event": false,
|
|
"hide-after": 0,
|
|
persistent: "",
|
|
onBeforeShow,
|
|
onShow,
|
|
onHide
|
|
}), {
|
|
default: withCtx(() => [
|
|
!unref(isRangeInput) ? (openBlock(), createBlock(unref(ElInput), {
|
|
key: 0,
|
|
id: _ctx.id,
|
|
ref_key: "inputRef",
|
|
ref: inputRef,
|
|
"container-role": "combobox",
|
|
"model-value": unref(displayValue),
|
|
name: _ctx.name,
|
|
size: unref(pickerSize),
|
|
disabled: unref(pickerDisabled),
|
|
placeholder: _ctx.placeholder,
|
|
class: normalizeClass([unref(nsDate).b("editor"), unref(nsDate).bm("editor", _ctx.type), _ctx.$attrs.class]),
|
|
style: normalizeStyle(_ctx.$attrs.style),
|
|
readonly: !_ctx.editable || _ctx.readonly || unref(isDatesPicker) || unref(isMonthsPicker) || unref(isYearsPicker) || _ctx.type === "week",
|
|
"aria-label": _ctx.ariaLabel,
|
|
tabindex: _ctx.tabindex,
|
|
"validate-event": false,
|
|
onInput: onUserInput,
|
|
onFocus: unref(handleFocus),
|
|
onBlur: unref(handleBlur),
|
|
onKeydown: handleKeydownInput,
|
|
onChange: handleChange,
|
|
onMousedown: onMouseDownInput,
|
|
onMouseenter: onMouseEnter,
|
|
onMouseleave: onMouseLeave,
|
|
onTouchstartPassive: onTouchStartInput,
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, {
|
|
prefix: withCtx(() => [
|
|
unref(triggerIcon) ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(nsInput).e("icon")),
|
|
onMousedown: withModifiers(onMouseDownInput, ["prevent"]),
|
|
onTouchstartPassive: onTouchStartInput
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(unref(triggerIcon))))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "onMousedown"])) : createCommentVNode("v-if", true)
|
|
]),
|
|
suffix: withCtx(() => [
|
|
showClose.value && _ctx.clearIcon ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(`${unref(nsInput).e("icon")} clear-icon`),
|
|
onMousedown: withModifiers(unref(NOOP), ["prevent"]),
|
|
onClick: onClearIconClick
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.clearIcon)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "onMousedown"])) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 1
|
|
}, 8, ["id", "model-value", "name", "size", "disabled", "placeholder", "class", "style", "readonly", "aria-label", "tabindex", "onFocus", "onBlur", "onClick"])) : (openBlock(), createBlock(PickerRangeTrigger, {
|
|
key: 1,
|
|
id: _ctx.id,
|
|
ref_key: "inputRef",
|
|
ref: inputRef,
|
|
"model-value": unref(displayValue),
|
|
name: _ctx.name,
|
|
disabled: unref(pickerDisabled),
|
|
readonly: !_ctx.editable || _ctx.readonly,
|
|
"start-placeholder": _ctx.startPlaceholder,
|
|
"end-placeholder": _ctx.endPlaceholder,
|
|
class: normalizeClass(unref(rangeInputKls)),
|
|
style: normalizeStyle(_ctx.$attrs.style),
|
|
"aria-label": _ctx.ariaLabel,
|
|
tabindex: _ctx.tabindex,
|
|
autocomplete: "off",
|
|
role: "combobox",
|
|
onClick: onMouseDownInput,
|
|
onFocus: unref(handleFocus),
|
|
onBlur: unref(handleBlur),
|
|
onStartInput: handleStartInput,
|
|
onStartChange: handleStartChange,
|
|
onEndInput: handleEndInput,
|
|
onEndChange: handleEndChange,
|
|
onMousedown: onMouseDownInput,
|
|
onMouseenter: onMouseEnter,
|
|
onMouseleave: onMouseLeave,
|
|
onTouchstartPassive: onTouchStartInput,
|
|
onKeydown: handleKeydownInput
|
|
}, {
|
|
prefix: withCtx(() => [
|
|
unref(triggerIcon) ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass([unref(nsInput).e("icon"), unref(nsRange).e("icon")])
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(unref(triggerIcon))))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true)
|
|
]),
|
|
"range-separator": withCtx(() => [
|
|
renderSlot(_ctx.$slots, "range-separator", {}, () => [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(nsRange).b("separator"))
|
|
}, toDisplayString(_ctx.rangeSeparator), 3)
|
|
])
|
|
]),
|
|
suffix: withCtx(() => [
|
|
_ctx.clearIcon ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(clearIconKls)),
|
|
onMousedown: withModifiers(unref(NOOP), ["prevent"]),
|
|
onClick: onClearIconClick
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.clearIcon)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "onMousedown"])) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 8, ["id", "model-value", "name", "disabled", "readonly", "start-placeholder", "end-placeholder", "class", "style", "aria-label", "tabindex", "onFocus", "onBlur"]))
|
|
]),
|
|
content: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default", {
|
|
visible: pickerVisible.value,
|
|
actualVisible: pickerActualVisible.value,
|
|
parsedValue: unref(parsedValue),
|
|
format: _ctx.format,
|
|
dateFormat: _ctx.dateFormat,
|
|
timeFormat: _ctx.timeFormat,
|
|
unlinkPanels: _ctx.unlinkPanels,
|
|
type: _ctx.type,
|
|
defaultValue: _ctx.defaultValue,
|
|
showNow: _ctx.showNow,
|
|
onPick,
|
|
onSelectRange: setSelectionRange,
|
|
onSetPickerOption,
|
|
onCalendarChange,
|
|
onPanelChange,
|
|
onMousedown: withModifiers(() => {
|
|
}, ["stop"])
|
|
})
|
|
]),
|
|
_: 3
|
|
}, 16, ["visible", "transition", "popper-class", "popper-options", "fallback-placements", "placement"]);
|
|
};
|
|
}
|
|
});
|
|
var CommonPicker = _export_sfc(_sfc_main57, [["__file", "picker.vue"]]);
|
|
|
|
// node_modules/element-plus/es/directives/repeat-click/index.mjs
|
|
var REPEAT_INTERVAL = 100;
|
|
var REPEAT_DELAY = 600;
|
|
var vRepeatClick = {
|
|
beforeMount(el, binding) {
|
|
const value = binding.value;
|
|
const { interval = REPEAT_INTERVAL, delay: delay2 = REPEAT_DELAY } = isFunction(value) ? {} : value;
|
|
let intervalId;
|
|
let delayId;
|
|
const handler = () => isFunction(value) ? value() : value.handler();
|
|
const clear = () => {
|
|
if (delayId) {
|
|
clearTimeout(delayId);
|
|
delayId = void 0;
|
|
}
|
|
if (intervalId) {
|
|
clearInterval(intervalId);
|
|
intervalId = void 0;
|
|
}
|
|
};
|
|
el.addEventListener("mousedown", (evt) => {
|
|
if (evt.button !== 0)
|
|
return;
|
|
clear();
|
|
handler();
|
|
document.addEventListener("mouseup", () => clear(), {
|
|
once: true
|
|
});
|
|
delayId = setTimeout(() => {
|
|
intervalId = setInterval(() => {
|
|
handler();
|
|
}, interval);
|
|
}, delay2);
|
|
});
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/time-picker-com/panel-time-pick.mjs
|
|
var import_dayjs4 = __toModule(require_dayjs_min());
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/props/panel-time-picker.mjs
|
|
var panelTimePickerProps = buildProps({
|
|
...timePanelSharedProps,
|
|
datetimeRole: String,
|
|
parsedValue: {
|
|
type: definePropType(Object)
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/composables/use-time-panel.mjs
|
|
var useTimePanel = ({
|
|
getAvailableHours,
|
|
getAvailableMinutes,
|
|
getAvailableSeconds
|
|
}) => {
|
|
const getAvailableTime = (date4, role, first, compareDate) => {
|
|
const availableTimeGetters = {
|
|
hour: getAvailableHours,
|
|
minute: getAvailableMinutes,
|
|
second: getAvailableSeconds
|
|
};
|
|
let result2 = date4;
|
|
["hour", "minute", "second"].forEach((type4) => {
|
|
if (availableTimeGetters[type4]) {
|
|
let availableTimeSlots;
|
|
const method5 = availableTimeGetters[type4];
|
|
switch (type4) {
|
|
case "minute": {
|
|
availableTimeSlots = method5(result2.hour(), role, compareDate);
|
|
break;
|
|
}
|
|
case "second": {
|
|
availableTimeSlots = method5(result2.hour(), result2.minute(), role, compareDate);
|
|
break;
|
|
}
|
|
default: {
|
|
availableTimeSlots = method5(role, compareDate);
|
|
break;
|
|
}
|
|
}
|
|
if ((availableTimeSlots == null ? void 0 : availableTimeSlots.length) && !availableTimeSlots.includes(result2[type4]())) {
|
|
const pos = first ? 0 : availableTimeSlots.length - 1;
|
|
result2 = result2[type4](availableTimeSlots[pos]);
|
|
}
|
|
}
|
|
});
|
|
return result2;
|
|
};
|
|
const timePickerOptions = {};
|
|
const onSetOption = ([key, val]) => {
|
|
timePickerOptions[key] = val;
|
|
};
|
|
return {
|
|
timePickerOptions,
|
|
getAvailableTime,
|
|
onSetOption
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/composables/use-time-picker.mjs
|
|
var makeAvailableArr = (disabledList) => {
|
|
const trueOrNumber = (isDisabled, index) => isDisabled || index;
|
|
const getNumber = (predicate) => predicate !== true;
|
|
return disabledList.map(trueOrNumber).filter(getNumber);
|
|
};
|
|
var getTimeLists = (disabledHours, disabledMinutes, disabledSeconds) => {
|
|
const getHoursList = (role, compare) => {
|
|
return makeList(24, disabledHours && (() => disabledHours == null ? void 0 : disabledHours(role, compare)));
|
|
};
|
|
const getMinutesList = (hour, role, compare) => {
|
|
return makeList(60, disabledMinutes && (() => disabledMinutes == null ? void 0 : disabledMinutes(hour, role, compare)));
|
|
};
|
|
const getSecondsList = (hour, minute, role, compare) => {
|
|
return makeList(60, disabledSeconds && (() => disabledSeconds == null ? void 0 : disabledSeconds(hour, minute, role, compare)));
|
|
};
|
|
return {
|
|
getHoursList,
|
|
getMinutesList,
|
|
getSecondsList
|
|
};
|
|
};
|
|
var buildAvailableTimeSlotGetter = (disabledHours, disabledMinutes, disabledSeconds) => {
|
|
const { getHoursList, getMinutesList, getSecondsList } = getTimeLists(disabledHours, disabledMinutes, disabledSeconds);
|
|
const getAvailableHours = (role, compare) => {
|
|
return makeAvailableArr(getHoursList(role, compare));
|
|
};
|
|
const getAvailableMinutes = (hour, role, compare) => {
|
|
return makeAvailableArr(getMinutesList(hour, role, compare));
|
|
};
|
|
const getAvailableSeconds = (hour, minute, role, compare) => {
|
|
return makeAvailableArr(getSecondsList(hour, minute, role, compare));
|
|
};
|
|
return {
|
|
getAvailableHours,
|
|
getAvailableMinutes,
|
|
getAvailableSeconds
|
|
};
|
|
};
|
|
var useOldValue = (props2) => {
|
|
const oldValue = ref(props2.parsedValue);
|
|
watch(() => props2.visible, (val) => {
|
|
if (!val) {
|
|
oldValue.value = props2.parsedValue;
|
|
}
|
|
});
|
|
return oldValue;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/props/basic-time-spinner.mjs
|
|
var basicTimeSpinnerProps = buildProps({
|
|
role: {
|
|
type: String,
|
|
required: true
|
|
},
|
|
spinnerDate: {
|
|
type: definePropType(Object),
|
|
required: true
|
|
},
|
|
showSeconds: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
arrowControl: Boolean,
|
|
amPmMode: {
|
|
type: definePropType(String),
|
|
default: ""
|
|
},
|
|
...disabledTimeListsProps
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/time-picker-com/basic-time-spinner.mjs
|
|
var _sfc_main58 = defineComponent({
|
|
__name: "basic-time-spinner",
|
|
props: basicTimeSpinnerProps,
|
|
emits: [CHANGE_EVENT, "select-range", "set-option"],
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const pickerBase = inject("EP_PICKER_BASE");
|
|
const { isRange, format: format2 } = pickerBase.props;
|
|
const ns = useNamespace("time");
|
|
const { getHoursList, getMinutesList, getSecondsList } = getTimeLists(props2.disabledHours, props2.disabledMinutes, props2.disabledSeconds);
|
|
let isScrolling = false;
|
|
const currentScrollbar = ref();
|
|
const listHoursRef = ref();
|
|
const listMinutesRef = ref();
|
|
const listSecondsRef = ref();
|
|
const listRefsMap = {
|
|
hours: listHoursRef,
|
|
minutes: listMinutesRef,
|
|
seconds: listSecondsRef
|
|
};
|
|
const spinnerItems = computed(() => {
|
|
return props2.showSeconds ? timeUnits : timeUnits.slice(0, 2);
|
|
});
|
|
const timePartials = computed(() => {
|
|
const { spinnerDate } = props2;
|
|
const hours = spinnerDate.hour();
|
|
const minutes = spinnerDate.minute();
|
|
const seconds = spinnerDate.second();
|
|
return { hours, minutes, seconds };
|
|
});
|
|
const timeList = computed(() => {
|
|
const { hours, minutes } = unref(timePartials);
|
|
const { role, spinnerDate } = props2;
|
|
const compare = !isRange ? spinnerDate : void 0;
|
|
return {
|
|
hours: getHoursList(role, compare),
|
|
minutes: getMinutesList(hours, role, compare),
|
|
seconds: getSecondsList(hours, minutes, role, compare)
|
|
};
|
|
});
|
|
const arrowControlTimeList = computed(() => {
|
|
const { hours, minutes, seconds } = unref(timePartials);
|
|
return {
|
|
hours: buildTimeList(hours, 23),
|
|
minutes: buildTimeList(minutes, 59),
|
|
seconds: buildTimeList(seconds, 59)
|
|
};
|
|
});
|
|
const debouncedResetScroll = debounce_default((type4) => {
|
|
isScrolling = false;
|
|
adjustCurrentSpinner(type4);
|
|
}, 200);
|
|
const getAmPmFlag = (hour) => {
|
|
const shouldShowAmPm = !!props2.amPmMode;
|
|
if (!shouldShowAmPm)
|
|
return "";
|
|
const isCapital = props2.amPmMode === "A";
|
|
let content = hour < 12 ? " am" : " pm";
|
|
if (isCapital)
|
|
content = content.toUpperCase();
|
|
return content;
|
|
};
|
|
const emitSelectRange = (type4) => {
|
|
let range4 = [0, 0];
|
|
if (!format2 || format2 === DEFAULT_FORMATS_TIME) {
|
|
switch (type4) {
|
|
case "hours":
|
|
range4 = [0, 2];
|
|
break;
|
|
case "minutes":
|
|
range4 = [3, 5];
|
|
break;
|
|
case "seconds":
|
|
range4 = [6, 8];
|
|
break;
|
|
}
|
|
}
|
|
const [left, right] = range4;
|
|
emit("select-range", left, right);
|
|
currentScrollbar.value = type4;
|
|
};
|
|
const adjustCurrentSpinner = (type4) => {
|
|
adjustSpinner(type4, unref(timePartials)[type4]);
|
|
};
|
|
const adjustSpinners = () => {
|
|
adjustCurrentSpinner("hours");
|
|
adjustCurrentSpinner("minutes");
|
|
adjustCurrentSpinner("seconds");
|
|
};
|
|
const getScrollbarElement = (el) => el.querySelector(`.${ns.namespace.value}-scrollbar__wrap`);
|
|
const adjustSpinner = (type4, value) => {
|
|
if (props2.arrowControl)
|
|
return;
|
|
const scrollbar = unref(listRefsMap[type4]);
|
|
if (scrollbar && scrollbar.$el) {
|
|
getScrollbarElement(scrollbar.$el).scrollTop = Math.max(0, value * typeItemHeight(type4));
|
|
}
|
|
};
|
|
const typeItemHeight = (type4) => {
|
|
const scrollbar = unref(listRefsMap[type4]);
|
|
const listItem = scrollbar == null ? void 0 : scrollbar.$el.querySelector("li");
|
|
if (listItem) {
|
|
return Number.parseFloat(getStyle(listItem, "height")) || 0;
|
|
}
|
|
return 0;
|
|
};
|
|
const onIncrement = () => {
|
|
scrollDown(1);
|
|
};
|
|
const onDecrement = () => {
|
|
scrollDown(-1);
|
|
};
|
|
const scrollDown = (step) => {
|
|
if (!currentScrollbar.value) {
|
|
emitSelectRange("hours");
|
|
}
|
|
const label = currentScrollbar.value;
|
|
const now2 = unref(timePartials)[label];
|
|
const total2 = currentScrollbar.value === "hours" ? 24 : 60;
|
|
const next = findNextUnDisabled(label, now2, step, total2);
|
|
modifyDateField(label, next);
|
|
adjustSpinner(label, next);
|
|
nextTick(() => emitSelectRange(label));
|
|
};
|
|
const findNextUnDisabled = (type4, now2, step, total2) => {
|
|
let next = (now2 + step + total2) % total2;
|
|
const list = unref(timeList)[type4];
|
|
while (list[next] && next !== now2) {
|
|
next = (next + step + total2) % total2;
|
|
}
|
|
return next;
|
|
};
|
|
const modifyDateField = (type4, value) => {
|
|
const list = unref(timeList)[type4];
|
|
const isDisabled = list[value];
|
|
if (isDisabled)
|
|
return;
|
|
const { hours, minutes, seconds } = unref(timePartials);
|
|
let changeTo;
|
|
switch (type4) {
|
|
case "hours":
|
|
changeTo = props2.spinnerDate.hour(value).minute(minutes).second(seconds);
|
|
break;
|
|
case "minutes":
|
|
changeTo = props2.spinnerDate.hour(hours).minute(value).second(seconds);
|
|
break;
|
|
case "seconds":
|
|
changeTo = props2.spinnerDate.hour(hours).minute(minutes).second(value);
|
|
break;
|
|
}
|
|
emit(CHANGE_EVENT, changeTo);
|
|
};
|
|
const handleClick = (type4, { value, disabled }) => {
|
|
if (!disabled) {
|
|
modifyDateField(type4, value);
|
|
emitSelectRange(type4);
|
|
adjustSpinner(type4, value);
|
|
}
|
|
};
|
|
const handleScroll2 = (type4) => {
|
|
const scrollbar = unref(listRefsMap[type4]);
|
|
if (!scrollbar)
|
|
return;
|
|
isScrolling = true;
|
|
debouncedResetScroll(type4);
|
|
const value = Math.min(Math.round((getScrollbarElement(scrollbar.$el).scrollTop - (scrollBarHeight(type4) * 0.5 - 10) / typeItemHeight(type4) + 3) / typeItemHeight(type4)), type4 === "hours" ? 23 : 59);
|
|
modifyDateField(type4, value);
|
|
};
|
|
const scrollBarHeight = (type4) => {
|
|
return unref(listRefsMap[type4]).$el.offsetHeight;
|
|
};
|
|
const bindScrollEvent = () => {
|
|
const bindFunction = (type4) => {
|
|
const scrollbar = unref(listRefsMap[type4]);
|
|
if (scrollbar && scrollbar.$el) {
|
|
getScrollbarElement(scrollbar.$el).onscroll = () => {
|
|
handleScroll2(type4);
|
|
};
|
|
}
|
|
};
|
|
bindFunction("hours");
|
|
bindFunction("minutes");
|
|
bindFunction("seconds");
|
|
};
|
|
onMounted(() => {
|
|
nextTick(() => {
|
|
!props2.arrowControl && bindScrollEvent();
|
|
adjustSpinners();
|
|
if (props2.role === "start")
|
|
emitSelectRange("hours");
|
|
});
|
|
});
|
|
const setRef = (scrollbar, type4) => {
|
|
listRefsMap[type4].value = scrollbar != null ? scrollbar : void 0;
|
|
};
|
|
emit("set-option", [`${props2.role}_scrollDown`, scrollDown]);
|
|
emit("set-option", [`${props2.role}_emitSelectRange`, emitSelectRange]);
|
|
watch(() => props2.spinnerDate, () => {
|
|
if (isScrolling)
|
|
return;
|
|
adjustSpinners();
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([unref(ns).b("spinner"), { "has-seconds": _ctx.showSeconds }])
|
|
}, [
|
|
!_ctx.arrowControl ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(unref(spinnerItems), (item) => {
|
|
return openBlock(), createBlock(unref(ElScrollbar), {
|
|
key: item,
|
|
ref_for: true,
|
|
ref: (scrollbar) => setRef(scrollbar, item),
|
|
class: normalizeClass(unref(ns).be("spinner", "wrapper")),
|
|
"wrap-style": "max-height: inherit;",
|
|
"view-class": unref(ns).be("spinner", "list"),
|
|
noresize: "",
|
|
tag: "ul",
|
|
onMouseenter: ($event) => emitSelectRange(item),
|
|
onMousemove: ($event) => adjustCurrentSpinner(item)
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(timeList)[item], (disabled, key) => {
|
|
return openBlock(), createElementBlock("li", {
|
|
key,
|
|
class: normalizeClass([
|
|
unref(ns).be("spinner", "item"),
|
|
unref(ns).is("active", key === unref(timePartials)[item]),
|
|
unref(ns).is("disabled", disabled)
|
|
]),
|
|
onClick: ($event) => handleClick(item, { value: key, disabled })
|
|
}, [
|
|
item === "hours" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
|
|
createTextVNode(toDisplayString(("0" + (_ctx.amPmMode ? key % 12 || 12 : key)).slice(-2)) + toDisplayString(getAmPmFlag(key)), 1)
|
|
], 64)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
|
|
createTextVNode(toDisplayString(("0" + key).slice(-2)), 1)
|
|
], 64))
|
|
], 10, ["onClick"]);
|
|
}), 128))
|
|
]),
|
|
_: 2
|
|
}, 1032, ["class", "view-class", "onMouseenter", "onMousemove"]);
|
|
}), 128)) : createCommentVNode("v-if", true),
|
|
_ctx.arrowControl ? (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(unref(spinnerItems), (item) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
key: item,
|
|
class: normalizeClass([unref(ns).be("spinner", "wrapper"), unref(ns).is("arrow")]),
|
|
onMouseenter: ($event) => emitSelectRange(item)
|
|
}, [
|
|
withDirectives((openBlock(), createBlock(unref(ElIcon), {
|
|
class: normalizeClass(["arrow-up", unref(ns).be("spinner", "arrow")])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(arrow_up_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])), [
|
|
[unref(vRepeatClick), onDecrement]
|
|
]),
|
|
withDirectives((openBlock(), createBlock(unref(ElIcon), {
|
|
class: normalizeClass(["arrow-down", unref(ns).be("spinner", "arrow")])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(arrow_down_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])), [
|
|
[unref(vRepeatClick), onIncrement]
|
|
]),
|
|
createBaseVNode("ul", {
|
|
class: normalizeClass(unref(ns).be("spinner", "list"))
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(arrowControlTimeList)[item], (time, key) => {
|
|
return openBlock(), createElementBlock("li", {
|
|
key,
|
|
class: normalizeClass([
|
|
unref(ns).be("spinner", "item"),
|
|
unref(ns).is("active", time === unref(timePartials)[item]),
|
|
unref(ns).is("disabled", unref(timeList)[item][time])
|
|
])
|
|
}, [
|
|
unref(isNumber2)(time) ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
|
|
item === "hours" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
|
|
createTextVNode(toDisplayString(("0" + (_ctx.amPmMode ? time % 12 || 12 : time)).slice(-2)) + toDisplayString(getAmPmFlag(time)), 1)
|
|
], 64)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
|
|
createTextVNode(toDisplayString(("0" + time).slice(-2)), 1)
|
|
], 64))
|
|
], 64)) : createCommentVNode("v-if", true)
|
|
], 2);
|
|
}), 128))
|
|
], 2)
|
|
], 42, ["onMouseenter"]);
|
|
}), 128)) : createCommentVNode("v-if", true)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var TimeSpinner = _export_sfc(_sfc_main58, [["__file", "basic-time-spinner.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/time-picker-com/panel-time-pick.mjs
|
|
var _sfc_main59 = defineComponent({
|
|
__name: "panel-time-pick",
|
|
props: panelTimePickerProps,
|
|
emits: ["pick", "select-range", "set-picker-option"],
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const pickerBase = inject("EP_PICKER_BASE");
|
|
const {
|
|
arrowControl,
|
|
disabledHours,
|
|
disabledMinutes,
|
|
disabledSeconds,
|
|
defaultValue
|
|
} = pickerBase.props;
|
|
const { getAvailableHours, getAvailableMinutes, getAvailableSeconds } = buildAvailableTimeSlotGetter(disabledHours, disabledMinutes, disabledSeconds);
|
|
const ns = useNamespace("time");
|
|
const { t, lang } = useLocale();
|
|
const selectionRange = ref([0, 2]);
|
|
const oldValue = useOldValue(props2);
|
|
const transitionName = computed(() => {
|
|
return isUndefined2(props2.actualVisible) ? `${ns.namespace.value}-zoom-in-top` : "";
|
|
});
|
|
const showSeconds = computed(() => {
|
|
return props2.format.includes("ss");
|
|
});
|
|
const amPmMode = computed(() => {
|
|
if (props2.format.includes("A"))
|
|
return "A";
|
|
if (props2.format.includes("a"))
|
|
return "a";
|
|
return "";
|
|
});
|
|
const isValidValue3 = (_date) => {
|
|
const parsedDate = (0, import_dayjs4.default)(_date).locale(lang.value);
|
|
const result2 = getRangeAvailableTime(parsedDate);
|
|
return parsedDate.isSame(result2);
|
|
};
|
|
const handleCancel = () => {
|
|
emit("pick", oldValue.value, false);
|
|
};
|
|
const handleConfirm = (visible = false, first = false) => {
|
|
if (first)
|
|
return;
|
|
emit("pick", props2.parsedValue, visible);
|
|
};
|
|
const handleChange = (_date) => {
|
|
if (!props2.visible) {
|
|
return;
|
|
}
|
|
const result2 = getRangeAvailableTime(_date).millisecond(0);
|
|
emit("pick", result2, true);
|
|
};
|
|
const setSelectionRange = (start, end) => {
|
|
emit("select-range", start, end);
|
|
selectionRange.value = [start, end];
|
|
};
|
|
const changeSelectionRange = (step) => {
|
|
const list = [0, 3].concat(showSeconds.value ? [6] : []);
|
|
const mapping = ["hours", "minutes"].concat(showSeconds.value ? ["seconds"] : []);
|
|
const index = list.indexOf(selectionRange.value[0]);
|
|
const next = (index + step + list.length) % list.length;
|
|
timePickerOptions["start_emitSelectRange"](mapping[next]);
|
|
};
|
|
const handleKeydown = (event) => {
|
|
const code = event.code;
|
|
const { left, right, up, down } = EVENT_CODE;
|
|
if ([left, right].includes(code)) {
|
|
const step = code === left ? -1 : 1;
|
|
changeSelectionRange(step);
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
if ([up, down].includes(code)) {
|
|
const step = code === up ? -1 : 1;
|
|
timePickerOptions["start_scrollDown"](step);
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
};
|
|
const { timePickerOptions, onSetOption, getAvailableTime } = useTimePanel({
|
|
getAvailableHours,
|
|
getAvailableMinutes,
|
|
getAvailableSeconds
|
|
});
|
|
const getRangeAvailableTime = (date4) => {
|
|
return getAvailableTime(date4, props2.datetimeRole || "", true);
|
|
};
|
|
const parseUserInput = (value) => {
|
|
if (!value)
|
|
return null;
|
|
return (0, import_dayjs4.default)(value, props2.format).locale(lang.value);
|
|
};
|
|
const formatToString = (value) => {
|
|
if (!value)
|
|
return null;
|
|
return value.format(props2.format);
|
|
};
|
|
const getDefaultValue2 = () => {
|
|
return (0, import_dayjs4.default)(defaultValue).locale(lang.value);
|
|
};
|
|
emit("set-picker-option", ["isValidValue", isValidValue3]);
|
|
emit("set-picker-option", ["formatToString", formatToString]);
|
|
emit("set-picker-option", ["parseUserInput", parseUserInput]);
|
|
emit("set-picker-option", ["handleKeydownInput", handleKeydown]);
|
|
emit("set-picker-option", ["getRangeAvailableTime", getRangeAvailableTime]);
|
|
emit("set-picker-option", ["getDefaultValue", getDefaultValue2]);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(Transition, { name: unref(transitionName) }, {
|
|
default: withCtx(() => [
|
|
_ctx.actualVisible || _ctx.visible ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).b("panel"))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([unref(ns).be("panel", "content"), { "has-seconds": unref(showSeconds) }])
|
|
}, [
|
|
createVNode(TimeSpinner, {
|
|
ref: "spinner",
|
|
role: _ctx.datetimeRole || "start",
|
|
"arrow-control": unref(arrowControl),
|
|
"show-seconds": unref(showSeconds),
|
|
"am-pm-mode": unref(amPmMode),
|
|
"spinner-date": _ctx.parsedValue,
|
|
"disabled-hours": unref(disabledHours),
|
|
"disabled-minutes": unref(disabledMinutes),
|
|
"disabled-seconds": unref(disabledSeconds),
|
|
onChange: handleChange,
|
|
onSetOption: unref(onSetOption),
|
|
onSelectRange: setSelectionRange
|
|
}, null, 8, ["role", "arrow-control", "show-seconds", "am-pm-mode", "spinner-date", "disabled-hours", "disabled-minutes", "disabled-seconds", "onSetOption"])
|
|
], 2),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).be("panel", "footer"))
|
|
}, [
|
|
createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass([unref(ns).be("panel", "btn"), "cancel"]),
|
|
onClick: handleCancel
|
|
}, toDisplayString(unref(t)("el.datepicker.cancel")), 3),
|
|
createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass([unref(ns).be("panel", "btn"), "confirm"]),
|
|
onClick: ($event) => handleConfirm()
|
|
}, toDisplayString(unref(t)("el.datepicker.confirm")), 11, ["onClick"])
|
|
], 2)
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 1
|
|
}, 8, ["name"]);
|
|
};
|
|
}
|
|
});
|
|
var TimePickPanel = _export_sfc(_sfc_main59, [["__file", "panel-time-pick.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/time-picker.mjs
|
|
var import_dayjs6 = __toModule(require_dayjs_min());
|
|
var import_customParseFormat = __toModule(require_customParseFormat());
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/time-picker-com/panel-time-range.mjs
|
|
var import_dayjs5 = __toModule(require_dayjs_min());
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/props/panel-time-range.mjs
|
|
var panelTimeRangeProps = buildProps({
|
|
...timePanelSharedProps,
|
|
parsedValue: {
|
|
type: definePropType(Array)
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/time-picker-com/panel-time-range.mjs
|
|
var _sfc_main60 = defineComponent({
|
|
__name: "panel-time-range",
|
|
props: panelTimeRangeProps,
|
|
emits: ["pick", "select-range", "set-picker-option"],
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const makeSelectRange = (start, end) => {
|
|
const result2 = [];
|
|
for (let i = start; i <= end; i++) {
|
|
result2.push(i);
|
|
}
|
|
return result2;
|
|
};
|
|
const { t, lang } = useLocale();
|
|
const nsTime = useNamespace("time");
|
|
const nsPicker = useNamespace("picker");
|
|
const pickerBase = inject("EP_PICKER_BASE");
|
|
const {
|
|
arrowControl,
|
|
disabledHours,
|
|
disabledMinutes,
|
|
disabledSeconds,
|
|
defaultValue
|
|
} = pickerBase.props;
|
|
const startContainerKls = computed(() => [
|
|
nsTime.be("range-picker", "body"),
|
|
nsTime.be("panel", "content"),
|
|
nsTime.is("arrow", arrowControl),
|
|
showSeconds.value ? "has-seconds" : ""
|
|
]);
|
|
const endContainerKls = computed(() => [
|
|
nsTime.be("range-picker", "body"),
|
|
nsTime.be("panel", "content"),
|
|
nsTime.is("arrow", arrowControl),
|
|
showSeconds.value ? "has-seconds" : ""
|
|
]);
|
|
const startTime = computed(() => props2.parsedValue[0]);
|
|
const endTime = computed(() => props2.parsedValue[1]);
|
|
const oldValue = useOldValue(props2);
|
|
const handleCancel = () => {
|
|
emit("pick", oldValue.value, false);
|
|
};
|
|
const showSeconds = computed(() => {
|
|
return props2.format.includes("ss");
|
|
});
|
|
const amPmMode = computed(() => {
|
|
if (props2.format.includes("A"))
|
|
return "A";
|
|
if (props2.format.includes("a"))
|
|
return "a";
|
|
return "";
|
|
});
|
|
const handleConfirm = (visible = false) => {
|
|
emit("pick", [startTime.value, endTime.value], visible);
|
|
};
|
|
const handleMinChange = (date4) => {
|
|
handleChange(date4.millisecond(0), endTime.value);
|
|
};
|
|
const handleMaxChange = (date4) => {
|
|
handleChange(startTime.value, date4.millisecond(0));
|
|
};
|
|
const isValidValue3 = (_date) => {
|
|
const parsedDate = _date.map((_2) => (0, import_dayjs5.default)(_2).locale(lang.value));
|
|
const result2 = getRangeAvailableTime(parsedDate);
|
|
return parsedDate[0].isSame(result2[0]) && parsedDate[1].isSame(result2[1]);
|
|
};
|
|
const handleChange = (start, end) => {
|
|
if (!props2.visible) {
|
|
return;
|
|
}
|
|
emit("pick", [start, end], true);
|
|
};
|
|
const btnConfirmDisabled = computed(() => {
|
|
return startTime.value > endTime.value;
|
|
});
|
|
const selectionRange = ref([0, 2]);
|
|
const setMinSelectionRange = (start, end) => {
|
|
emit("select-range", start, end, "min");
|
|
selectionRange.value = [start, end];
|
|
};
|
|
const offset3 = computed(() => showSeconds.value ? 11 : 8);
|
|
const setMaxSelectionRange = (start, end) => {
|
|
emit("select-range", start, end, "max");
|
|
const _offset = unref(offset3);
|
|
selectionRange.value = [start + _offset, end + _offset];
|
|
};
|
|
const changeSelectionRange = (step) => {
|
|
const list = showSeconds.value ? [0, 3, 6, 11, 14, 17] : [0, 3, 8, 11];
|
|
const mapping = ["hours", "minutes"].concat(showSeconds.value ? ["seconds"] : []);
|
|
const index = list.indexOf(selectionRange.value[0]);
|
|
const next = (index + step + list.length) % list.length;
|
|
const half = list.length / 2;
|
|
if (next < half) {
|
|
timePickerOptions["start_emitSelectRange"](mapping[next]);
|
|
} else {
|
|
timePickerOptions["end_emitSelectRange"](mapping[next - half]);
|
|
}
|
|
};
|
|
const handleKeydown = (event) => {
|
|
const code = event.code;
|
|
const { left, right, up, down } = EVENT_CODE;
|
|
if ([left, right].includes(code)) {
|
|
const step = code === left ? -1 : 1;
|
|
changeSelectionRange(step);
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
if ([up, down].includes(code)) {
|
|
const step = code === up ? -1 : 1;
|
|
const role = selectionRange.value[0] < offset3.value ? "start" : "end";
|
|
timePickerOptions[`${role}_scrollDown`](step);
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
};
|
|
const disabledHours_ = (role, compare) => {
|
|
const defaultDisable = disabledHours ? disabledHours(role) : [];
|
|
const isStart = role === "start";
|
|
const compareDate = compare || (isStart ? endTime.value : startTime.value);
|
|
const compareHour = compareDate.hour();
|
|
const nextDisable = isStart ? makeSelectRange(compareHour + 1, 23) : makeSelectRange(0, compareHour - 1);
|
|
return union_default(defaultDisable, nextDisable);
|
|
};
|
|
const disabledMinutes_ = (hour, role, compare) => {
|
|
const defaultDisable = disabledMinutes ? disabledMinutes(hour, role) : [];
|
|
const isStart = role === "start";
|
|
const compareDate = compare || (isStart ? endTime.value : startTime.value);
|
|
const compareHour = compareDate.hour();
|
|
if (hour !== compareHour) {
|
|
return defaultDisable;
|
|
}
|
|
const compareMinute = compareDate.minute();
|
|
const nextDisable = isStart ? makeSelectRange(compareMinute + 1, 59) : makeSelectRange(0, compareMinute - 1);
|
|
return union_default(defaultDisable, nextDisable);
|
|
};
|
|
const disabledSeconds_ = (hour, minute, role, compare) => {
|
|
const defaultDisable = disabledSeconds ? disabledSeconds(hour, minute, role) : [];
|
|
const isStart = role === "start";
|
|
const compareDate = compare || (isStart ? endTime.value : startTime.value);
|
|
const compareHour = compareDate.hour();
|
|
const compareMinute = compareDate.minute();
|
|
if (hour !== compareHour || minute !== compareMinute) {
|
|
return defaultDisable;
|
|
}
|
|
const compareSecond = compareDate.second();
|
|
const nextDisable = isStart ? makeSelectRange(compareSecond + 1, 59) : makeSelectRange(0, compareSecond - 1);
|
|
return union_default(defaultDisable, nextDisable);
|
|
};
|
|
const getRangeAvailableTime = ([start, end]) => {
|
|
return [
|
|
getAvailableTime(start, "start", true, end),
|
|
getAvailableTime(end, "end", false, start)
|
|
];
|
|
};
|
|
const { getAvailableHours, getAvailableMinutes, getAvailableSeconds } = buildAvailableTimeSlotGetter(disabledHours_, disabledMinutes_, disabledSeconds_);
|
|
const {
|
|
timePickerOptions,
|
|
getAvailableTime,
|
|
onSetOption
|
|
} = useTimePanel({
|
|
getAvailableHours,
|
|
getAvailableMinutes,
|
|
getAvailableSeconds
|
|
});
|
|
const parseUserInput = (days) => {
|
|
if (!days)
|
|
return null;
|
|
if (isArray(days)) {
|
|
return days.map((d2) => (0, import_dayjs5.default)(d2, props2.format).locale(lang.value));
|
|
}
|
|
return (0, import_dayjs5.default)(days, props2.format).locale(lang.value);
|
|
};
|
|
const formatToString = (days) => {
|
|
if (!days)
|
|
return null;
|
|
if (isArray(days)) {
|
|
return days.map((d2) => d2.format(props2.format));
|
|
}
|
|
return days.format(props2.format);
|
|
};
|
|
const getDefaultValue2 = () => {
|
|
if (isArray(defaultValue)) {
|
|
return defaultValue.map((d2) => (0, import_dayjs5.default)(d2).locale(lang.value));
|
|
}
|
|
const defaultDay = (0, import_dayjs5.default)(defaultValue).locale(lang.value);
|
|
return [defaultDay, defaultDay.add(60, "m")];
|
|
};
|
|
emit("set-picker-option", ["formatToString", formatToString]);
|
|
emit("set-picker-option", ["parseUserInput", parseUserInput]);
|
|
emit("set-picker-option", ["isValidValue", isValidValue3]);
|
|
emit("set-picker-option", ["handleKeydownInput", handleKeydown]);
|
|
emit("set-picker-option", ["getDefaultValue", getDefaultValue2]);
|
|
emit("set-picker-option", ["getRangeAvailableTime", getRangeAvailableTime]);
|
|
return (_ctx, _cache) => {
|
|
return _ctx.actualVisible ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass([unref(nsTime).b("range-picker"), unref(nsPicker).b("panel")])
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(nsTime).be("range-picker", "content"))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(nsTime).be("range-picker", "cell"))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(nsTime).be("range-picker", "header"))
|
|
}, toDisplayString(unref(t)("el.datepicker.startTime")), 3),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(startContainerKls))
|
|
}, [
|
|
createVNode(TimeSpinner, {
|
|
ref: "minSpinner",
|
|
role: "start",
|
|
"show-seconds": unref(showSeconds),
|
|
"am-pm-mode": unref(amPmMode),
|
|
"arrow-control": unref(arrowControl),
|
|
"spinner-date": unref(startTime),
|
|
"disabled-hours": disabledHours_,
|
|
"disabled-minutes": disabledMinutes_,
|
|
"disabled-seconds": disabledSeconds_,
|
|
onChange: handleMinChange,
|
|
onSetOption: unref(onSetOption),
|
|
onSelectRange: setMinSelectionRange
|
|
}, null, 8, ["show-seconds", "am-pm-mode", "arrow-control", "spinner-date", "onSetOption"])
|
|
], 2)
|
|
], 2),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(nsTime).be("range-picker", "cell"))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(nsTime).be("range-picker", "header"))
|
|
}, toDisplayString(unref(t)("el.datepicker.endTime")), 3),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(endContainerKls))
|
|
}, [
|
|
createVNode(TimeSpinner, {
|
|
ref: "maxSpinner",
|
|
role: "end",
|
|
"show-seconds": unref(showSeconds),
|
|
"am-pm-mode": unref(amPmMode),
|
|
"arrow-control": unref(arrowControl),
|
|
"spinner-date": unref(endTime),
|
|
"disabled-hours": disabledHours_,
|
|
"disabled-minutes": disabledMinutes_,
|
|
"disabled-seconds": disabledSeconds_,
|
|
onChange: handleMaxChange,
|
|
onSetOption: unref(onSetOption),
|
|
onSelectRange: setMaxSelectionRange
|
|
}, null, 8, ["show-seconds", "am-pm-mode", "arrow-control", "spinner-date", "onSetOption"])
|
|
], 2)
|
|
], 2)
|
|
], 2),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(nsTime).be("panel", "footer"))
|
|
}, [
|
|
createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass([unref(nsTime).be("panel", "btn"), "cancel"]),
|
|
onClick: ($event) => handleCancel()
|
|
}, toDisplayString(unref(t)("el.datepicker.cancel")), 11, ["onClick"]),
|
|
createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass([unref(nsTime).be("panel", "btn"), "confirm"]),
|
|
disabled: unref(btnConfirmDisabled),
|
|
onClick: ($event) => handleConfirm()
|
|
}, toDisplayString(unref(t)("el.datepicker.confirm")), 11, ["disabled", "onClick"])
|
|
], 2)
|
|
], 2)) : createCommentVNode("v-if", true);
|
|
};
|
|
}
|
|
});
|
|
var TimeRangePanel = _export_sfc(_sfc_main60, [["__file", "panel-time-range.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/time-picker.mjs
|
|
import_dayjs6.default.extend(import_customParseFormat.default);
|
|
var TimePicker = defineComponent({
|
|
name: "ElTimePicker",
|
|
install: null,
|
|
props: {
|
|
...timePickerDefaultProps,
|
|
isRange: {
|
|
type: Boolean,
|
|
default: false
|
|
}
|
|
},
|
|
emits: [UPDATE_MODEL_EVENT],
|
|
setup(props2, ctx) {
|
|
const commonPicker = ref();
|
|
const [type4, Panel] = props2.isRange ? ["timerange", TimeRangePanel] : ["time", TimePickPanel];
|
|
const modelUpdater = (value) => ctx.emit(UPDATE_MODEL_EVENT, value);
|
|
provide("ElPopperOptions", props2.popperOptions);
|
|
ctx.expose({
|
|
focus: () => {
|
|
var _a2;
|
|
(_a2 = commonPicker.value) == null ? void 0 : _a2.focus();
|
|
},
|
|
blur: () => {
|
|
var _a2;
|
|
(_a2 = commonPicker.value) == null ? void 0 : _a2.blur();
|
|
},
|
|
handleOpen: () => {
|
|
var _a2;
|
|
(_a2 = commonPicker.value) == null ? void 0 : _a2.handleOpen();
|
|
},
|
|
handleClose: () => {
|
|
var _a2;
|
|
(_a2 = commonPicker.value) == null ? void 0 : _a2.handleClose();
|
|
}
|
|
});
|
|
return () => {
|
|
var _a2;
|
|
const format2 = (_a2 = props2.format) != null ? _a2 : DEFAULT_FORMATS_TIME;
|
|
return createVNode(CommonPicker, mergeProps(props2, {
|
|
"ref": commonPicker,
|
|
"type": type4,
|
|
"format": format2,
|
|
"onUpdate:modelValue": modelUpdater
|
|
}), {
|
|
default: (props22) => createVNode(Panel, props22, null)
|
|
});
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/time-picker/index.mjs
|
|
var ElTimePicker = withInstall(TimePicker);
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/constants.mjs
|
|
var ROOT_PICKER_INJECTION_KEY = Symbol();
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/props/date-picker.mjs
|
|
var datePickerProps = buildProps({
|
|
...timePickerDefaultProps,
|
|
type: {
|
|
type: definePropType(String),
|
|
default: "date"
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/date-picker.mjs
|
|
var import_dayjs17 = __toModule(require_dayjs_min());
|
|
var import_customParseFormat2 = __toModule(require_customParseFormat());
|
|
var import_advancedFormat = __toModule(require_advancedFormat());
|
|
var import_localeData2 = __toModule(require_localeData());
|
|
var import_weekOfYear = __toModule(require_weekOfYear());
|
|
var import_weekYear = __toModule(require_weekYear());
|
|
var import_dayOfYear = __toModule(require_dayOfYear());
|
|
var import_isSameOrAfter = __toModule(require_isSameOrAfter());
|
|
var import_isSameOrBefore = __toModule(require_isSameOrBefore());
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/date-picker-com/panel-date-pick.mjs
|
|
var import_dayjs11 = __toModule(require_dayjs_min());
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/props/shared.mjs
|
|
var selectionModes = [
|
|
"date",
|
|
"dates",
|
|
"year",
|
|
"years",
|
|
"month",
|
|
"months",
|
|
"week",
|
|
"range"
|
|
];
|
|
var datePickerSharedProps = buildProps({
|
|
disabledDate: {
|
|
type: definePropType(Function)
|
|
},
|
|
date: {
|
|
type: definePropType(Object),
|
|
required: true
|
|
},
|
|
minDate: {
|
|
type: definePropType(Object)
|
|
},
|
|
maxDate: {
|
|
type: definePropType(Object)
|
|
},
|
|
parsedValue: {
|
|
type: definePropType([Object, Array])
|
|
},
|
|
rangeState: {
|
|
type: definePropType(Object),
|
|
default: () => ({
|
|
endDate: null,
|
|
selecting: false
|
|
})
|
|
}
|
|
});
|
|
var panelSharedProps = buildProps({
|
|
type: {
|
|
type: definePropType(String),
|
|
required: true,
|
|
values: datePickTypes
|
|
},
|
|
dateFormat: String,
|
|
timeFormat: String,
|
|
showNow: {
|
|
type: Boolean,
|
|
default: true
|
|
}
|
|
});
|
|
var panelRangeSharedProps = buildProps({
|
|
unlinkPanels: Boolean,
|
|
parsedValue: {
|
|
type: definePropType(Array)
|
|
}
|
|
});
|
|
var selectionModeWithDefault = (mode) => {
|
|
return {
|
|
type: String,
|
|
values: selectionModes,
|
|
default: mode
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/props/panel-date-pick.mjs
|
|
var panelDatePickProps = buildProps({
|
|
...panelSharedProps,
|
|
parsedValue: {
|
|
type: definePropType([Object, Array])
|
|
},
|
|
visible: {
|
|
type: Boolean
|
|
},
|
|
format: {
|
|
type: String,
|
|
default: ""
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/utils.mjs
|
|
var import_dayjs7 = __toModule(require_dayjs_min());
|
|
var isValidRange2 = (range4) => {
|
|
if (!isArray(range4))
|
|
return false;
|
|
const [left, right] = range4;
|
|
return import_dayjs7.default.isDayjs(left) && import_dayjs7.default.isDayjs(right) && (0, import_dayjs7.default)(left).isValid() && (0, import_dayjs7.default)(right).isValid() && left.isSameOrBefore(right);
|
|
};
|
|
var getDefaultValue = (defaultValue, { lang, unit: unit4, unlinkPanels }) => {
|
|
let start;
|
|
if (isArray(defaultValue)) {
|
|
let [left, right] = defaultValue.map((d2) => (0, import_dayjs7.default)(d2).locale(lang));
|
|
if (!unlinkPanels) {
|
|
right = left.add(1, unit4);
|
|
}
|
|
return [left, right];
|
|
} else if (defaultValue) {
|
|
start = (0, import_dayjs7.default)(defaultValue);
|
|
} else {
|
|
start = (0, import_dayjs7.default)();
|
|
}
|
|
start = start.locale(lang);
|
|
return [start, start.add(1, unit4)];
|
|
};
|
|
var buildPickerTable = (dimension, rows, {
|
|
columnIndexOffset,
|
|
startDate,
|
|
nextEndDate,
|
|
now: now2,
|
|
unit: unit4,
|
|
relativeDateGetter,
|
|
setCellMetadata,
|
|
setRowMetadata
|
|
}) => {
|
|
for (let rowIndex = 0; rowIndex < dimension.row; rowIndex++) {
|
|
const row = rows[rowIndex];
|
|
for (let columnIndex = 0; columnIndex < dimension.column; columnIndex++) {
|
|
let cell = row[columnIndex + columnIndexOffset];
|
|
if (!cell) {
|
|
cell = {
|
|
row: rowIndex,
|
|
column: columnIndex,
|
|
type: "normal",
|
|
inRange: false,
|
|
start: false,
|
|
end: false
|
|
};
|
|
}
|
|
const index = rowIndex * dimension.column + columnIndex;
|
|
const nextStartDate = relativeDateGetter(index);
|
|
cell.dayjs = nextStartDate;
|
|
cell.date = nextStartDate.toDate();
|
|
cell.timestamp = nextStartDate.valueOf();
|
|
cell.type = "normal";
|
|
cell.inRange = !!(startDate && nextStartDate.isSameOrAfter(startDate, unit4) && nextEndDate && nextStartDate.isSameOrBefore(nextEndDate, unit4)) || !!(startDate && nextStartDate.isSameOrBefore(startDate, unit4) && nextEndDate && nextStartDate.isSameOrAfter(nextEndDate, unit4));
|
|
if (startDate == null ? void 0 : startDate.isSameOrAfter(nextEndDate)) {
|
|
cell.start = !!nextEndDate && nextStartDate.isSame(nextEndDate, unit4);
|
|
cell.end = startDate && nextStartDate.isSame(startDate, unit4);
|
|
} else {
|
|
cell.start = !!startDate && nextStartDate.isSame(startDate, unit4);
|
|
cell.end = !!nextEndDate && nextStartDate.isSame(nextEndDate, unit4);
|
|
}
|
|
const isToday = nextStartDate.isSame(now2, unit4);
|
|
if (isToday) {
|
|
cell.type = "today";
|
|
}
|
|
setCellMetadata == null ? void 0 : setCellMetadata(cell, { rowIndex, columnIndex });
|
|
row[columnIndex + columnIndexOffset] = cell;
|
|
}
|
|
setRowMetadata == null ? void 0 : setRowMetadata(row);
|
|
}
|
|
};
|
|
var datesInMonth = (date4, year, month, lang) => {
|
|
const firstDay = (0, import_dayjs7.default)(date4).locale(lang).month(month).year(year);
|
|
const numOfDays = firstDay.daysInMonth();
|
|
return rangeArr(numOfDays).map((n) => firstDay.add(n, "day").toDate());
|
|
};
|
|
var getValidDateOfMonth = (date4, year, month, lang, disabledDate) => {
|
|
const _value = (0, import_dayjs7.default)(date4).year(year).month(month);
|
|
const _date = datesInMonth(date4, year, month, lang).find((date22) => {
|
|
return !(disabledDate == null ? void 0 : disabledDate(date22));
|
|
});
|
|
if (_date) {
|
|
return (0, import_dayjs7.default)(_date).locale(lang);
|
|
}
|
|
return _value.locale(lang);
|
|
};
|
|
var getValidDateOfYear = (value, lang, disabledDate) => {
|
|
const year = value.year();
|
|
if (!(disabledDate == null ? void 0 : disabledDate(value.toDate()))) {
|
|
return value.locale(lang);
|
|
}
|
|
const month = value.month();
|
|
if (!datesInMonth(value, year, month, lang).every(disabledDate)) {
|
|
return getValidDateOfMonth(value, year, month, lang, disabledDate);
|
|
}
|
|
for (let i = 0; i < 12; i++) {
|
|
if (!datesInMonth(value, year, i, lang).every(disabledDate)) {
|
|
return getValidDateOfMonth(value, year, i, lang, disabledDate);
|
|
}
|
|
}
|
|
return value;
|
|
};
|
|
var correctlyParseUserInput = (value, format2, lang, defaultFormat) => {
|
|
if (isArray(value)) {
|
|
return value.map((v2) => correctlyParseUserInput(v2, format2, lang, defaultFormat));
|
|
}
|
|
if (isString(value)) {
|
|
const dayjsValue = defaultFormat.value ? (0, import_dayjs7.default)(value) : (0, import_dayjs7.default)(value, format2);
|
|
if (!dayjsValue.isValid()) {
|
|
return dayjsValue;
|
|
}
|
|
}
|
|
return (0, import_dayjs7.default)(value, format2).locale(lang);
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/props/basic-date-table.mjs
|
|
var basicDateTableProps = buildProps({
|
|
...datePickerSharedProps,
|
|
cellClassName: {
|
|
type: definePropType(Function)
|
|
},
|
|
showWeekNumber: Boolean,
|
|
selectionMode: selectionModeWithDefault("date")
|
|
});
|
|
var basicDateTableEmits = ["changerange", "pick", "select"];
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/composables/use-basic-date-table.mjs
|
|
var import_dayjs8 = __toModule(require_dayjs_min());
|
|
var isNormalDay = (type4 = "") => {
|
|
return ["normal", "today"].includes(type4);
|
|
};
|
|
var useBasicDateTable = (props2, emit) => {
|
|
const { lang } = useLocale();
|
|
const tbodyRef = ref();
|
|
const currentCellRef = ref();
|
|
const lastRow = ref();
|
|
const lastColumn = ref();
|
|
const tableRows = ref([[], [], [], [], [], []]);
|
|
let focusWithClick = false;
|
|
const firstDayOfWeek = props2.date.$locale().weekStart || 7;
|
|
const WEEKS_CONSTANT = props2.date.locale("en").localeData().weekdaysShort().map((_2) => _2.toLowerCase());
|
|
const offsetDay = computed(() => {
|
|
return firstDayOfWeek > 3 ? 7 - firstDayOfWeek : -firstDayOfWeek;
|
|
});
|
|
const startDate = computed(() => {
|
|
const startDayOfMonth = props2.date.startOf("month");
|
|
return startDayOfMonth.subtract(startDayOfMonth.day() || 7, "day");
|
|
});
|
|
const WEEKS = computed(() => {
|
|
return WEEKS_CONSTANT.concat(WEEKS_CONSTANT).slice(firstDayOfWeek, firstDayOfWeek + 7);
|
|
});
|
|
const hasCurrent = computed(() => {
|
|
return flatten_default(unref(rows)).some((row) => {
|
|
return row.isCurrent;
|
|
});
|
|
});
|
|
const days = computed(() => {
|
|
const startOfMonth = props2.date.startOf("month");
|
|
const startOfMonthDay = startOfMonth.day() || 7;
|
|
const dateCountOfMonth = startOfMonth.daysInMonth();
|
|
const dateCountOfLastMonth = startOfMonth.subtract(1, "month").daysInMonth();
|
|
return {
|
|
startOfMonthDay,
|
|
dateCountOfMonth,
|
|
dateCountOfLastMonth
|
|
};
|
|
});
|
|
const selectedDate = computed(() => {
|
|
return props2.selectionMode === "dates" ? castArray2(props2.parsedValue) : [];
|
|
});
|
|
const setDateText = (cell, { count, rowIndex, columnIndex }) => {
|
|
const { startOfMonthDay, dateCountOfMonth, dateCountOfLastMonth } = unref(days);
|
|
const offset3 = unref(offsetDay);
|
|
if (rowIndex >= 0 && rowIndex <= 1) {
|
|
const numberOfDaysFromPreviousMonth = startOfMonthDay + offset3 < 0 ? 7 + startOfMonthDay + offset3 : startOfMonthDay + offset3;
|
|
if (columnIndex + rowIndex * 7 >= numberOfDaysFromPreviousMonth) {
|
|
cell.text = count;
|
|
return true;
|
|
} else {
|
|
cell.text = dateCountOfLastMonth - (numberOfDaysFromPreviousMonth - columnIndex % 7) + 1 + rowIndex * 7;
|
|
cell.type = "prev-month";
|
|
}
|
|
} else {
|
|
if (count <= dateCountOfMonth) {
|
|
cell.text = count;
|
|
} else {
|
|
cell.text = count - dateCountOfMonth;
|
|
cell.type = "next-month";
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
const setCellMetadata = (cell, { columnIndex, rowIndex }, count) => {
|
|
const { disabledDate, cellClassName } = props2;
|
|
const _selectedDate = unref(selectedDate);
|
|
const shouldIncrement = setDateText(cell, { count, rowIndex, columnIndex });
|
|
const cellDate = cell.dayjs.toDate();
|
|
cell.selected = _selectedDate.find((d2) => d2.isSame(cell.dayjs, "day"));
|
|
cell.isSelected = !!cell.selected;
|
|
cell.isCurrent = isCurrent(cell);
|
|
cell.disabled = disabledDate == null ? void 0 : disabledDate(cellDate);
|
|
cell.customClass = cellClassName == null ? void 0 : cellClassName(cellDate);
|
|
return shouldIncrement;
|
|
};
|
|
const setRowMetadata = (row) => {
|
|
if (props2.selectionMode === "week") {
|
|
const [start, end] = props2.showWeekNumber ? [1, 7] : [0, 6];
|
|
const isActive = isWeekActive(row[start + 1]);
|
|
row[start].inRange = isActive;
|
|
row[start].start = isActive;
|
|
row[end].inRange = isActive;
|
|
row[end].end = isActive;
|
|
}
|
|
};
|
|
const rows = computed(() => {
|
|
const { minDate, maxDate, rangeState, showWeekNumber } = props2;
|
|
const offset3 = unref(offsetDay);
|
|
const rows_ = unref(tableRows);
|
|
const dateUnit = "day";
|
|
let count = 1;
|
|
if (showWeekNumber) {
|
|
for (let rowIndex = 0; rowIndex < 6; rowIndex++) {
|
|
if (!rows_[rowIndex][0]) {
|
|
rows_[rowIndex][0] = {
|
|
type: "week",
|
|
text: unref(startDate).add(rowIndex * 7 + 1, dateUnit).week()
|
|
};
|
|
}
|
|
}
|
|
}
|
|
buildPickerTable({ row: 6, column: 7 }, rows_, {
|
|
startDate: minDate,
|
|
columnIndexOffset: showWeekNumber ? 1 : 0,
|
|
nextEndDate: rangeState.endDate || maxDate || rangeState.selecting && minDate || null,
|
|
now: (0, import_dayjs8.default)().locale(unref(lang)).startOf(dateUnit),
|
|
unit: dateUnit,
|
|
relativeDateGetter: (idx) => unref(startDate).add(idx - offset3, dateUnit),
|
|
setCellMetadata: (...args) => {
|
|
if (setCellMetadata(...args, count)) {
|
|
count += 1;
|
|
}
|
|
},
|
|
setRowMetadata
|
|
});
|
|
return rows_;
|
|
});
|
|
watch(() => props2.date, async () => {
|
|
var _a2;
|
|
if ((_a2 = unref(tbodyRef)) == null ? void 0 : _a2.contains(document.activeElement)) {
|
|
await nextTick();
|
|
await focus();
|
|
}
|
|
});
|
|
const focus = async () => {
|
|
var _a2;
|
|
return (_a2 = unref(currentCellRef)) == null ? void 0 : _a2.focus();
|
|
};
|
|
const isCurrent = (cell) => {
|
|
return props2.selectionMode === "date" && isNormalDay(cell.type) && cellMatchesDate(cell, props2.parsedValue);
|
|
};
|
|
const cellMatchesDate = (cell, date4) => {
|
|
if (!date4)
|
|
return false;
|
|
return (0, import_dayjs8.default)(date4).locale(unref(lang)).isSame(props2.date.date(Number(cell.text)), "day");
|
|
};
|
|
const getDateOfCell = (row, column2) => {
|
|
const offsetFromStart = row * 7 + (column2 - (props2.showWeekNumber ? 1 : 0)) - unref(offsetDay);
|
|
return unref(startDate).add(offsetFromStart, "day");
|
|
};
|
|
const handleMouseMove = (event) => {
|
|
var _a2;
|
|
if (!props2.rangeState.selecting)
|
|
return;
|
|
let target2 = event.target;
|
|
if (target2.tagName === "SPAN") {
|
|
target2 = (_a2 = target2.parentNode) == null ? void 0 : _a2.parentNode;
|
|
}
|
|
if (target2.tagName === "DIV") {
|
|
target2 = target2.parentNode;
|
|
}
|
|
if (target2.tagName !== "TD")
|
|
return;
|
|
const row = target2.parentNode.rowIndex - 1;
|
|
const column2 = target2.cellIndex;
|
|
if (unref(rows)[row][column2].disabled)
|
|
return;
|
|
if (row !== unref(lastRow) || column2 !== unref(lastColumn)) {
|
|
lastRow.value = row;
|
|
lastColumn.value = column2;
|
|
emit("changerange", {
|
|
selecting: true,
|
|
endDate: getDateOfCell(row, column2)
|
|
});
|
|
}
|
|
};
|
|
const isSelectedCell = (cell) => {
|
|
return !unref(hasCurrent) && (cell == null ? void 0 : cell.text) === 1 && cell.type === "normal" || cell.isCurrent;
|
|
};
|
|
const handleFocus = (event) => {
|
|
if (focusWithClick || unref(hasCurrent) || props2.selectionMode !== "date")
|
|
return;
|
|
handlePickDate(event, true);
|
|
};
|
|
const handleMouseDown = (event) => {
|
|
const target2 = event.target.closest("td");
|
|
if (!target2)
|
|
return;
|
|
focusWithClick = true;
|
|
};
|
|
const handleMouseUp = (event) => {
|
|
const target2 = event.target.closest("td");
|
|
if (!target2)
|
|
return;
|
|
focusWithClick = false;
|
|
};
|
|
const handleRangePick = (newDate) => {
|
|
if (!props2.rangeState.selecting || !props2.minDate) {
|
|
emit("pick", { minDate: newDate, maxDate: null });
|
|
emit("select", true);
|
|
} else {
|
|
if (newDate >= props2.minDate) {
|
|
emit("pick", { minDate: props2.minDate, maxDate: newDate });
|
|
} else {
|
|
emit("pick", { minDate: newDate, maxDate: props2.minDate });
|
|
}
|
|
emit("select", false);
|
|
}
|
|
};
|
|
const handleWeekPick = (newDate) => {
|
|
const weekNumber = newDate.week();
|
|
const value = `${newDate.year()}w${weekNumber}`;
|
|
emit("pick", {
|
|
year: newDate.year(),
|
|
week: weekNumber,
|
|
value,
|
|
date: newDate.startOf("week")
|
|
});
|
|
};
|
|
const handleDatesPick = (newDate, selected) => {
|
|
const newValue = selected ? castArray2(props2.parsedValue).filter((d2) => (d2 == null ? void 0 : d2.valueOf()) !== newDate.valueOf()) : castArray2(props2.parsedValue).concat([newDate]);
|
|
emit("pick", newValue);
|
|
};
|
|
const handlePickDate = (event, isKeyboardMovement = false) => {
|
|
const target2 = event.target.closest("td");
|
|
if (!target2)
|
|
return;
|
|
const row = target2.parentNode.rowIndex - 1;
|
|
const column2 = target2.cellIndex;
|
|
const cell = unref(rows)[row][column2];
|
|
if (cell.disabled || cell.type === "week")
|
|
return;
|
|
const newDate = getDateOfCell(row, column2);
|
|
switch (props2.selectionMode) {
|
|
case "range": {
|
|
handleRangePick(newDate);
|
|
break;
|
|
}
|
|
case "date": {
|
|
emit("pick", newDate, isKeyboardMovement);
|
|
break;
|
|
}
|
|
case "week": {
|
|
handleWeekPick(newDate);
|
|
break;
|
|
}
|
|
case "dates": {
|
|
handleDatesPick(newDate, !!cell.selected);
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
const isWeekActive = (cell) => {
|
|
if (props2.selectionMode !== "week")
|
|
return false;
|
|
let newDate = props2.date.startOf("day");
|
|
if (cell.type === "prev-month") {
|
|
newDate = newDate.subtract(1, "month");
|
|
}
|
|
if (cell.type === "next-month") {
|
|
newDate = newDate.add(1, "month");
|
|
}
|
|
newDate = newDate.date(Number.parseInt(cell.text, 10));
|
|
if (props2.parsedValue && !isArray(props2.parsedValue)) {
|
|
const dayOffset = (props2.parsedValue.day() - firstDayOfWeek + 7) % 7 - 1;
|
|
const weekDate = props2.parsedValue.subtract(dayOffset, "day");
|
|
return weekDate.isSame(newDate, "day");
|
|
}
|
|
return false;
|
|
};
|
|
return {
|
|
WEEKS,
|
|
rows,
|
|
tbodyRef,
|
|
currentCellRef,
|
|
focus,
|
|
isCurrent,
|
|
isWeekActive,
|
|
isSelectedCell,
|
|
handlePickDate,
|
|
handleMouseUp,
|
|
handleMouseDown,
|
|
handleMouseMove,
|
|
handleFocus
|
|
};
|
|
};
|
|
var useBasicDateTableDOM = (props2, {
|
|
isCurrent,
|
|
isWeekActive
|
|
}) => {
|
|
const ns = useNamespace("date-table");
|
|
const { t } = useLocale();
|
|
const tableKls = computed(() => [
|
|
ns.b(),
|
|
{ "is-week-mode": props2.selectionMode === "week" }
|
|
]);
|
|
const tableLabel = computed(() => t("el.datepicker.dateTablePrompt"));
|
|
const weekLabel = computed(() => t("el.datepicker.week"));
|
|
const getCellClasses = (cell) => {
|
|
const classes = [];
|
|
if (isNormalDay(cell.type) && !cell.disabled) {
|
|
classes.push("available");
|
|
if (cell.type === "today") {
|
|
classes.push("today");
|
|
}
|
|
} else {
|
|
classes.push(cell.type);
|
|
}
|
|
if (isCurrent(cell)) {
|
|
classes.push("current");
|
|
}
|
|
if (cell.inRange && (isNormalDay(cell.type) || props2.selectionMode === "week")) {
|
|
classes.push("in-range");
|
|
if (cell.start) {
|
|
classes.push("start-date");
|
|
}
|
|
if (cell.end) {
|
|
classes.push("end-date");
|
|
}
|
|
}
|
|
if (cell.disabled) {
|
|
classes.push("disabled");
|
|
}
|
|
if (cell.selected) {
|
|
classes.push("selected");
|
|
}
|
|
if (cell.customClass) {
|
|
classes.push(cell.customClass);
|
|
}
|
|
return classes.join(" ");
|
|
};
|
|
const getRowKls = (cell) => [
|
|
ns.e("row"),
|
|
{ current: isWeekActive(cell) }
|
|
];
|
|
return {
|
|
tableKls,
|
|
tableLabel,
|
|
weekLabel,
|
|
getCellClasses,
|
|
getRowKls,
|
|
t
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/props/basic-cell.mjs
|
|
var basicCellProps = buildProps({
|
|
cell: {
|
|
type: definePropType(Object)
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/date-picker-com/basic-cell-render.mjs
|
|
var ElDatePickerCell = defineComponent({
|
|
name: "ElDatePickerCell",
|
|
props: basicCellProps,
|
|
setup(props2) {
|
|
const ns = useNamespace("date-table-cell");
|
|
const {
|
|
slots
|
|
} = inject(ROOT_PICKER_INJECTION_KEY);
|
|
return () => {
|
|
const {
|
|
cell
|
|
} = props2;
|
|
return renderSlot(slots, "default", {
|
|
...cell
|
|
}, () => {
|
|
var _a2;
|
|
return [createVNode("div", {
|
|
"class": ns.b()
|
|
}, [createVNode("span", {
|
|
"class": ns.e("text")
|
|
}, [(_a2 = cell == null ? void 0 : cell.renderText) != null ? _a2 : cell == null ? void 0 : cell.text])])];
|
|
});
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/date-picker-com/basic-date-table.mjs
|
|
var _sfc_main61 = defineComponent({
|
|
__name: "basic-date-table",
|
|
props: basicDateTableProps,
|
|
emits: basicDateTableEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const {
|
|
WEEKS,
|
|
rows,
|
|
tbodyRef,
|
|
currentCellRef,
|
|
focus,
|
|
isCurrent,
|
|
isWeekActive,
|
|
isSelectedCell,
|
|
handlePickDate,
|
|
handleMouseUp,
|
|
handleMouseDown,
|
|
handleMouseMove,
|
|
handleFocus
|
|
} = useBasicDateTable(props2, emit);
|
|
const { tableLabel, tableKls, weekLabel, getCellClasses, getRowKls, t } = useBasicDateTableDOM(props2, {
|
|
isCurrent,
|
|
isWeekActive
|
|
});
|
|
let isUnmounting = false;
|
|
onBeforeUnmount(() => {
|
|
isUnmounting = true;
|
|
});
|
|
expose({
|
|
focus
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("table", {
|
|
"aria-label": unref(tableLabel),
|
|
class: normalizeClass(unref(tableKls)),
|
|
cellspacing: "0",
|
|
cellpadding: "0",
|
|
role: "grid",
|
|
onClick: unref(handlePickDate),
|
|
onMousemove: unref(handleMouseMove),
|
|
onMousedown: withModifiers(unref(handleMouseDown), ["prevent"]),
|
|
onMouseup: unref(handleMouseUp)
|
|
}, [
|
|
createBaseVNode("tbody", {
|
|
ref_key: "tbodyRef",
|
|
ref: tbodyRef
|
|
}, [
|
|
createBaseVNode("tr", null, [
|
|
_ctx.showWeekNumber ? (openBlock(), createElementBlock("th", {
|
|
key: 0,
|
|
scope: "col"
|
|
}, toDisplayString(unref(weekLabel)), 1)) : createCommentVNode("v-if", true),
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(WEEKS), (week, key) => {
|
|
return openBlock(), createElementBlock("th", {
|
|
key,
|
|
"aria-label": unref(t)("el.datepicker.weeksFull." + week),
|
|
scope: "col"
|
|
}, toDisplayString(unref(t)("el.datepicker.weeks." + week)), 9, ["aria-label"]);
|
|
}), 128))
|
|
]),
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(rows), (row, rowKey2) => {
|
|
return openBlock(), createElementBlock("tr", {
|
|
key: rowKey2,
|
|
class: normalizeClass(unref(getRowKls)(row[1]))
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(row, (cell, columnKey) => {
|
|
return openBlock(), createElementBlock("td", {
|
|
key: `${rowKey2}.${columnKey}`,
|
|
ref_for: true,
|
|
ref: (el) => !unref(isUnmounting) && unref(isSelectedCell)(cell) && (currentCellRef.value = el),
|
|
class: normalizeClass(unref(getCellClasses)(cell)),
|
|
"aria-current": cell.isCurrent ? "date" : void 0,
|
|
"aria-selected": cell.isCurrent,
|
|
tabindex: unref(isSelectedCell)(cell) ? 0 : -1,
|
|
onFocus: unref(handleFocus)
|
|
}, [
|
|
createVNode(unref(ElDatePickerCell), { cell }, null, 8, ["cell"])
|
|
], 42, ["aria-current", "aria-selected", "tabindex", "onFocus"]);
|
|
}), 128))
|
|
], 2);
|
|
}), 128))
|
|
], 512)
|
|
], 42, ["aria-label", "onClick", "onMousemove", "onMousedown", "onMouseup"]);
|
|
};
|
|
}
|
|
});
|
|
var DateTable2 = _export_sfc(_sfc_main61, [["__file", "basic-date-table.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/date-picker-com/basic-month-table.mjs
|
|
var import_dayjs9 = __toModule(require_dayjs_min());
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/props/basic-month-table.mjs
|
|
var basicMonthTableProps = buildProps({
|
|
...datePickerSharedProps,
|
|
selectionMode: selectionModeWithDefault("month")
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/date-picker-com/basic-month-table.mjs
|
|
var _sfc_main62 = defineComponent({
|
|
__name: "basic-month-table",
|
|
props: basicMonthTableProps,
|
|
emits: ["changerange", "pick", "select"],
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("month-table");
|
|
const { t, lang } = useLocale();
|
|
const tbodyRef = ref();
|
|
const currentCellRef = ref();
|
|
const months = ref(props2.date.locale("en").localeData().monthsShort().map((_2) => _2.toLowerCase()));
|
|
const tableRows = ref([
|
|
[],
|
|
[],
|
|
[]
|
|
]);
|
|
const lastRow = ref();
|
|
const lastColumn = ref();
|
|
const rows = computed(() => {
|
|
var _a2, _b;
|
|
const rows2 = tableRows.value;
|
|
const now2 = (0, import_dayjs9.default)().locale(lang.value).startOf("month");
|
|
for (let i = 0; i < 3; i++) {
|
|
const row = rows2[i];
|
|
for (let j = 0; j < 4; j++) {
|
|
const cell = row[j] || (row[j] = {
|
|
row: i,
|
|
column: j,
|
|
type: "normal",
|
|
inRange: false,
|
|
start: false,
|
|
end: false,
|
|
text: -1,
|
|
disabled: false
|
|
});
|
|
cell.type = "normal";
|
|
const index = i * 4 + j;
|
|
const calTime = props2.date.startOf("year").month(index);
|
|
const calEndDate = props2.rangeState.endDate || props2.maxDate || props2.rangeState.selecting && props2.minDate || null;
|
|
cell.inRange = !!(props2.minDate && calTime.isSameOrAfter(props2.minDate, "month") && calEndDate && calTime.isSameOrBefore(calEndDate, "month")) || !!(props2.minDate && calTime.isSameOrBefore(props2.minDate, "month") && calEndDate && calTime.isSameOrAfter(calEndDate, "month"));
|
|
if ((_a2 = props2.minDate) == null ? void 0 : _a2.isSameOrAfter(calEndDate)) {
|
|
cell.start = !!(calEndDate && calTime.isSame(calEndDate, "month"));
|
|
cell.end = props2.minDate && calTime.isSame(props2.minDate, "month");
|
|
} else {
|
|
cell.start = !!(props2.minDate && calTime.isSame(props2.minDate, "month"));
|
|
cell.end = !!(calEndDate && calTime.isSame(calEndDate, "month"));
|
|
}
|
|
const isToday = now2.isSame(calTime);
|
|
if (isToday) {
|
|
cell.type = "today";
|
|
}
|
|
cell.text = index;
|
|
cell.disabled = ((_b = props2.disabledDate) == null ? void 0 : _b.call(props2, calTime.toDate())) || false;
|
|
}
|
|
}
|
|
return rows2;
|
|
});
|
|
const focus = () => {
|
|
var _a2;
|
|
(_a2 = currentCellRef.value) == null ? void 0 : _a2.focus();
|
|
};
|
|
const getCellStyle = (cell) => {
|
|
const style = {};
|
|
const year = props2.date.year();
|
|
const today = new Date();
|
|
const month = cell.text;
|
|
style.disabled = props2.disabledDate ? datesInMonth(props2.date, year, month, lang.value).every(props2.disabledDate) : false;
|
|
style.current = castArray2(props2.parsedValue).findIndex((date4) => import_dayjs9.default.isDayjs(date4) && date4.year() === year && date4.month() === month) >= 0;
|
|
style.today = today.getFullYear() === year && today.getMonth() === month;
|
|
if (cell.inRange) {
|
|
style["in-range"] = true;
|
|
if (cell.start) {
|
|
style["start-date"] = true;
|
|
}
|
|
if (cell.end) {
|
|
style["end-date"] = true;
|
|
}
|
|
}
|
|
return style;
|
|
};
|
|
const isSelectedCell = (cell) => {
|
|
const year = props2.date.year();
|
|
const month = cell.text;
|
|
return castArray2(props2.date).findIndex((date4) => date4.year() === year && date4.month() === month) >= 0;
|
|
};
|
|
const handleMouseMove = (event) => {
|
|
var _a2;
|
|
if (!props2.rangeState.selecting)
|
|
return;
|
|
let target2 = event.target;
|
|
if (target2.tagName === "SPAN") {
|
|
target2 = (_a2 = target2.parentNode) == null ? void 0 : _a2.parentNode;
|
|
}
|
|
if (target2.tagName === "DIV") {
|
|
target2 = target2.parentNode;
|
|
}
|
|
if (target2.tagName !== "TD")
|
|
return;
|
|
const row = target2.parentNode.rowIndex;
|
|
const column2 = target2.cellIndex;
|
|
if (rows.value[row][column2].disabled)
|
|
return;
|
|
if (row !== lastRow.value || column2 !== lastColumn.value) {
|
|
lastRow.value = row;
|
|
lastColumn.value = column2;
|
|
emit("changerange", {
|
|
selecting: true,
|
|
endDate: props2.date.startOf("year").month(row * 4 + column2)
|
|
});
|
|
}
|
|
};
|
|
const handleMonthTableClick = (event) => {
|
|
var _a2;
|
|
const target2 = (_a2 = event.target) == null ? void 0 : _a2.closest("td");
|
|
if ((target2 == null ? void 0 : target2.tagName) !== "TD")
|
|
return;
|
|
if (hasClass(target2, "disabled"))
|
|
return;
|
|
const column2 = target2.cellIndex;
|
|
const row = target2.parentNode.rowIndex;
|
|
const month = row * 4 + column2;
|
|
const newDate = props2.date.startOf("year").month(month);
|
|
if (props2.selectionMode === "months") {
|
|
if (event.type === "keydown") {
|
|
emit("pick", castArray2(props2.parsedValue), false);
|
|
return;
|
|
}
|
|
const newMonth = getValidDateOfMonth(props2.date, props2.date.year(), month, lang.value, props2.disabledDate);
|
|
const newValue = hasClass(target2, "current") ? castArray2(props2.parsedValue).filter((d2) => (d2 == null ? void 0 : d2.year()) !== newMonth.year() || (d2 == null ? void 0 : d2.month()) !== newMonth.month()) : castArray2(props2.parsedValue).concat([(0, import_dayjs9.default)(newMonth)]);
|
|
emit("pick", newValue);
|
|
} else if (props2.selectionMode === "range") {
|
|
if (!props2.rangeState.selecting) {
|
|
emit("pick", { minDate: newDate, maxDate: null });
|
|
emit("select", true);
|
|
} else {
|
|
if (props2.minDate && newDate >= props2.minDate) {
|
|
emit("pick", { minDate: props2.minDate, maxDate: newDate });
|
|
} else {
|
|
emit("pick", { minDate: newDate, maxDate: props2.minDate });
|
|
}
|
|
emit("select", false);
|
|
}
|
|
} else {
|
|
emit("pick", month);
|
|
}
|
|
};
|
|
watch(() => props2.date, async () => {
|
|
var _a2, _b;
|
|
if ((_a2 = tbodyRef.value) == null ? void 0 : _a2.contains(document.activeElement)) {
|
|
await nextTick();
|
|
(_b = currentCellRef.value) == null ? void 0 : _b.focus();
|
|
}
|
|
});
|
|
expose({
|
|
focus
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("table", {
|
|
role: "grid",
|
|
"aria-label": unref(t)("el.datepicker.monthTablePrompt"),
|
|
class: normalizeClass(unref(ns).b()),
|
|
onClick: handleMonthTableClick,
|
|
onMousemove: handleMouseMove
|
|
}, [
|
|
createBaseVNode("tbody", {
|
|
ref_key: "tbodyRef",
|
|
ref: tbodyRef
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(rows), (row, key) => {
|
|
return openBlock(), createElementBlock("tr", { key }, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(row, (cell, key_) => {
|
|
return openBlock(), createElementBlock("td", {
|
|
key: key_,
|
|
ref_for: true,
|
|
ref: (el) => isSelectedCell(cell) && (currentCellRef.value = el),
|
|
class: normalizeClass(getCellStyle(cell)),
|
|
"aria-selected": `${isSelectedCell(cell)}`,
|
|
"aria-label": unref(t)(`el.datepicker.month${+cell.text + 1}`),
|
|
tabindex: isSelectedCell(cell) ? 0 : -1,
|
|
onKeydown: [
|
|
withKeys(withModifiers(handleMonthTableClick, ["prevent", "stop"]), ["space"]),
|
|
withKeys(withModifiers(handleMonthTableClick, ["prevent", "stop"]), ["enter"])
|
|
]
|
|
}, [
|
|
createVNode(unref(ElDatePickerCell), {
|
|
cell: {
|
|
...cell,
|
|
renderText: unref(t)("el.datepicker.months." + months.value[cell.text])
|
|
}
|
|
}, null, 8, ["cell"])
|
|
], 42, ["aria-selected", "aria-label", "tabindex", "onKeydown"]);
|
|
}), 128))
|
|
]);
|
|
}), 128))
|
|
], 512)
|
|
], 42, ["aria-label"]);
|
|
};
|
|
}
|
|
});
|
|
var MonthTable = _export_sfc(_sfc_main62, [["__file", "basic-month-table.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/date-picker-com/basic-year-table.mjs
|
|
var import_dayjs10 = __toModule(require_dayjs_min());
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/props/basic-year-table.mjs
|
|
var basicYearTableProps = buildProps({
|
|
...datePickerSharedProps,
|
|
selectionMode: selectionModeWithDefault("year")
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/date-picker-com/basic-year-table.mjs
|
|
var _sfc_main63 = defineComponent({
|
|
__name: "basic-year-table",
|
|
props: basicYearTableProps,
|
|
emits: ["changerange", "pick", "select"],
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const datesInYear = (year, lang2) => {
|
|
const firstDay = (0, import_dayjs10.default)(String(year)).locale(lang2).startOf("year");
|
|
const lastDay = firstDay.endOf("year");
|
|
const numOfDays = lastDay.dayOfYear();
|
|
return rangeArr(numOfDays).map((n) => firstDay.add(n, "day").toDate());
|
|
};
|
|
const ns = useNamespace("year-table");
|
|
const { t, lang } = useLocale();
|
|
const tbodyRef = ref();
|
|
const currentCellRef = ref();
|
|
const startYear = computed(() => {
|
|
return Math.floor(props2.date.year() / 10) * 10;
|
|
});
|
|
const tableRows = ref([[], [], []]);
|
|
const lastRow = ref();
|
|
const lastColumn = ref();
|
|
const rows = computed(() => {
|
|
var _a2;
|
|
const rows2 = tableRows.value;
|
|
const now2 = (0, import_dayjs10.default)().locale(lang.value).startOf("year");
|
|
for (let i = 0; i < 3; i++) {
|
|
const row = rows2[i];
|
|
for (let j = 0; j < 4; j++) {
|
|
if (i * 4 + j >= 10) {
|
|
break;
|
|
}
|
|
let cell = row[j];
|
|
if (!cell) {
|
|
cell = {
|
|
row: i,
|
|
column: j,
|
|
type: "normal",
|
|
inRange: false,
|
|
start: false,
|
|
end: false,
|
|
text: -1,
|
|
disabled: false
|
|
};
|
|
}
|
|
cell.type = "normal";
|
|
const index = i * 4 + j + startYear.value;
|
|
const calTime = (0, import_dayjs10.default)().year(index);
|
|
const calEndDate = props2.rangeState.endDate || props2.maxDate || props2.rangeState.selecting && props2.minDate || null;
|
|
cell.inRange = !!(props2.minDate && calTime.isSameOrAfter(props2.minDate, "year") && calEndDate && calTime.isSameOrBefore(calEndDate, "year")) || !!(props2.minDate && calTime.isSameOrBefore(props2.minDate, "year") && calEndDate && calTime.isSameOrAfter(calEndDate, "year"));
|
|
if ((_a2 = props2.minDate) == null ? void 0 : _a2.isSameOrAfter(calEndDate)) {
|
|
cell.start = !!(calEndDate && calTime.isSame(calEndDate, "year"));
|
|
cell.end = !!(props2.minDate && calTime.isSame(props2.minDate, "year"));
|
|
} else {
|
|
cell.start = !!(props2.minDate && calTime.isSame(props2.minDate, "year"));
|
|
cell.end = !!(calEndDate && calTime.isSame(calEndDate, "year"));
|
|
}
|
|
const isToday = now2.isSame(calTime);
|
|
if (isToday) {
|
|
cell.type = "today";
|
|
}
|
|
cell.text = index;
|
|
const cellDate = calTime.toDate();
|
|
cell.disabled = props2.disabledDate && props2.disabledDate(cellDate) || false;
|
|
row[j] = cell;
|
|
}
|
|
}
|
|
return rows2;
|
|
});
|
|
const focus = () => {
|
|
var _a2;
|
|
(_a2 = currentCellRef.value) == null ? void 0 : _a2.focus();
|
|
};
|
|
const getCellKls = (cell) => {
|
|
const kls = {};
|
|
const today = (0, import_dayjs10.default)().locale(lang.value);
|
|
const year = cell.text;
|
|
kls.disabled = props2.disabledDate ? datesInYear(year, lang.value).every(props2.disabledDate) : false;
|
|
kls.today = today.year() === year;
|
|
kls.current = castArray2(props2.parsedValue).findIndex((d2) => d2.year() === year) >= 0;
|
|
if (cell.inRange) {
|
|
kls["in-range"] = true;
|
|
if (cell.start) {
|
|
kls["start-date"] = true;
|
|
}
|
|
if (cell.end) {
|
|
kls["end-date"] = true;
|
|
}
|
|
}
|
|
return kls;
|
|
};
|
|
const isSelectedCell = (cell) => {
|
|
const year = cell.text;
|
|
return castArray2(props2.date).findIndex((date4) => date4.year() === year) >= 0;
|
|
};
|
|
const handleYearTableClick = (event) => {
|
|
var _a2;
|
|
const target2 = (_a2 = event.target) == null ? void 0 : _a2.closest("td");
|
|
if (!target2 || !target2.textContent || hasClass(target2, "disabled"))
|
|
return;
|
|
const column2 = target2.cellIndex;
|
|
const row = target2.parentNode.rowIndex;
|
|
const selectedYear = row * 4 + column2 + startYear.value;
|
|
const newDate = (0, import_dayjs10.default)().year(selectedYear);
|
|
if (props2.selectionMode === "range") {
|
|
if (!props2.rangeState.selecting) {
|
|
emit("pick", { minDate: newDate, maxDate: null });
|
|
emit("select", true);
|
|
} else {
|
|
if (props2.minDate && newDate >= props2.minDate) {
|
|
emit("pick", { minDate: props2.minDate, maxDate: newDate });
|
|
} else {
|
|
emit("pick", { minDate: newDate, maxDate: props2.minDate });
|
|
}
|
|
emit("select", false);
|
|
}
|
|
} else if (props2.selectionMode === "years") {
|
|
if (event.type === "keydown") {
|
|
emit("pick", castArray2(props2.parsedValue), false);
|
|
return;
|
|
}
|
|
const vaildYear = getValidDateOfYear(newDate.startOf("year"), lang.value, props2.disabledDate);
|
|
const newValue = hasClass(target2, "current") ? castArray2(props2.parsedValue).filter((d2) => (d2 == null ? void 0 : d2.year()) !== selectedYear) : castArray2(props2.parsedValue).concat([vaildYear]);
|
|
emit("pick", newValue);
|
|
} else {
|
|
emit("pick", selectedYear);
|
|
}
|
|
};
|
|
const handleMouseMove = (event) => {
|
|
var _a2;
|
|
if (!props2.rangeState.selecting)
|
|
return;
|
|
const target2 = (_a2 = event.target) == null ? void 0 : _a2.closest("td");
|
|
if (!target2)
|
|
return;
|
|
const row = target2.parentNode.rowIndex;
|
|
const column2 = target2.cellIndex;
|
|
if (rows.value[row][column2].disabled)
|
|
return;
|
|
if (row !== lastRow.value || column2 !== lastColumn.value) {
|
|
lastRow.value = row;
|
|
lastColumn.value = column2;
|
|
emit("changerange", {
|
|
selecting: true,
|
|
endDate: (0, import_dayjs10.default)().year(startYear.value).add(row * 4 + column2, "year")
|
|
});
|
|
}
|
|
};
|
|
watch(() => props2.date, async () => {
|
|
var _a2, _b;
|
|
if ((_a2 = tbodyRef.value) == null ? void 0 : _a2.contains(document.activeElement)) {
|
|
await nextTick();
|
|
(_b = currentCellRef.value) == null ? void 0 : _b.focus();
|
|
}
|
|
});
|
|
expose({
|
|
focus
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("table", {
|
|
role: "grid",
|
|
"aria-label": unref(t)("el.datepicker.yearTablePrompt"),
|
|
class: normalizeClass(unref(ns).b()),
|
|
onClick: handleYearTableClick,
|
|
onMousemove: handleMouseMove
|
|
}, [
|
|
createBaseVNode("tbody", {
|
|
ref_key: "tbodyRef",
|
|
ref: tbodyRef
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(rows), (row, rowKey2) => {
|
|
return openBlock(), createElementBlock("tr", { key: rowKey2 }, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(row, (cell, cellKey) => {
|
|
return openBlock(), createElementBlock("td", {
|
|
key: `${rowKey2}_${cellKey}`,
|
|
ref_for: true,
|
|
ref: (el) => isSelectedCell(cell) && (currentCellRef.value = el),
|
|
class: normalizeClass(["available", getCellKls(cell)]),
|
|
"aria-selected": isSelectedCell(cell),
|
|
"aria-label": String(cell.text),
|
|
tabindex: isSelectedCell(cell) ? 0 : -1,
|
|
onKeydown: [
|
|
withKeys(withModifiers(handleYearTableClick, ["prevent", "stop"]), ["space"]),
|
|
withKeys(withModifiers(handleYearTableClick, ["prevent", "stop"]), ["enter"])
|
|
]
|
|
}, [
|
|
createVNode(unref(ElDatePickerCell), { cell }, null, 8, ["cell"])
|
|
], 42, ["aria-selected", "aria-label", "tabindex", "onKeydown"]);
|
|
}), 128))
|
|
]);
|
|
}), 128))
|
|
], 512)
|
|
], 42, ["aria-label"]);
|
|
};
|
|
}
|
|
});
|
|
var YearTable = _export_sfc(_sfc_main63, [["__file", "basic-year-table.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/date-picker-com/panel-date-pick.mjs
|
|
var _sfc_main64 = defineComponent({
|
|
__name: "panel-date-pick",
|
|
props: panelDatePickProps,
|
|
emits: ["pick", "set-picker-option", "panel-change"],
|
|
setup(__props, { emit: contextEmit }) {
|
|
const props2 = __props;
|
|
const timeWithinRange = (_2, __, ___) => true;
|
|
const ppNs = useNamespace("picker-panel");
|
|
const dpNs = useNamespace("date-picker");
|
|
const attrs = useAttrs();
|
|
const slots = useSlots();
|
|
const { t, lang } = useLocale();
|
|
const pickerBase = inject("EP_PICKER_BASE");
|
|
const isDefaultFormat = inject("ElIsDefaultFormat");
|
|
const popper = inject(TOOLTIP_INJECTION_KEY);
|
|
const { shortcuts, disabledDate, cellClassName, defaultTime } = pickerBase.props;
|
|
const defaultValue = toRef(pickerBase.props, "defaultValue");
|
|
const currentViewRef = ref();
|
|
const innerDate = ref((0, import_dayjs11.default)().locale(lang.value));
|
|
const isChangeToNow = ref(false);
|
|
let isShortcut = false;
|
|
const defaultTimeD = computed(() => {
|
|
return (0, import_dayjs11.default)(defaultTime).locale(lang.value);
|
|
});
|
|
const month = computed(() => {
|
|
return innerDate.value.month();
|
|
});
|
|
const year = computed(() => {
|
|
return innerDate.value.year();
|
|
});
|
|
const selectableRange = ref([]);
|
|
const userInputDate = ref(null);
|
|
const userInputTime = ref(null);
|
|
const checkDateWithinRange = (date4) => {
|
|
return selectableRange.value.length > 0 ? timeWithinRange(date4, selectableRange.value, props2.format || "HH:mm:ss") : true;
|
|
};
|
|
const formatEmit = (emitDayjs) => {
|
|
if (defaultTime && !visibleTime.value && !isChangeToNow.value && !isShortcut) {
|
|
return defaultTimeD.value.year(emitDayjs.year()).month(emitDayjs.month()).date(emitDayjs.date());
|
|
}
|
|
if (showTime.value)
|
|
return emitDayjs.millisecond(0);
|
|
return emitDayjs.startOf("day");
|
|
};
|
|
const emit = (value, ...args) => {
|
|
if (!value) {
|
|
contextEmit("pick", value, ...args);
|
|
} else if (isArray(value)) {
|
|
const dates = value.map(formatEmit);
|
|
contextEmit("pick", dates, ...args);
|
|
} else {
|
|
contextEmit("pick", formatEmit(value), ...args);
|
|
}
|
|
userInputDate.value = null;
|
|
userInputTime.value = null;
|
|
isChangeToNow.value = false;
|
|
isShortcut = false;
|
|
};
|
|
const handleDatePick = async (value, keepOpen) => {
|
|
if (selectionMode.value === "date") {
|
|
value = value;
|
|
let newDate = props2.parsedValue ? props2.parsedValue.year(value.year()).month(value.month()).date(value.date()) : value;
|
|
if (!checkDateWithinRange(newDate)) {
|
|
newDate = selectableRange.value[0][0].year(value.year()).month(value.month()).date(value.date());
|
|
}
|
|
innerDate.value = newDate;
|
|
emit(newDate, showTime.value || keepOpen);
|
|
if (props2.type === "datetime") {
|
|
await nextTick();
|
|
handleFocusPicker();
|
|
}
|
|
} else if (selectionMode.value === "week") {
|
|
emit(value.date);
|
|
} else if (selectionMode.value === "dates") {
|
|
emit(value, true);
|
|
}
|
|
};
|
|
const moveByMonth = (forward) => {
|
|
const action = forward ? "add" : "subtract";
|
|
innerDate.value = innerDate.value[action](1, "month");
|
|
handlePanelChange("month");
|
|
};
|
|
const moveByYear = (forward) => {
|
|
const currentDate = innerDate.value;
|
|
const action = forward ? "add" : "subtract";
|
|
innerDate.value = currentView.value === "year" ? currentDate[action](10, "year") : currentDate[action](1, "year");
|
|
handlePanelChange("year");
|
|
};
|
|
const currentView = ref("date");
|
|
const yearLabel = computed(() => {
|
|
const yearTranslation = t("el.datepicker.year");
|
|
if (currentView.value === "year") {
|
|
const startYear = Math.floor(year.value / 10) * 10;
|
|
if (yearTranslation) {
|
|
return `${startYear} ${yearTranslation} - ${startYear + 9} ${yearTranslation}`;
|
|
}
|
|
return `${startYear} - ${startYear + 9}`;
|
|
}
|
|
return `${year.value} ${yearTranslation}`;
|
|
});
|
|
const handleShortcutClick = (shortcut) => {
|
|
const shortcutValue = isFunction(shortcut.value) ? shortcut.value() : shortcut.value;
|
|
if (shortcutValue) {
|
|
isShortcut = true;
|
|
emit((0, import_dayjs11.default)(shortcutValue).locale(lang.value));
|
|
return;
|
|
}
|
|
if (shortcut.onClick) {
|
|
shortcut.onClick({
|
|
attrs,
|
|
slots,
|
|
emit: contextEmit
|
|
});
|
|
}
|
|
};
|
|
const selectionMode = computed(() => {
|
|
const { type: type4 } = props2;
|
|
if (["week", "month", "months", "year", "years", "dates"].includes(type4))
|
|
return type4;
|
|
return "date";
|
|
});
|
|
const isMultipleType = computed(() => {
|
|
return selectionMode.value === "dates" || selectionMode.value === "months" || selectionMode.value === "years";
|
|
});
|
|
const keyboardMode = computed(() => {
|
|
return selectionMode.value === "date" ? currentView.value : selectionMode.value;
|
|
});
|
|
const hasShortcuts = computed(() => !!shortcuts.length);
|
|
const handleMonthPick = async (month2, keepOpen) => {
|
|
if (selectionMode.value === "month") {
|
|
innerDate.value = getValidDateOfMonth(innerDate.value, innerDate.value.year(), month2, lang.value, disabledDate);
|
|
emit(innerDate.value, false);
|
|
} else if (selectionMode.value === "months") {
|
|
emit(month2, keepOpen != null ? keepOpen : true);
|
|
} else {
|
|
innerDate.value = getValidDateOfMonth(innerDate.value, innerDate.value.year(), month2, lang.value, disabledDate);
|
|
currentView.value = "date";
|
|
if (["month", "year", "date", "week"].includes(selectionMode.value)) {
|
|
emit(innerDate.value, true);
|
|
await nextTick();
|
|
handleFocusPicker();
|
|
}
|
|
}
|
|
handlePanelChange("month");
|
|
};
|
|
const handleYearPick = async (year2, keepOpen) => {
|
|
if (selectionMode.value === "year") {
|
|
const data = innerDate.value.startOf("year").year(year2);
|
|
innerDate.value = getValidDateOfYear(data, lang.value, disabledDate);
|
|
emit(innerDate.value, false);
|
|
} else if (selectionMode.value === "years") {
|
|
emit(year2, keepOpen != null ? keepOpen : true);
|
|
} else {
|
|
const data = innerDate.value.year(year2);
|
|
innerDate.value = getValidDateOfYear(data, lang.value, disabledDate);
|
|
currentView.value = "month";
|
|
if (["month", "year", "date", "week"].includes(selectionMode.value)) {
|
|
emit(innerDate.value, true);
|
|
await nextTick();
|
|
handleFocusPicker();
|
|
}
|
|
}
|
|
handlePanelChange("year");
|
|
};
|
|
const showPicker = async (view) => {
|
|
currentView.value = view;
|
|
await nextTick();
|
|
handleFocusPicker();
|
|
};
|
|
const showTime = computed(() => props2.type === "datetime" || props2.type === "datetimerange");
|
|
const footerVisible = computed(() => {
|
|
const showDateFooter = showTime.value || selectionMode.value === "dates";
|
|
const showYearFooter = selectionMode.value === "years";
|
|
const showMonthFooter = selectionMode.value === "months";
|
|
const isDateView = currentView.value === "date";
|
|
const isYearView = currentView.value === "year";
|
|
const isMonthView = currentView.value === "month";
|
|
return showDateFooter && isDateView || showYearFooter && isYearView || showMonthFooter && isMonthView;
|
|
});
|
|
const disabledConfirm = computed(() => {
|
|
if (!disabledDate)
|
|
return false;
|
|
if (!props2.parsedValue)
|
|
return true;
|
|
if (isArray(props2.parsedValue)) {
|
|
return disabledDate(props2.parsedValue[0].toDate());
|
|
}
|
|
return disabledDate(props2.parsedValue.toDate());
|
|
});
|
|
const onConfirm = () => {
|
|
if (isMultipleType.value) {
|
|
emit(props2.parsedValue);
|
|
} else {
|
|
let result2 = props2.parsedValue;
|
|
if (!result2) {
|
|
const defaultTimeD2 = (0, import_dayjs11.default)(defaultTime).locale(lang.value);
|
|
const defaultValueD = getDefaultValue2();
|
|
result2 = defaultTimeD2.year(defaultValueD.year()).month(defaultValueD.month()).date(defaultValueD.date());
|
|
}
|
|
innerDate.value = result2;
|
|
emit(result2);
|
|
}
|
|
};
|
|
const disabledNow = computed(() => {
|
|
if (!disabledDate)
|
|
return false;
|
|
return disabledDate((0, import_dayjs11.default)().locale(lang.value).toDate());
|
|
});
|
|
const changeToNow = () => {
|
|
const now2 = (0, import_dayjs11.default)().locale(lang.value);
|
|
const nowDate = now2.toDate();
|
|
isChangeToNow.value = true;
|
|
if ((!disabledDate || !disabledDate(nowDate)) && checkDateWithinRange(nowDate)) {
|
|
innerDate.value = (0, import_dayjs11.default)().locale(lang.value);
|
|
emit(innerDate.value);
|
|
}
|
|
};
|
|
const timeFormat = computed(() => {
|
|
return props2.timeFormat || extractTimeFormat(props2.format);
|
|
});
|
|
const dateFormat = computed(() => {
|
|
return props2.dateFormat || extractDateFormat(props2.format);
|
|
});
|
|
const visibleTime = computed(() => {
|
|
if (userInputTime.value)
|
|
return userInputTime.value;
|
|
if (!props2.parsedValue && !defaultValue.value)
|
|
return;
|
|
return (props2.parsedValue || innerDate.value).format(timeFormat.value);
|
|
});
|
|
const visibleDate = computed(() => {
|
|
if (userInputDate.value)
|
|
return userInputDate.value;
|
|
if (!props2.parsedValue && !defaultValue.value)
|
|
return;
|
|
return (props2.parsedValue || innerDate.value).format(dateFormat.value);
|
|
});
|
|
const timePickerVisible = ref(false);
|
|
const onTimePickerInputFocus = () => {
|
|
timePickerVisible.value = true;
|
|
};
|
|
const handleTimePickClose = () => {
|
|
timePickerVisible.value = false;
|
|
};
|
|
const getUnits = (date4) => {
|
|
return {
|
|
hour: date4.hour(),
|
|
minute: date4.minute(),
|
|
second: date4.second(),
|
|
year: date4.year(),
|
|
month: date4.month(),
|
|
date: date4.date()
|
|
};
|
|
};
|
|
const handleTimePick = (value, visible, first) => {
|
|
const { hour, minute, second } = getUnits(value);
|
|
const newDate = props2.parsedValue ? props2.parsedValue.hour(hour).minute(minute).second(second) : value;
|
|
innerDate.value = newDate;
|
|
emit(innerDate.value, true);
|
|
if (!first) {
|
|
timePickerVisible.value = visible;
|
|
}
|
|
};
|
|
const handleVisibleTimeChange = (value) => {
|
|
const newDate = (0, import_dayjs11.default)(value, timeFormat.value).locale(lang.value);
|
|
if (newDate.isValid() && checkDateWithinRange(newDate)) {
|
|
const { year: year2, month: month2, date: date4 } = getUnits(innerDate.value);
|
|
innerDate.value = newDate.year(year2).month(month2).date(date4);
|
|
userInputTime.value = null;
|
|
timePickerVisible.value = false;
|
|
emit(innerDate.value, true);
|
|
}
|
|
};
|
|
const handleVisibleDateChange = (value) => {
|
|
const newDate = correctlyParseUserInput(value, dateFormat.value, lang.value, isDefaultFormat);
|
|
if (newDate.isValid()) {
|
|
if (disabledDate && disabledDate(newDate.toDate())) {
|
|
return;
|
|
}
|
|
const { hour, minute, second } = getUnits(innerDate.value);
|
|
innerDate.value = newDate.hour(hour).minute(minute).second(second);
|
|
userInputDate.value = null;
|
|
emit(innerDate.value, true);
|
|
}
|
|
};
|
|
const isValidValue3 = (date4) => {
|
|
return import_dayjs11.default.isDayjs(date4) && date4.isValid() && (disabledDate ? !disabledDate(date4.toDate()) : true);
|
|
};
|
|
const formatToString = (value) => {
|
|
return isArray(value) ? value.map((_2) => _2.format(props2.format)) : value.format(props2.format);
|
|
};
|
|
const parseUserInput = (value) => {
|
|
return correctlyParseUserInput(value, props2.format, lang.value, isDefaultFormat);
|
|
};
|
|
const getDefaultValue2 = () => {
|
|
const parseDate2 = (0, import_dayjs11.default)(defaultValue.value).locale(lang.value);
|
|
if (!defaultValue.value) {
|
|
const defaultTimeDValue = defaultTimeD.value;
|
|
return (0, import_dayjs11.default)().hour(defaultTimeDValue.hour()).minute(defaultTimeDValue.minute()).second(defaultTimeDValue.second()).locale(lang.value);
|
|
}
|
|
return parseDate2;
|
|
};
|
|
const handleFocusPicker = () => {
|
|
var _a2;
|
|
if (["week", "month", "year", "date"].includes(selectionMode.value)) {
|
|
(_a2 = currentViewRef.value) == null ? void 0 : _a2.focus();
|
|
}
|
|
};
|
|
const _handleFocusPicker = () => {
|
|
handleFocusPicker();
|
|
if (selectionMode.value === "week") {
|
|
handleKeyControl(EVENT_CODE.down);
|
|
}
|
|
};
|
|
const handleKeydownTable = (event) => {
|
|
const { code } = event;
|
|
const validCode = [
|
|
EVENT_CODE.up,
|
|
EVENT_CODE.down,
|
|
EVENT_CODE.left,
|
|
EVENT_CODE.right,
|
|
EVENT_CODE.home,
|
|
EVENT_CODE.end,
|
|
EVENT_CODE.pageUp,
|
|
EVENT_CODE.pageDown
|
|
];
|
|
if (validCode.includes(code)) {
|
|
handleKeyControl(code);
|
|
event.stopPropagation();
|
|
event.preventDefault();
|
|
}
|
|
if ([EVENT_CODE.enter, EVENT_CODE.space, EVENT_CODE.numpadEnter].includes(code) && userInputDate.value === null && userInputTime.value === null) {
|
|
event.preventDefault();
|
|
emit(innerDate.value, false);
|
|
}
|
|
};
|
|
const handleKeyControl = (code) => {
|
|
var _a2;
|
|
const { up, down, left, right, home, end, pageUp, pageDown } = EVENT_CODE;
|
|
const mapping = {
|
|
year: {
|
|
[up]: -4,
|
|
[down]: 4,
|
|
[left]: -1,
|
|
[right]: 1,
|
|
offset: (date4, step) => date4.setFullYear(date4.getFullYear() + step)
|
|
},
|
|
month: {
|
|
[up]: -4,
|
|
[down]: 4,
|
|
[left]: -1,
|
|
[right]: 1,
|
|
offset: (date4, step) => date4.setMonth(date4.getMonth() + step)
|
|
},
|
|
week: {
|
|
[up]: -1,
|
|
[down]: 1,
|
|
[left]: -1,
|
|
[right]: 1,
|
|
offset: (date4, step) => date4.setDate(date4.getDate() + step * 7)
|
|
},
|
|
date: {
|
|
[up]: -7,
|
|
[down]: 7,
|
|
[left]: -1,
|
|
[right]: 1,
|
|
[home]: (date4) => -date4.getDay(),
|
|
[end]: (date4) => -date4.getDay() + 6,
|
|
[pageUp]: (date4) => -new Date(date4.getFullYear(), date4.getMonth(), 0).getDate(),
|
|
[pageDown]: (date4) => new Date(date4.getFullYear(), date4.getMonth() + 1, 0).getDate(),
|
|
offset: (date4, step) => date4.setDate(date4.getDate() + step)
|
|
}
|
|
};
|
|
const newDate = innerDate.value.toDate();
|
|
while (Math.abs(innerDate.value.diff(newDate, "year", true)) < 1) {
|
|
const map2 = mapping[keyboardMode.value];
|
|
if (!map2)
|
|
return;
|
|
map2.offset(newDate, isFunction(map2[code]) ? map2[code](newDate) : (_a2 = map2[code]) != null ? _a2 : 0);
|
|
if (disabledDate && disabledDate(newDate)) {
|
|
break;
|
|
}
|
|
const result2 = (0, import_dayjs11.default)(newDate).locale(lang.value);
|
|
innerDate.value = result2;
|
|
contextEmit("pick", result2, true);
|
|
break;
|
|
}
|
|
};
|
|
const handlePanelChange = (mode) => {
|
|
contextEmit("panel-change", innerDate.value.toDate(), mode, currentView.value);
|
|
};
|
|
watch(() => selectionMode.value, (val) => {
|
|
if (["month", "year"].includes(val)) {
|
|
currentView.value = val;
|
|
return;
|
|
} else if (val === "years") {
|
|
currentView.value = "year";
|
|
return;
|
|
} else if (val === "months") {
|
|
currentView.value = "month";
|
|
return;
|
|
}
|
|
currentView.value = "date";
|
|
}, { immediate: true });
|
|
watch(() => currentView.value, () => {
|
|
popper == null ? void 0 : popper.updatePopper();
|
|
});
|
|
watch(() => defaultValue.value, (val) => {
|
|
if (val) {
|
|
innerDate.value = getDefaultValue2();
|
|
}
|
|
}, { immediate: true });
|
|
watch(() => props2.parsedValue, (val) => {
|
|
if (val) {
|
|
if (isMultipleType.value)
|
|
return;
|
|
if (isArray(val))
|
|
return;
|
|
innerDate.value = val;
|
|
} else {
|
|
innerDate.value = getDefaultValue2();
|
|
}
|
|
}, { immediate: true });
|
|
contextEmit("set-picker-option", ["isValidValue", isValidValue3]);
|
|
contextEmit("set-picker-option", ["formatToString", formatToString]);
|
|
contextEmit("set-picker-option", ["parseUserInput", parseUserInput]);
|
|
contextEmit("set-picker-option", ["handleFocusPicker", _handleFocusPicker]);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([
|
|
unref(ppNs).b(),
|
|
unref(dpNs).b(),
|
|
{
|
|
"has-sidebar": _ctx.$slots.sidebar || unref(hasShortcuts),
|
|
"has-time": unref(showTime)
|
|
}
|
|
])
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ppNs).e("body-wrapper"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "sidebar", {
|
|
class: normalizeClass(unref(ppNs).e("sidebar"))
|
|
}),
|
|
unref(hasShortcuts) ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ppNs).e("sidebar"))
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(shortcuts), (shortcut, key) => {
|
|
return openBlock(), createElementBlock("button", {
|
|
key,
|
|
type: "button",
|
|
class: normalizeClass(unref(ppNs).e("shortcut")),
|
|
onClick: ($event) => handleShortcutClick(shortcut)
|
|
}, toDisplayString(shortcut.text), 11, ["onClick"]);
|
|
}), 128))
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ppNs).e("body"))
|
|
}, [
|
|
unref(showTime) ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(dpNs).e("time-header"))
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(dpNs).e("editor-wrap"))
|
|
}, [
|
|
createVNode(unref(ElInput), {
|
|
placeholder: unref(t)("el.datepicker.selectDate"),
|
|
"model-value": unref(visibleDate),
|
|
size: "small",
|
|
"validate-event": false,
|
|
onInput: (val) => userInputDate.value = val,
|
|
onChange: handleVisibleDateChange
|
|
}, null, 8, ["placeholder", "model-value", "onInput"])
|
|
], 2),
|
|
withDirectives((openBlock(), createElementBlock("span", {
|
|
class: normalizeClass(unref(dpNs).e("editor-wrap"))
|
|
}, [
|
|
createVNode(unref(ElInput), {
|
|
placeholder: unref(t)("el.datepicker.selectTime"),
|
|
"model-value": unref(visibleTime),
|
|
size: "small",
|
|
"validate-event": false,
|
|
onFocus: onTimePickerInputFocus,
|
|
onInput: (val) => userInputTime.value = val,
|
|
onChange: handleVisibleTimeChange
|
|
}, null, 8, ["placeholder", "model-value", "onInput"]),
|
|
createVNode(unref(TimePickPanel), {
|
|
visible: timePickerVisible.value,
|
|
format: unref(timeFormat),
|
|
"parsed-value": innerDate.value,
|
|
onPick: handleTimePick
|
|
}, null, 8, ["visible", "format", "parsed-value"])
|
|
], 2)), [
|
|
[unref(ClickOutside), handleTimePickClose]
|
|
])
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
withDirectives(createBaseVNode("div", {
|
|
class: normalizeClass([
|
|
unref(dpNs).e("header"),
|
|
(currentView.value === "year" || currentView.value === "month") && unref(dpNs).e("header--bordered")
|
|
])
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(dpNs).e("prev-btn"))
|
|
}, [
|
|
createBaseVNode("button", {
|
|
type: "button",
|
|
"aria-label": unref(t)(`el.datepicker.prevYear`),
|
|
class: normalizeClass(["d-arrow-left", unref(ppNs).e("icon-btn")]),
|
|
onClick: ($event) => moveByYear(false)
|
|
}, [
|
|
renderSlot(_ctx.$slots, "prev-year", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(d_arrow_left_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["aria-label", "onClick"]),
|
|
withDirectives(createBaseVNode("button", {
|
|
type: "button",
|
|
"aria-label": unref(t)(`el.datepicker.prevMonth`),
|
|
class: normalizeClass([unref(ppNs).e("icon-btn"), "arrow-left"]),
|
|
onClick: ($event) => moveByMonth(false)
|
|
}, [
|
|
renderSlot(_ctx.$slots, "prev-month", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(arrow_left_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["aria-label", "onClick"]), [
|
|
[vShow, currentView.value === "date"]
|
|
])
|
|
], 2),
|
|
createBaseVNode("span", {
|
|
role: "button",
|
|
class: normalizeClass(unref(dpNs).e("header-label")),
|
|
"aria-live": "polite",
|
|
tabindex: "0",
|
|
onKeydown: withKeys(($event) => showPicker("year"), ["enter"]),
|
|
onClick: ($event) => showPicker("year")
|
|
}, toDisplayString(unref(yearLabel)), 43, ["onKeydown", "onClick"]),
|
|
withDirectives(createBaseVNode("span", {
|
|
role: "button",
|
|
"aria-live": "polite",
|
|
tabindex: "0",
|
|
class: normalizeClass([
|
|
unref(dpNs).e("header-label"),
|
|
{ active: currentView.value === "month" }
|
|
]),
|
|
onKeydown: withKeys(($event) => showPicker("month"), ["enter"]),
|
|
onClick: ($event) => showPicker("month")
|
|
}, toDisplayString(unref(t)(`el.datepicker.month${unref(month) + 1}`)), 43, ["onKeydown", "onClick"]), [
|
|
[vShow, currentView.value === "date"]
|
|
]),
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(dpNs).e("next-btn"))
|
|
}, [
|
|
withDirectives(createBaseVNode("button", {
|
|
type: "button",
|
|
"aria-label": unref(t)(`el.datepicker.nextMonth`),
|
|
class: normalizeClass([unref(ppNs).e("icon-btn"), "arrow-right"]),
|
|
onClick: ($event) => moveByMonth(true)
|
|
}, [
|
|
renderSlot(_ctx.$slots, "next-month", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(arrow_right_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["aria-label", "onClick"]), [
|
|
[vShow, currentView.value === "date"]
|
|
]),
|
|
createBaseVNode("button", {
|
|
type: "button",
|
|
"aria-label": unref(t)(`el.datepicker.nextYear`),
|
|
class: normalizeClass([unref(ppNs).e("icon-btn"), "d-arrow-right"]),
|
|
onClick: ($event) => moveByYear(true)
|
|
}, [
|
|
renderSlot(_ctx.$slots, "next-year", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(d_arrow_right_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["aria-label", "onClick"])
|
|
], 2)
|
|
], 2), [
|
|
[vShow, currentView.value !== "time"]
|
|
]),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ppNs).e("content")),
|
|
onKeydown: handleKeydownTable
|
|
}, [
|
|
currentView.value === "date" ? (openBlock(), createBlock(DateTable2, {
|
|
key: 0,
|
|
ref_key: "currentViewRef",
|
|
ref: currentViewRef,
|
|
"selection-mode": unref(selectionMode),
|
|
date: innerDate.value,
|
|
"parsed-value": _ctx.parsedValue,
|
|
"disabled-date": unref(disabledDate),
|
|
"cell-class-name": unref(cellClassName),
|
|
onPick: handleDatePick
|
|
}, null, 8, ["selection-mode", "date", "parsed-value", "disabled-date", "cell-class-name"])) : createCommentVNode("v-if", true),
|
|
currentView.value === "year" ? (openBlock(), createBlock(YearTable, {
|
|
key: 1,
|
|
ref_key: "currentViewRef",
|
|
ref: currentViewRef,
|
|
"selection-mode": unref(selectionMode),
|
|
date: innerDate.value,
|
|
"disabled-date": unref(disabledDate),
|
|
"parsed-value": _ctx.parsedValue,
|
|
onPick: handleYearPick
|
|
}, null, 8, ["selection-mode", "date", "disabled-date", "parsed-value"])) : createCommentVNode("v-if", true),
|
|
currentView.value === "month" ? (openBlock(), createBlock(MonthTable, {
|
|
key: 2,
|
|
ref_key: "currentViewRef",
|
|
ref: currentViewRef,
|
|
"selection-mode": unref(selectionMode),
|
|
date: innerDate.value,
|
|
"parsed-value": _ctx.parsedValue,
|
|
"disabled-date": unref(disabledDate),
|
|
onPick: handleMonthPick
|
|
}, null, 8, ["selection-mode", "date", "parsed-value", "disabled-date"])) : createCommentVNode("v-if", true)
|
|
], 34)
|
|
], 2)
|
|
], 2),
|
|
withDirectives(createBaseVNode("div", {
|
|
class: normalizeClass(unref(ppNs).e("footer"))
|
|
}, [
|
|
withDirectives(createVNode(unref(ElButton), {
|
|
text: "",
|
|
size: "small",
|
|
class: normalizeClass(unref(ppNs).e("link-btn")),
|
|
disabled: unref(disabledNow),
|
|
onClick: changeToNow
|
|
}, {
|
|
default: withCtx(() => [
|
|
createTextVNode(toDisplayString(unref(t)("el.datepicker.now")), 1)
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "disabled"]), [
|
|
[vShow, !unref(isMultipleType) && _ctx.showNow]
|
|
]),
|
|
createVNode(unref(ElButton), {
|
|
plain: "",
|
|
size: "small",
|
|
class: normalizeClass(unref(ppNs).e("link-btn")),
|
|
disabled: unref(disabledConfirm),
|
|
onClick: onConfirm
|
|
}, {
|
|
default: withCtx(() => [
|
|
createTextVNode(toDisplayString(unref(t)("el.datepicker.confirm")), 1)
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "disabled"])
|
|
], 2), [
|
|
[vShow, unref(footerVisible)]
|
|
])
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var DatePickPanel = _export_sfc(_sfc_main64, [["__file", "panel-date-pick.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/date-picker-com/panel-date-range.mjs
|
|
var import_dayjs14 = __toModule(require_dayjs_min());
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/props/panel-date-range.mjs
|
|
var panelDateRangeProps = buildProps({
|
|
...panelSharedProps,
|
|
...panelRangeSharedProps,
|
|
visible: Boolean
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/composables/use-range-picker.mjs
|
|
var import_dayjs13 = __toModule(require_dayjs_min());
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/composables/use-shortcut.mjs
|
|
var import_dayjs12 = __toModule(require_dayjs_min());
|
|
var useShortcut = (lang) => {
|
|
const { emit } = getCurrentInstance();
|
|
const attrs = useAttrs();
|
|
const slots = useSlots();
|
|
const handleShortcutClick = (shortcut) => {
|
|
const shortcutValues = isFunction(shortcut.value) ? shortcut.value() : shortcut.value;
|
|
if (shortcutValues) {
|
|
emit("pick", [
|
|
(0, import_dayjs12.default)(shortcutValues[0]).locale(lang.value),
|
|
(0, import_dayjs12.default)(shortcutValues[1]).locale(lang.value)
|
|
]);
|
|
return;
|
|
}
|
|
if (shortcut.onClick) {
|
|
shortcut.onClick({
|
|
attrs,
|
|
slots,
|
|
emit
|
|
});
|
|
}
|
|
};
|
|
return handleShortcutClick;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/composables/use-range-picker.mjs
|
|
var useRangePicker = (props2, {
|
|
defaultValue,
|
|
defaultTime,
|
|
leftDate,
|
|
rightDate,
|
|
unit: unit4,
|
|
onParsedValueChanged
|
|
}) => {
|
|
const { emit } = getCurrentInstance();
|
|
const { pickerNs } = inject(ROOT_PICKER_INJECTION_KEY);
|
|
const drpNs = useNamespace("date-range-picker");
|
|
const { t, lang } = useLocale();
|
|
const handleShortcutClick = useShortcut(lang);
|
|
const minDate = ref();
|
|
const maxDate = ref();
|
|
const rangeState = ref({
|
|
endDate: null,
|
|
selecting: false
|
|
});
|
|
const handleChangeRange = (val) => {
|
|
rangeState.value = val;
|
|
};
|
|
const handleRangeConfirm = (visible = false) => {
|
|
const _minDate = unref(minDate);
|
|
const _maxDate = unref(maxDate);
|
|
if (isValidRange2([_minDate, _maxDate])) {
|
|
emit("pick", [_minDate, _maxDate], visible);
|
|
}
|
|
};
|
|
const onSelect = (selecting) => {
|
|
rangeState.value.selecting = selecting;
|
|
if (!selecting) {
|
|
rangeState.value.endDate = null;
|
|
}
|
|
};
|
|
const onReset = (parsedValue) => {
|
|
if (isArray(parsedValue) && parsedValue.length === 2) {
|
|
const [start, end] = parsedValue;
|
|
minDate.value = start;
|
|
leftDate.value = start;
|
|
maxDate.value = end;
|
|
onParsedValueChanged(unref(minDate), unref(maxDate));
|
|
} else {
|
|
restoreDefault();
|
|
}
|
|
};
|
|
const restoreDefault = () => {
|
|
let [start, end] = getDefaultValue(unref(defaultValue), {
|
|
lang: unref(lang),
|
|
unit: unit4,
|
|
unlinkPanels: props2.unlinkPanels
|
|
});
|
|
const getShift = (day) => {
|
|
return day.diff(day.startOf("d"), "ms");
|
|
};
|
|
const maybeTimes = unref(defaultTime);
|
|
if (maybeTimes) {
|
|
let leftShift = 0;
|
|
let rightShift = 0;
|
|
if (isArray(maybeTimes)) {
|
|
const [timeStart, timeEnd] = maybeTimes.map(import_dayjs13.default);
|
|
leftShift = getShift(timeStart);
|
|
rightShift = getShift(timeEnd);
|
|
} else {
|
|
const shift3 = getShift((0, import_dayjs13.default)(maybeTimes));
|
|
leftShift = shift3;
|
|
rightShift = shift3;
|
|
}
|
|
start = start.startOf("d").add(leftShift, "ms");
|
|
end = end.startOf("d").add(rightShift, "ms");
|
|
}
|
|
minDate.value = void 0;
|
|
maxDate.value = void 0;
|
|
leftDate.value = start;
|
|
rightDate.value = end;
|
|
};
|
|
watch(defaultValue, (val) => {
|
|
if (val) {
|
|
restoreDefault();
|
|
}
|
|
}, { immediate: true });
|
|
watch(() => props2.parsedValue, onReset, { immediate: true });
|
|
return {
|
|
minDate,
|
|
maxDate,
|
|
rangeState,
|
|
lang,
|
|
ppNs: pickerNs,
|
|
drpNs,
|
|
handleChangeRange,
|
|
handleRangeConfirm,
|
|
handleShortcutClick,
|
|
onSelect,
|
|
onReset,
|
|
t
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/composables/use-panel-date-range.mjs
|
|
var usePanelDateRange = (props2, emit, leftDate, rightDate) => {
|
|
const leftCurrentView = ref("date");
|
|
const leftCurrentViewRef = ref();
|
|
const rightCurrentView = ref("date");
|
|
const rightCurrentViewRef = ref();
|
|
const pickerBase = inject("EP_PICKER_BASE");
|
|
const { disabledDate } = pickerBase.props;
|
|
const { t, lang } = useLocale();
|
|
const leftYear = computed(() => {
|
|
return leftDate.value.year();
|
|
});
|
|
const leftMonth = computed(() => {
|
|
return leftDate.value.month();
|
|
});
|
|
const rightYear = computed(() => {
|
|
return rightDate.value.year();
|
|
});
|
|
const rightMonth = computed(() => {
|
|
return rightDate.value.month();
|
|
});
|
|
function computedYearLabel(currentView, yearValue) {
|
|
const yearTranslation = t("el.datepicker.year");
|
|
if (currentView.value === "year") {
|
|
const startYear = Math.floor(yearValue.value / 10) * 10;
|
|
return yearTranslation ? `${startYear} ${yearTranslation} - ${startYear + 9} ${yearTranslation}` : `${startYear} - ${startYear + 9}`;
|
|
}
|
|
return `${yearValue.value} ${yearTranslation}`;
|
|
}
|
|
function focusPicker(currentViewRef) {
|
|
currentViewRef == null ? void 0 : currentViewRef.focus();
|
|
}
|
|
async function showPicker(pickerType, view) {
|
|
const currentView = pickerType === "left" ? leftCurrentView : rightCurrentView;
|
|
const currentViewRef = pickerType === "left" ? leftCurrentViewRef : rightCurrentViewRef;
|
|
currentView.value = view;
|
|
await nextTick();
|
|
focusPicker(currentViewRef.value);
|
|
}
|
|
async function handlePick(mode, pickerType, value) {
|
|
const isLeftPicker = pickerType === "left";
|
|
const startDate = isLeftPicker ? leftDate : rightDate;
|
|
const endDate = isLeftPicker ? rightDate : leftDate;
|
|
const currentView = isLeftPicker ? leftCurrentView : rightCurrentView;
|
|
const currentViewRef = isLeftPicker ? leftCurrentViewRef : rightCurrentViewRef;
|
|
if (mode === "year") {
|
|
const data = startDate.value.year(value);
|
|
startDate.value = getValidDateOfYear(data, lang.value, disabledDate);
|
|
}
|
|
if (mode === "month") {
|
|
startDate.value = getValidDateOfMonth(startDate.value, startDate.value.year(), value, lang.value, disabledDate);
|
|
}
|
|
if (!props2.unlinkPanels) {
|
|
endDate.value = pickerType === "left" ? startDate.value.add(1, "month") : startDate.value.subtract(1, "month");
|
|
}
|
|
currentView.value = mode === "year" ? "month" : "date";
|
|
await nextTick();
|
|
focusPicker(currentViewRef.value);
|
|
handlePanelChange(mode);
|
|
}
|
|
function handlePanelChange(mode) {
|
|
emit("panel-change", [leftDate.value.toDate(), rightDate.value.toDate()], mode);
|
|
}
|
|
function adjustDateByView(currentView, date4, forward) {
|
|
const action = forward ? "add" : "subtract";
|
|
return currentView === "year" ? date4[action](10, "year") : date4[action](1, "year");
|
|
}
|
|
return {
|
|
leftCurrentView,
|
|
rightCurrentView,
|
|
leftCurrentViewRef,
|
|
rightCurrentViewRef,
|
|
leftYear,
|
|
rightYear,
|
|
leftMonth,
|
|
rightMonth,
|
|
leftYearLabel: computed(() => computedYearLabel(leftCurrentView, leftYear)),
|
|
rightYearLabel: computed(() => computedYearLabel(rightCurrentView, rightYear)),
|
|
showLeftPicker: (view) => showPicker("left", view),
|
|
showRightPicker: (view) => showPicker("right", view),
|
|
handleLeftYearPick: (year) => handlePick("year", "left", year),
|
|
handleRightYearPick: (year) => handlePick("year", "right", year),
|
|
handleLeftMonthPick: (month) => handlePick("month", "left", month),
|
|
handleRightMonthPick: (month) => handlePick("month", "right", month),
|
|
handlePanelChange,
|
|
adjustDateByView
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/date-picker-com/panel-date-range.mjs
|
|
var unit = "month";
|
|
var _sfc_main65 = defineComponent({
|
|
__name: "panel-date-range",
|
|
props: panelDateRangeProps,
|
|
emits: [
|
|
"pick",
|
|
"set-picker-option",
|
|
"calendar-change",
|
|
"panel-change"
|
|
],
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const pickerBase = inject("EP_PICKER_BASE");
|
|
const isDefaultFormat = inject("ElIsDefaultFormat");
|
|
const { disabledDate, cellClassName, defaultTime, clearable } = pickerBase.props;
|
|
const format2 = toRef(pickerBase.props, "format");
|
|
const shortcuts = toRef(pickerBase.props, "shortcuts");
|
|
const defaultValue = toRef(pickerBase.props, "defaultValue");
|
|
const { lang } = useLocale();
|
|
const leftDate = ref((0, import_dayjs14.default)().locale(lang.value));
|
|
const rightDate = ref((0, import_dayjs14.default)().locale(lang.value).add(1, unit));
|
|
const {
|
|
minDate,
|
|
maxDate,
|
|
rangeState,
|
|
ppNs,
|
|
drpNs,
|
|
handleChangeRange,
|
|
handleRangeConfirm,
|
|
handleShortcutClick,
|
|
onSelect,
|
|
onReset,
|
|
t
|
|
} = useRangePicker(props2, {
|
|
defaultValue,
|
|
defaultTime,
|
|
leftDate,
|
|
rightDate,
|
|
unit,
|
|
onParsedValueChanged
|
|
});
|
|
watch(() => props2.visible, (visible) => {
|
|
if (!visible && rangeState.value.selecting) {
|
|
onReset(props2.parsedValue);
|
|
onSelect(false);
|
|
}
|
|
});
|
|
const dateUserInput = ref({
|
|
min: null,
|
|
max: null
|
|
});
|
|
const timeUserInput = ref({
|
|
min: null,
|
|
max: null
|
|
});
|
|
const {
|
|
leftCurrentView,
|
|
rightCurrentView,
|
|
leftCurrentViewRef,
|
|
rightCurrentViewRef,
|
|
leftYear,
|
|
rightYear,
|
|
leftMonth,
|
|
rightMonth,
|
|
leftYearLabel,
|
|
rightYearLabel,
|
|
showLeftPicker,
|
|
showRightPicker,
|
|
handleLeftYearPick,
|
|
handleRightYearPick,
|
|
handleLeftMonthPick,
|
|
handleRightMonthPick,
|
|
handlePanelChange,
|
|
adjustDateByView
|
|
} = usePanelDateRange(props2, emit, leftDate, rightDate);
|
|
const hasShortcuts = computed(() => !!shortcuts.value.length);
|
|
const minVisibleDate = computed(() => {
|
|
if (dateUserInput.value.min !== null)
|
|
return dateUserInput.value.min;
|
|
if (minDate.value)
|
|
return minDate.value.format(dateFormat.value);
|
|
return "";
|
|
});
|
|
const maxVisibleDate = computed(() => {
|
|
if (dateUserInput.value.max !== null)
|
|
return dateUserInput.value.max;
|
|
if (maxDate.value || minDate.value)
|
|
return (maxDate.value || minDate.value).format(dateFormat.value);
|
|
return "";
|
|
});
|
|
const minVisibleTime = computed(() => {
|
|
if (timeUserInput.value.min !== null)
|
|
return timeUserInput.value.min;
|
|
if (minDate.value)
|
|
return minDate.value.format(timeFormat.value);
|
|
return "";
|
|
});
|
|
const maxVisibleTime = computed(() => {
|
|
if (timeUserInput.value.max !== null)
|
|
return timeUserInput.value.max;
|
|
if (maxDate.value || minDate.value)
|
|
return (maxDate.value || minDate.value).format(timeFormat.value);
|
|
return "";
|
|
});
|
|
const timeFormat = computed(() => {
|
|
return props2.timeFormat || extractTimeFormat(format2.value);
|
|
});
|
|
const dateFormat = computed(() => {
|
|
return props2.dateFormat || extractDateFormat(format2.value);
|
|
});
|
|
const isValidValue3 = (date4) => {
|
|
return isValidRange2(date4) && (disabledDate ? !disabledDate(date4[0].toDate()) && !disabledDate(date4[1].toDate()) : true);
|
|
};
|
|
const leftPrevYear = () => {
|
|
leftDate.value = adjustDateByView(leftCurrentView.value, leftDate.value, false);
|
|
if (!props2.unlinkPanels) {
|
|
rightDate.value = leftDate.value.add(1, "month");
|
|
}
|
|
handlePanelChange("year");
|
|
};
|
|
const leftPrevMonth = () => {
|
|
leftDate.value = leftDate.value.subtract(1, "month");
|
|
if (!props2.unlinkPanels) {
|
|
rightDate.value = leftDate.value.add(1, "month");
|
|
}
|
|
handlePanelChange("month");
|
|
};
|
|
const rightNextYear = () => {
|
|
if (!props2.unlinkPanels) {
|
|
leftDate.value = adjustDateByView(rightCurrentView.value, leftDate.value, true);
|
|
rightDate.value = leftDate.value.add(1, "month");
|
|
} else {
|
|
rightDate.value = adjustDateByView(rightCurrentView.value, rightDate.value, true);
|
|
}
|
|
handlePanelChange("year");
|
|
};
|
|
const rightNextMonth = () => {
|
|
if (!props2.unlinkPanels) {
|
|
leftDate.value = leftDate.value.add(1, "month");
|
|
rightDate.value = leftDate.value.add(1, "month");
|
|
} else {
|
|
rightDate.value = rightDate.value.add(1, "month");
|
|
}
|
|
handlePanelChange("month");
|
|
};
|
|
const leftNextYear = () => {
|
|
leftDate.value = adjustDateByView(leftCurrentView.value, leftDate.value, true);
|
|
handlePanelChange("year");
|
|
};
|
|
const leftNextMonth = () => {
|
|
leftDate.value = leftDate.value.add(1, "month");
|
|
handlePanelChange("month");
|
|
};
|
|
const rightPrevYear = () => {
|
|
rightDate.value = adjustDateByView(rightCurrentView.value, rightDate.value, false);
|
|
handlePanelChange("year");
|
|
};
|
|
const rightPrevMonth = () => {
|
|
rightDate.value = rightDate.value.subtract(1, "month");
|
|
handlePanelChange("month");
|
|
};
|
|
const enableMonthArrow = computed(() => {
|
|
const nextMonth = (leftMonth.value + 1) % 12;
|
|
const yearOffset = leftMonth.value + 1 >= 12 ? 1 : 0;
|
|
return props2.unlinkPanels && new Date(leftYear.value + yearOffset, nextMonth) < new Date(rightYear.value, rightMonth.value);
|
|
});
|
|
const enableYearArrow = computed(() => {
|
|
return props2.unlinkPanels && rightYear.value * 12 + rightMonth.value - (leftYear.value * 12 + leftMonth.value + 1) >= 12;
|
|
});
|
|
const btnDisabled = computed(() => {
|
|
return !(minDate.value && maxDate.value && !rangeState.value.selecting && isValidRange2([minDate.value, maxDate.value]));
|
|
});
|
|
const showTime = computed(() => props2.type === "datetime" || props2.type === "datetimerange");
|
|
const formatEmit = (emitDayjs, index) => {
|
|
if (!emitDayjs)
|
|
return;
|
|
if (defaultTime) {
|
|
const defaultTimeD = (0, import_dayjs14.default)(defaultTime[index] || defaultTime).locale(lang.value);
|
|
return defaultTimeD.year(emitDayjs.year()).month(emitDayjs.month()).date(emitDayjs.date());
|
|
}
|
|
return emitDayjs;
|
|
};
|
|
const handleRangePick = (val, close2 = true) => {
|
|
const min_ = val.minDate;
|
|
const max_ = val.maxDate;
|
|
const minDate_ = formatEmit(min_, 0);
|
|
const maxDate_ = formatEmit(max_, 1);
|
|
if (maxDate.value === maxDate_ && minDate.value === minDate_) {
|
|
return;
|
|
}
|
|
emit("calendar-change", [min_.toDate(), max_ && max_.toDate()]);
|
|
maxDate.value = maxDate_;
|
|
minDate.value = minDate_;
|
|
if (!close2 || showTime.value)
|
|
return;
|
|
handleRangeConfirm();
|
|
};
|
|
const minTimePickerVisible = ref(false);
|
|
const maxTimePickerVisible = ref(false);
|
|
const handleMinTimeClose = () => {
|
|
minTimePickerVisible.value = false;
|
|
};
|
|
const handleMaxTimeClose = () => {
|
|
maxTimePickerVisible.value = false;
|
|
};
|
|
const handleDateInput = (value, type4) => {
|
|
dateUserInput.value[type4] = value;
|
|
const parsedValueD = (0, import_dayjs14.default)(value, dateFormat.value).locale(lang.value);
|
|
if (parsedValueD.isValid()) {
|
|
if (disabledDate && disabledDate(parsedValueD.toDate())) {
|
|
return;
|
|
}
|
|
if (type4 === "min") {
|
|
leftDate.value = parsedValueD;
|
|
minDate.value = (minDate.value || leftDate.value).year(parsedValueD.year()).month(parsedValueD.month()).date(parsedValueD.date());
|
|
if (!props2.unlinkPanels && (!maxDate.value || maxDate.value.isBefore(minDate.value))) {
|
|
rightDate.value = parsedValueD.add(1, "month");
|
|
maxDate.value = minDate.value.add(1, "month");
|
|
}
|
|
} else {
|
|
rightDate.value = parsedValueD;
|
|
maxDate.value = (maxDate.value || rightDate.value).year(parsedValueD.year()).month(parsedValueD.month()).date(parsedValueD.date());
|
|
if (!props2.unlinkPanels && (!minDate.value || minDate.value.isAfter(maxDate.value))) {
|
|
leftDate.value = parsedValueD.subtract(1, "month");
|
|
minDate.value = maxDate.value.subtract(1, "month");
|
|
}
|
|
}
|
|
}
|
|
};
|
|
const handleDateChange = (_2, type4) => {
|
|
dateUserInput.value[type4] = null;
|
|
};
|
|
const handleTimeInput = (value, type4) => {
|
|
timeUserInput.value[type4] = value;
|
|
const parsedValueD = (0, import_dayjs14.default)(value, timeFormat.value).locale(lang.value);
|
|
if (parsedValueD.isValid()) {
|
|
if (type4 === "min") {
|
|
minTimePickerVisible.value = true;
|
|
minDate.value = (minDate.value || leftDate.value).hour(parsedValueD.hour()).minute(parsedValueD.minute()).second(parsedValueD.second());
|
|
} else {
|
|
maxTimePickerVisible.value = true;
|
|
maxDate.value = (maxDate.value || rightDate.value).hour(parsedValueD.hour()).minute(parsedValueD.minute()).second(parsedValueD.second());
|
|
rightDate.value = maxDate.value;
|
|
}
|
|
}
|
|
};
|
|
const handleTimeChange = (_value, type4) => {
|
|
timeUserInput.value[type4] = null;
|
|
if (type4 === "min") {
|
|
leftDate.value = minDate.value;
|
|
minTimePickerVisible.value = false;
|
|
if (!maxDate.value || maxDate.value.isBefore(minDate.value)) {
|
|
maxDate.value = minDate.value;
|
|
}
|
|
} else {
|
|
rightDate.value = maxDate.value;
|
|
maxTimePickerVisible.value = false;
|
|
if (maxDate.value && maxDate.value.isBefore(minDate.value)) {
|
|
minDate.value = maxDate.value;
|
|
}
|
|
}
|
|
};
|
|
const handleMinTimePick = (value, visible, first) => {
|
|
if (timeUserInput.value.min)
|
|
return;
|
|
if (value) {
|
|
leftDate.value = value;
|
|
minDate.value = (minDate.value || leftDate.value).hour(value.hour()).minute(value.minute()).second(value.second());
|
|
}
|
|
if (!first) {
|
|
minTimePickerVisible.value = visible;
|
|
}
|
|
if (!maxDate.value || maxDate.value.isBefore(minDate.value)) {
|
|
maxDate.value = minDate.value;
|
|
rightDate.value = value;
|
|
}
|
|
};
|
|
const handleMaxTimePick = (value, visible, first) => {
|
|
if (timeUserInput.value.max)
|
|
return;
|
|
if (value) {
|
|
rightDate.value = value;
|
|
maxDate.value = (maxDate.value || rightDate.value).hour(value.hour()).minute(value.minute()).second(value.second());
|
|
}
|
|
if (!first) {
|
|
maxTimePickerVisible.value = visible;
|
|
}
|
|
if (maxDate.value && maxDate.value.isBefore(minDate.value)) {
|
|
minDate.value = maxDate.value;
|
|
}
|
|
};
|
|
const handleClear = () => {
|
|
leftDate.value = getDefaultValue(unref(defaultValue), {
|
|
lang: unref(lang),
|
|
unit: "month",
|
|
unlinkPanels: props2.unlinkPanels
|
|
})[0];
|
|
rightDate.value = leftDate.value.add(1, "month");
|
|
maxDate.value = void 0;
|
|
minDate.value = void 0;
|
|
emit("pick", null);
|
|
};
|
|
const formatToString = (value) => {
|
|
return isArray(value) ? value.map((_2) => _2.format(format2.value)) : value.format(format2.value);
|
|
};
|
|
const parseUserInput = (value) => {
|
|
return correctlyParseUserInput(value, format2.value, lang.value, isDefaultFormat);
|
|
};
|
|
function onParsedValueChanged(minDate2, maxDate2) {
|
|
if (props2.unlinkPanels && maxDate2) {
|
|
const minDateYear = (minDate2 == null ? void 0 : minDate2.year()) || 0;
|
|
const minDateMonth = (minDate2 == null ? void 0 : minDate2.month()) || 0;
|
|
const maxDateYear = maxDate2.year();
|
|
const maxDateMonth = maxDate2.month();
|
|
rightDate.value = minDateYear === maxDateYear && minDateMonth === maxDateMonth ? maxDate2.add(1, unit) : maxDate2;
|
|
} else {
|
|
rightDate.value = leftDate.value.add(1, unit);
|
|
if (maxDate2) {
|
|
rightDate.value = rightDate.value.hour(maxDate2.hour()).minute(maxDate2.minute()).second(maxDate2.second());
|
|
}
|
|
}
|
|
}
|
|
emit("set-picker-option", ["isValidValue", isValidValue3]);
|
|
emit("set-picker-option", ["parseUserInput", parseUserInput]);
|
|
emit("set-picker-option", ["formatToString", formatToString]);
|
|
emit("set-picker-option", ["handleClear", handleClear]);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([
|
|
unref(ppNs).b(),
|
|
unref(drpNs).b(),
|
|
{
|
|
"has-sidebar": _ctx.$slots.sidebar || unref(hasShortcuts),
|
|
"has-time": unref(showTime)
|
|
}
|
|
])
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ppNs).e("body-wrapper"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "sidebar", {
|
|
class: normalizeClass(unref(ppNs).e("sidebar"))
|
|
}),
|
|
unref(hasShortcuts) ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ppNs).e("sidebar"))
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(shortcuts), (shortcut, key) => {
|
|
return openBlock(), createElementBlock("button", {
|
|
key,
|
|
type: "button",
|
|
class: normalizeClass(unref(ppNs).e("shortcut")),
|
|
onClick: ($event) => unref(handleShortcutClick)(shortcut)
|
|
}, toDisplayString(shortcut.text), 11, ["onClick"]);
|
|
}), 128))
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ppNs).e("body"))
|
|
}, [
|
|
unref(showTime) ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(drpNs).e("time-header"))
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(drpNs).e("editors-wrap"))
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(drpNs).e("time-picker-wrap"))
|
|
}, [
|
|
createVNode(unref(ElInput), {
|
|
size: "small",
|
|
disabled: unref(rangeState).selecting,
|
|
placeholder: unref(t)("el.datepicker.startDate"),
|
|
class: normalizeClass(unref(drpNs).e("editor")),
|
|
"model-value": unref(minVisibleDate),
|
|
"validate-event": false,
|
|
onInput: (val) => handleDateInput(val, "min"),
|
|
onChange: (val) => handleDateChange(val, "min")
|
|
}, null, 8, ["disabled", "placeholder", "class", "model-value", "onInput", "onChange"])
|
|
], 2),
|
|
withDirectives((openBlock(), createElementBlock("span", {
|
|
class: normalizeClass(unref(drpNs).e("time-picker-wrap"))
|
|
}, [
|
|
createVNode(unref(ElInput), {
|
|
size: "small",
|
|
class: normalizeClass(unref(drpNs).e("editor")),
|
|
disabled: unref(rangeState).selecting,
|
|
placeholder: unref(t)("el.datepicker.startTime"),
|
|
"model-value": unref(minVisibleTime),
|
|
"validate-event": false,
|
|
onFocus: ($event) => minTimePickerVisible.value = true,
|
|
onInput: (val) => handleTimeInput(val, "min"),
|
|
onChange: (val) => handleTimeChange(val, "min")
|
|
}, null, 8, ["class", "disabled", "placeholder", "model-value", "onFocus", "onInput", "onChange"]),
|
|
createVNode(unref(TimePickPanel), {
|
|
visible: minTimePickerVisible.value,
|
|
format: unref(timeFormat),
|
|
"datetime-role": "start",
|
|
"parsed-value": leftDate.value,
|
|
onPick: handleMinTimePick
|
|
}, null, 8, ["visible", "format", "parsed-value"])
|
|
], 2)), [
|
|
[unref(ClickOutside), handleMinTimeClose]
|
|
])
|
|
], 2),
|
|
createBaseVNode("span", null, [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(arrow_right_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
]),
|
|
createBaseVNode("span", {
|
|
class: normalizeClass([unref(drpNs).e("editors-wrap"), "is-right"])
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(drpNs).e("time-picker-wrap"))
|
|
}, [
|
|
createVNode(unref(ElInput), {
|
|
size: "small",
|
|
class: normalizeClass(unref(drpNs).e("editor")),
|
|
disabled: unref(rangeState).selecting,
|
|
placeholder: unref(t)("el.datepicker.endDate"),
|
|
"model-value": unref(maxVisibleDate),
|
|
readonly: !unref(minDate),
|
|
"validate-event": false,
|
|
onInput: (val) => handleDateInput(val, "max"),
|
|
onChange: (val) => handleDateChange(val, "max")
|
|
}, null, 8, ["class", "disabled", "placeholder", "model-value", "readonly", "onInput", "onChange"])
|
|
], 2),
|
|
withDirectives((openBlock(), createElementBlock("span", {
|
|
class: normalizeClass(unref(drpNs).e("time-picker-wrap"))
|
|
}, [
|
|
createVNode(unref(ElInput), {
|
|
size: "small",
|
|
class: normalizeClass(unref(drpNs).e("editor")),
|
|
disabled: unref(rangeState).selecting,
|
|
placeholder: unref(t)("el.datepicker.endTime"),
|
|
"model-value": unref(maxVisibleTime),
|
|
readonly: !unref(minDate),
|
|
"validate-event": false,
|
|
onFocus: ($event) => unref(minDate) && (maxTimePickerVisible.value = true),
|
|
onInput: (val) => handleTimeInput(val, "max"),
|
|
onChange: (val) => handleTimeChange(val, "max")
|
|
}, null, 8, ["class", "disabled", "placeholder", "model-value", "readonly", "onFocus", "onInput", "onChange"]),
|
|
createVNode(unref(TimePickPanel), {
|
|
"datetime-role": "end",
|
|
visible: maxTimePickerVisible.value,
|
|
format: unref(timeFormat),
|
|
"parsed-value": rightDate.value,
|
|
onPick: handleMaxTimePick
|
|
}, null, 8, ["visible", "format", "parsed-value"])
|
|
], 2)), [
|
|
[unref(ClickOutside), handleMaxTimeClose]
|
|
])
|
|
], 2)
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([[unref(ppNs).e("content"), unref(drpNs).e("content")], "is-left"])
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(drpNs).e("header"))
|
|
}, [
|
|
createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass([unref(ppNs).e("icon-btn"), "d-arrow-left"]),
|
|
"aria-label": unref(t)(`el.datepicker.prevYear`),
|
|
onClick: leftPrevYear
|
|
}, [
|
|
renderSlot(_ctx.$slots, "prev-year", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(d_arrow_left_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["aria-label"]),
|
|
withDirectives(createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass([unref(ppNs).e("icon-btn"), "arrow-left"]),
|
|
"aria-label": unref(t)(`el.datepicker.prevMonth`),
|
|
onClick: leftPrevMonth
|
|
}, [
|
|
renderSlot(_ctx.$slots, "prev-month", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(arrow_left_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["aria-label"]), [
|
|
[vShow, unref(leftCurrentView) === "date"]
|
|
]),
|
|
_ctx.unlinkPanels ? (openBlock(), createElementBlock("button", {
|
|
key: 0,
|
|
type: "button",
|
|
disabled: !unref(enableYearArrow),
|
|
class: normalizeClass([[unref(ppNs).e("icon-btn"), { "is-disabled": !unref(enableYearArrow) }], "d-arrow-right"]),
|
|
"aria-label": unref(t)(`el.datepicker.nextYear`),
|
|
onClick: leftNextYear
|
|
}, [
|
|
renderSlot(_ctx.$slots, "next-year", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(d_arrow_right_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["disabled", "aria-label"])) : createCommentVNode("v-if", true),
|
|
_ctx.unlinkPanels && unref(leftCurrentView) === "date" ? (openBlock(), createElementBlock("button", {
|
|
key: 1,
|
|
type: "button",
|
|
disabled: !unref(enableMonthArrow),
|
|
class: normalizeClass([[
|
|
unref(ppNs).e("icon-btn"),
|
|
{ "is-disabled": !unref(enableMonthArrow) }
|
|
], "arrow-right"]),
|
|
"aria-label": unref(t)(`el.datepicker.nextMonth`),
|
|
onClick: leftNextMonth
|
|
}, [
|
|
renderSlot(_ctx.$slots, "next-month", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(arrow_right_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["disabled", "aria-label"])) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", null, [
|
|
createBaseVNode("span", {
|
|
role: "button",
|
|
class: normalizeClass(unref(drpNs).e("header-label")),
|
|
"aria-live": "polite",
|
|
tabindex: "0",
|
|
onKeydown: withKeys(($event) => unref(showLeftPicker)("year"), ["enter"]),
|
|
onClick: ($event) => unref(showLeftPicker)("year")
|
|
}, toDisplayString(unref(leftYearLabel)), 43, ["onKeydown", "onClick"]),
|
|
withDirectives(createBaseVNode("span", {
|
|
role: "button",
|
|
"aria-live": "polite",
|
|
tabindex: "0",
|
|
class: normalizeClass([
|
|
unref(drpNs).e("header-label"),
|
|
{ active: unref(leftCurrentView) === "month" }
|
|
]),
|
|
onKeydown: withKeys(($event) => unref(showLeftPicker)("month"), ["enter"]),
|
|
onClick: ($event) => unref(showLeftPicker)("month")
|
|
}, toDisplayString(unref(t)(`el.datepicker.month${leftDate.value.month() + 1}`)), 43, ["onKeydown", "onClick"]), [
|
|
[vShow, unref(leftCurrentView) === "date"]
|
|
])
|
|
])
|
|
], 2),
|
|
unref(leftCurrentView) === "date" ? (openBlock(), createBlock(DateTable2, {
|
|
key: 0,
|
|
ref_key: "leftCurrentViewRef",
|
|
ref: leftCurrentViewRef,
|
|
"selection-mode": "range",
|
|
date: leftDate.value,
|
|
"min-date": unref(minDate),
|
|
"max-date": unref(maxDate),
|
|
"range-state": unref(rangeState),
|
|
"disabled-date": unref(disabledDate),
|
|
"cell-class-name": unref(cellClassName),
|
|
onChangerange: unref(handleChangeRange),
|
|
onPick: handleRangePick,
|
|
onSelect: unref(onSelect)
|
|
}, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "cell-class-name", "onChangerange", "onSelect"])) : createCommentVNode("v-if", true),
|
|
unref(leftCurrentView) === "year" ? (openBlock(), createBlock(YearTable, {
|
|
key: 1,
|
|
ref_key: "leftCurrentViewRef",
|
|
ref: leftCurrentViewRef,
|
|
"selection-mode": "year",
|
|
date: leftDate.value,
|
|
"disabled-date": unref(disabledDate),
|
|
"parsed-value": _ctx.parsedValue,
|
|
onPick: unref(handleLeftYearPick)
|
|
}, null, 8, ["date", "disabled-date", "parsed-value", "onPick"])) : createCommentVNode("v-if", true),
|
|
unref(leftCurrentView) === "month" ? (openBlock(), createBlock(MonthTable, {
|
|
key: 2,
|
|
ref_key: "leftCurrentViewRef",
|
|
ref: leftCurrentViewRef,
|
|
"selection-mode": "month",
|
|
date: leftDate.value,
|
|
"parsed-value": _ctx.parsedValue,
|
|
"disabled-date": unref(disabledDate),
|
|
onPick: unref(handleLeftMonthPick)
|
|
}, null, 8, ["date", "parsed-value", "disabled-date", "onPick"])) : createCommentVNode("v-if", true)
|
|
], 2),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([[unref(ppNs).e("content"), unref(drpNs).e("content")], "is-right"])
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(drpNs).e("header"))
|
|
}, [
|
|
_ctx.unlinkPanels ? (openBlock(), createElementBlock("button", {
|
|
key: 0,
|
|
type: "button",
|
|
disabled: !unref(enableYearArrow),
|
|
class: normalizeClass([[unref(ppNs).e("icon-btn"), { "is-disabled": !unref(enableYearArrow) }], "d-arrow-left"]),
|
|
"aria-label": unref(t)(`el.datepicker.prevYear`),
|
|
onClick: rightPrevYear
|
|
}, [
|
|
renderSlot(_ctx.$slots, "prev-year", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(d_arrow_left_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["disabled", "aria-label"])) : createCommentVNode("v-if", true),
|
|
_ctx.unlinkPanels && unref(rightCurrentView) === "date" ? (openBlock(), createElementBlock("button", {
|
|
key: 1,
|
|
type: "button",
|
|
disabled: !unref(enableMonthArrow),
|
|
class: normalizeClass([[
|
|
unref(ppNs).e("icon-btn"),
|
|
{ "is-disabled": !unref(enableMonthArrow) }
|
|
], "arrow-left"]),
|
|
"aria-label": unref(t)(`el.datepicker.prevMonth`),
|
|
onClick: rightPrevMonth
|
|
}, [
|
|
renderSlot(_ctx.$slots, "prev-month", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(arrow_left_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["disabled", "aria-label"])) : createCommentVNode("v-if", true),
|
|
createBaseVNode("button", {
|
|
type: "button",
|
|
"aria-label": unref(t)(`el.datepicker.nextYear`),
|
|
class: normalizeClass([unref(ppNs).e("icon-btn"), "d-arrow-right"]),
|
|
onClick: rightNextYear
|
|
}, [
|
|
renderSlot(_ctx.$slots, "next-year", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(d_arrow_right_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["aria-label"]),
|
|
withDirectives(createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass([unref(ppNs).e("icon-btn"), "arrow-right"]),
|
|
"aria-label": unref(t)(`el.datepicker.nextMonth`),
|
|
onClick: rightNextMonth
|
|
}, [
|
|
renderSlot(_ctx.$slots, "next-month", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(arrow_right_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["aria-label"]), [
|
|
[vShow, unref(rightCurrentView) === "date"]
|
|
]),
|
|
createBaseVNode("div", null, [
|
|
createBaseVNode("span", {
|
|
role: "button",
|
|
class: normalizeClass(unref(drpNs).e("header-label")),
|
|
"aria-live": "polite",
|
|
tabindex: "0",
|
|
onKeydown: withKeys(($event) => unref(showRightPicker)("year"), ["enter"]),
|
|
onClick: ($event) => unref(showRightPicker)("year")
|
|
}, toDisplayString(unref(rightYearLabel)), 43, ["onKeydown", "onClick"]),
|
|
withDirectives(createBaseVNode("span", {
|
|
role: "button",
|
|
"aria-live": "polite",
|
|
tabindex: "0",
|
|
class: normalizeClass([
|
|
unref(drpNs).e("header-label"),
|
|
{ active: unref(rightCurrentView) === "month" }
|
|
]),
|
|
onKeydown: withKeys(($event) => unref(showRightPicker)("month"), ["enter"]),
|
|
onClick: ($event) => unref(showRightPicker)("month")
|
|
}, toDisplayString(unref(t)(`el.datepicker.month${rightDate.value.month() + 1}`)), 43, ["onKeydown", "onClick"]), [
|
|
[vShow, unref(rightCurrentView) === "date"]
|
|
])
|
|
])
|
|
], 2),
|
|
unref(rightCurrentView) === "date" ? (openBlock(), createBlock(DateTable2, {
|
|
key: 0,
|
|
ref_key: "rightCurrentViewRef",
|
|
ref: rightCurrentViewRef,
|
|
"selection-mode": "range",
|
|
date: rightDate.value,
|
|
"min-date": unref(minDate),
|
|
"max-date": unref(maxDate),
|
|
"range-state": unref(rangeState),
|
|
"disabled-date": unref(disabledDate),
|
|
"cell-class-name": unref(cellClassName),
|
|
onChangerange: unref(handleChangeRange),
|
|
onPick: handleRangePick,
|
|
onSelect: unref(onSelect)
|
|
}, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "cell-class-name", "onChangerange", "onSelect"])) : createCommentVNode("v-if", true),
|
|
unref(rightCurrentView) === "year" ? (openBlock(), createBlock(YearTable, {
|
|
key: 1,
|
|
ref_key: "rightCurrentViewRef",
|
|
ref: rightCurrentViewRef,
|
|
"selection-mode": "year",
|
|
date: rightDate.value,
|
|
"disabled-date": unref(disabledDate),
|
|
"parsed-value": _ctx.parsedValue,
|
|
onPick: unref(handleRightYearPick)
|
|
}, null, 8, ["date", "disabled-date", "parsed-value", "onPick"])) : createCommentVNode("v-if", true),
|
|
unref(rightCurrentView) === "month" ? (openBlock(), createBlock(MonthTable, {
|
|
key: 2,
|
|
ref_key: "rightCurrentViewRef",
|
|
ref: rightCurrentViewRef,
|
|
"selection-mode": "month",
|
|
date: rightDate.value,
|
|
"parsed-value": _ctx.parsedValue,
|
|
"disabled-date": unref(disabledDate),
|
|
onPick: unref(handleRightMonthPick)
|
|
}, null, 8, ["date", "parsed-value", "disabled-date", "onPick"])) : createCommentVNode("v-if", true)
|
|
], 2)
|
|
], 2)
|
|
], 2),
|
|
unref(showTime) ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ppNs).e("footer"))
|
|
}, [
|
|
unref(clearable) ? (openBlock(), createBlock(unref(ElButton), {
|
|
key: 0,
|
|
text: "",
|
|
size: "small",
|
|
class: normalizeClass(unref(ppNs).e("link-btn")),
|
|
onClick: handleClear
|
|
}, {
|
|
default: withCtx(() => [
|
|
createTextVNode(toDisplayString(unref(t)("el.datepicker.clear")), 1)
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true),
|
|
createVNode(unref(ElButton), {
|
|
plain: "",
|
|
size: "small",
|
|
class: normalizeClass(unref(ppNs).e("link-btn")),
|
|
disabled: unref(btnDisabled),
|
|
onClick: ($event) => unref(handleRangeConfirm)(false)
|
|
}, {
|
|
default: withCtx(() => [
|
|
createTextVNode(toDisplayString(unref(t)("el.datepicker.confirm")), 1)
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "disabled", "onClick"])
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var DateRangePickPanel = _export_sfc(_sfc_main65, [["__file", "panel-date-range.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/date-picker-com/panel-month-range.mjs
|
|
var import_dayjs15 = __toModule(require_dayjs_min());
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/props/panel-month-range.mjs
|
|
var panelMonthRangeProps = buildProps({
|
|
...panelRangeSharedProps
|
|
});
|
|
var panelMonthRangeEmits = [
|
|
"pick",
|
|
"set-picker-option",
|
|
"calendar-change"
|
|
];
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/composables/use-month-range-header.mjs
|
|
var useMonthRangeHeader = ({
|
|
unlinkPanels,
|
|
leftDate,
|
|
rightDate
|
|
}) => {
|
|
const { t } = useLocale();
|
|
const leftPrevYear = () => {
|
|
leftDate.value = leftDate.value.subtract(1, "year");
|
|
if (!unlinkPanels.value) {
|
|
rightDate.value = rightDate.value.subtract(1, "year");
|
|
}
|
|
};
|
|
const rightNextYear = () => {
|
|
if (!unlinkPanels.value) {
|
|
leftDate.value = leftDate.value.add(1, "year");
|
|
}
|
|
rightDate.value = rightDate.value.add(1, "year");
|
|
};
|
|
const leftNextYear = () => {
|
|
leftDate.value = leftDate.value.add(1, "year");
|
|
};
|
|
const rightPrevYear = () => {
|
|
rightDate.value = rightDate.value.subtract(1, "year");
|
|
};
|
|
const leftLabel = computed(() => {
|
|
return `${leftDate.value.year()} ${t("el.datepicker.year")}`;
|
|
});
|
|
const rightLabel = computed(() => {
|
|
return `${rightDate.value.year()} ${t("el.datepicker.year")}`;
|
|
});
|
|
const leftYear = computed(() => {
|
|
return leftDate.value.year();
|
|
});
|
|
const rightYear = computed(() => {
|
|
return rightDate.value.year() === leftDate.value.year() ? leftDate.value.year() + 1 : rightDate.value.year();
|
|
});
|
|
return {
|
|
leftPrevYear,
|
|
rightNextYear,
|
|
leftNextYear,
|
|
rightPrevYear,
|
|
leftLabel,
|
|
rightLabel,
|
|
leftYear,
|
|
rightYear
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/date-picker-com/panel-month-range.mjs
|
|
var unit2 = "year";
|
|
var __default__48 = defineComponent({
|
|
name: "DatePickerMonthRange"
|
|
});
|
|
var _sfc_main66 = defineComponent({
|
|
...__default__48,
|
|
props: panelMonthRangeProps,
|
|
emits: panelMonthRangeEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const { lang } = useLocale();
|
|
const pickerBase = inject("EP_PICKER_BASE");
|
|
const isDefaultFormat = inject("ElIsDefaultFormat");
|
|
const { shortcuts, disabledDate } = pickerBase.props;
|
|
const format2 = toRef(pickerBase.props, "format");
|
|
const defaultValue = toRef(pickerBase.props, "defaultValue");
|
|
const leftDate = ref((0, import_dayjs15.default)().locale(lang.value));
|
|
const rightDate = ref((0, import_dayjs15.default)().locale(lang.value).add(1, unit2));
|
|
const {
|
|
minDate,
|
|
maxDate,
|
|
rangeState,
|
|
ppNs,
|
|
drpNs,
|
|
handleChangeRange,
|
|
handleRangeConfirm,
|
|
handleShortcutClick,
|
|
onSelect
|
|
} = useRangePicker(props2, {
|
|
defaultValue,
|
|
leftDate,
|
|
rightDate,
|
|
unit: unit2,
|
|
onParsedValueChanged
|
|
});
|
|
const hasShortcuts = computed(() => !!shortcuts.length);
|
|
const {
|
|
leftPrevYear,
|
|
rightNextYear,
|
|
leftNextYear,
|
|
rightPrevYear,
|
|
leftLabel,
|
|
rightLabel,
|
|
leftYear,
|
|
rightYear
|
|
} = useMonthRangeHeader({
|
|
unlinkPanels: toRef(props2, "unlinkPanels"),
|
|
leftDate,
|
|
rightDate
|
|
});
|
|
const enableYearArrow = computed(() => {
|
|
return props2.unlinkPanels && rightYear.value > leftYear.value + 1;
|
|
});
|
|
const handleRangePick = (val, close2 = true) => {
|
|
const minDate_ = val.minDate;
|
|
const maxDate_ = val.maxDate;
|
|
if (maxDate.value === maxDate_ && minDate.value === minDate_) {
|
|
return;
|
|
}
|
|
emit("calendar-change", [minDate_.toDate(), maxDate_ && maxDate_.toDate()]);
|
|
maxDate.value = maxDate_;
|
|
minDate.value = minDate_;
|
|
if (!close2)
|
|
return;
|
|
handleRangeConfirm();
|
|
};
|
|
const handleClear = () => {
|
|
leftDate.value = getDefaultValue(unref(defaultValue), {
|
|
lang: unref(lang),
|
|
unit: "year",
|
|
unlinkPanels: props2.unlinkPanels
|
|
})[0];
|
|
rightDate.value = leftDate.value.add(1, "year");
|
|
emit("pick", null);
|
|
};
|
|
const formatToString = (value) => {
|
|
return isArray(value) ? value.map((_2) => _2.format(format2.value)) : value.format(format2.value);
|
|
};
|
|
const parseUserInput = (value) => {
|
|
return correctlyParseUserInput(value, format2.value, lang.value, isDefaultFormat);
|
|
};
|
|
function onParsedValueChanged(minDate2, maxDate2) {
|
|
if (props2.unlinkPanels && maxDate2) {
|
|
const minDateYear = (minDate2 == null ? void 0 : minDate2.year()) || 0;
|
|
const maxDateYear = maxDate2.year();
|
|
rightDate.value = minDateYear === maxDateYear ? maxDate2.add(1, unit2) : maxDate2;
|
|
} else {
|
|
rightDate.value = leftDate.value.add(1, unit2);
|
|
}
|
|
}
|
|
emit("set-picker-option", ["isValidValue", isValidRange2]);
|
|
emit("set-picker-option", ["formatToString", formatToString]);
|
|
emit("set-picker-option", ["parseUserInput", parseUserInput]);
|
|
emit("set-picker-option", ["handleClear", handleClear]);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([
|
|
unref(ppNs).b(),
|
|
unref(drpNs).b(),
|
|
{
|
|
"has-sidebar": Boolean(_ctx.$slots.sidebar) || unref(hasShortcuts)
|
|
}
|
|
])
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ppNs).e("body-wrapper"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "sidebar", {
|
|
class: normalizeClass(unref(ppNs).e("sidebar"))
|
|
}),
|
|
unref(hasShortcuts) ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ppNs).e("sidebar"))
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(shortcuts), (shortcut, key) => {
|
|
return openBlock(), createElementBlock("button", {
|
|
key,
|
|
type: "button",
|
|
class: normalizeClass(unref(ppNs).e("shortcut")),
|
|
onClick: ($event) => unref(handleShortcutClick)(shortcut)
|
|
}, toDisplayString(shortcut.text), 11, ["onClick"]);
|
|
}), 128))
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ppNs).e("body"))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([[unref(ppNs).e("content"), unref(drpNs).e("content")], "is-left"])
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(drpNs).e("header"))
|
|
}, [
|
|
createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass([unref(ppNs).e("icon-btn"), "d-arrow-left"]),
|
|
onClick: unref(leftPrevYear)
|
|
}, [
|
|
renderSlot(_ctx.$slots, "prev-year", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(d_arrow_left_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["onClick"]),
|
|
_ctx.unlinkPanels ? (openBlock(), createElementBlock("button", {
|
|
key: 0,
|
|
type: "button",
|
|
disabled: !unref(enableYearArrow),
|
|
class: normalizeClass([[
|
|
unref(ppNs).e("icon-btn"),
|
|
{ [unref(ppNs).is("disabled")]: !unref(enableYearArrow) }
|
|
], "d-arrow-right"]),
|
|
onClick: unref(leftNextYear)
|
|
}, [
|
|
renderSlot(_ctx.$slots, "next-year", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(d_arrow_right_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["disabled", "onClick"])) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", null, toDisplayString(unref(leftLabel)), 1)
|
|
], 2),
|
|
createVNode(MonthTable, {
|
|
"selection-mode": "range",
|
|
date: leftDate.value,
|
|
"min-date": unref(minDate),
|
|
"max-date": unref(maxDate),
|
|
"range-state": unref(rangeState),
|
|
"disabled-date": unref(disabledDate),
|
|
onChangerange: unref(handleChangeRange),
|
|
onPick: handleRangePick,
|
|
onSelect: unref(onSelect)
|
|
}, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "onChangerange", "onSelect"])
|
|
], 2),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([[unref(ppNs).e("content"), unref(drpNs).e("content")], "is-right"])
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(drpNs).e("header"))
|
|
}, [
|
|
_ctx.unlinkPanels ? (openBlock(), createElementBlock("button", {
|
|
key: 0,
|
|
type: "button",
|
|
disabled: !unref(enableYearArrow),
|
|
class: normalizeClass([[unref(ppNs).e("icon-btn"), { "is-disabled": !unref(enableYearArrow) }], "d-arrow-left"]),
|
|
onClick: unref(rightPrevYear)
|
|
}, [
|
|
renderSlot(_ctx.$slots, "prev-year", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(d_arrow_left_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["disabled", "onClick"])) : createCommentVNode("v-if", true),
|
|
createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass([unref(ppNs).e("icon-btn"), "d-arrow-right"]),
|
|
onClick: unref(rightNextYear)
|
|
}, [
|
|
renderSlot(_ctx.$slots, "next-year", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(d_arrow_right_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["onClick"]),
|
|
createBaseVNode("div", null, toDisplayString(unref(rightLabel)), 1)
|
|
], 2),
|
|
createVNode(MonthTable, {
|
|
"selection-mode": "range",
|
|
date: rightDate.value,
|
|
"min-date": unref(minDate),
|
|
"max-date": unref(maxDate),
|
|
"range-state": unref(rangeState),
|
|
"disabled-date": unref(disabledDate),
|
|
onChangerange: unref(handleChangeRange),
|
|
onPick: handleRangePick,
|
|
onSelect: unref(onSelect)
|
|
}, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "onChangerange", "onSelect"])
|
|
], 2)
|
|
], 2)
|
|
], 2)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var MonthRangePickPanel = _export_sfc(_sfc_main66, [["__file", "panel-month-range.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/date-picker-com/panel-year-range.mjs
|
|
var import_dayjs16 = __toModule(require_dayjs_min());
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/props/panel-year-range.mjs
|
|
var panelYearRangeProps = buildProps({
|
|
...panelRangeSharedProps
|
|
});
|
|
var panelYearRangeEmits = [
|
|
"pick",
|
|
"set-picker-option",
|
|
"calendar-change"
|
|
];
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/composables/use-year-range-header.mjs
|
|
var useYearRangeHeader = ({
|
|
unlinkPanels,
|
|
leftDate,
|
|
rightDate
|
|
}) => {
|
|
const leftPrevYear = () => {
|
|
leftDate.value = leftDate.value.subtract(10, "year");
|
|
if (!unlinkPanels.value) {
|
|
rightDate.value = rightDate.value.subtract(10, "year");
|
|
}
|
|
};
|
|
const rightNextYear = () => {
|
|
if (!unlinkPanels.value) {
|
|
leftDate.value = leftDate.value.add(10, "year");
|
|
}
|
|
rightDate.value = rightDate.value.add(10, "year");
|
|
};
|
|
const leftNextYear = () => {
|
|
leftDate.value = leftDate.value.add(10, "year");
|
|
};
|
|
const rightPrevYear = () => {
|
|
rightDate.value = rightDate.value.subtract(10, "year");
|
|
};
|
|
const leftLabel = computed(() => {
|
|
const leftStartDate = Math.floor(leftDate.value.year() / 10) * 10;
|
|
return `${leftStartDate}-${leftStartDate + 9}`;
|
|
});
|
|
const rightLabel = computed(() => {
|
|
const rightStartDate = Math.floor(rightDate.value.year() / 10) * 10;
|
|
return `${rightStartDate}-${rightStartDate + 9}`;
|
|
});
|
|
const leftYear = computed(() => {
|
|
const leftEndDate = Math.floor(leftDate.value.year() / 10) * 10 + 9;
|
|
return leftEndDate;
|
|
});
|
|
const rightYear = computed(() => {
|
|
const rightStartDate = Math.floor(rightDate.value.year() / 10) * 10;
|
|
return rightStartDate;
|
|
});
|
|
return {
|
|
leftPrevYear,
|
|
rightNextYear,
|
|
leftNextYear,
|
|
rightPrevYear,
|
|
leftLabel,
|
|
rightLabel,
|
|
leftYear,
|
|
rightYear
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/date-picker-com/panel-year-range.mjs
|
|
var unit3 = "year";
|
|
var __default__49 = defineComponent({
|
|
name: "DatePickerYearRange"
|
|
});
|
|
var _sfc_main67 = defineComponent({
|
|
...__default__49,
|
|
props: panelYearRangeProps,
|
|
emits: panelYearRangeEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const { lang } = useLocale();
|
|
const leftDate = ref((0, import_dayjs16.default)().locale(lang.value));
|
|
const rightDate = ref(leftDate.value.add(10, "year"));
|
|
const { pickerNs: ppNs } = inject(ROOT_PICKER_INJECTION_KEY);
|
|
const drpNs = useNamespace("date-range-picker");
|
|
const isDefaultFormat = inject("ElIsDefaultFormat");
|
|
const hasShortcuts = computed(() => !!shortcuts.length);
|
|
const panelKls = computed(() => [
|
|
ppNs.b(),
|
|
drpNs.b(),
|
|
{
|
|
"has-sidebar": Boolean(useSlots().sidebar) || hasShortcuts.value
|
|
}
|
|
]);
|
|
const leftPanelKls = computed(() => {
|
|
return {
|
|
content: [ppNs.e("content"), drpNs.e("content"), "is-left"],
|
|
arrowLeftBtn: [ppNs.e("icon-btn"), "d-arrow-left"],
|
|
arrowRightBtn: [
|
|
ppNs.e("icon-btn"),
|
|
{ [ppNs.is("disabled")]: !enableYearArrow.value },
|
|
"d-arrow-right"
|
|
]
|
|
};
|
|
});
|
|
const rightPanelKls = computed(() => {
|
|
return {
|
|
content: [ppNs.e("content"), drpNs.e("content"), "is-right"],
|
|
arrowLeftBtn: [
|
|
ppNs.e("icon-btn"),
|
|
{ "is-disabled": !enableYearArrow.value },
|
|
"d-arrow-left"
|
|
],
|
|
arrowRightBtn: [ppNs.e("icon-btn"), "d-arrow-right"]
|
|
};
|
|
});
|
|
const handleShortcutClick = useShortcut(lang);
|
|
const {
|
|
leftPrevYear,
|
|
rightNextYear,
|
|
leftNextYear,
|
|
rightPrevYear,
|
|
leftLabel,
|
|
rightLabel,
|
|
leftYear,
|
|
rightYear
|
|
} = useYearRangeHeader({
|
|
unlinkPanels: toRef(props2, "unlinkPanels"),
|
|
leftDate,
|
|
rightDate
|
|
});
|
|
const enableYearArrow = computed(() => {
|
|
return props2.unlinkPanels && rightYear.value > leftYear.value + 1;
|
|
});
|
|
const minDate = ref();
|
|
const maxDate = ref();
|
|
const rangeState = ref({
|
|
endDate: null,
|
|
selecting: false
|
|
});
|
|
const handleChangeRange = (val) => {
|
|
rangeState.value = val;
|
|
};
|
|
const handleRangePick = (val, close2 = true) => {
|
|
const minDate_ = val.minDate;
|
|
const maxDate_ = val.maxDate;
|
|
if (maxDate.value === maxDate_ && minDate.value === minDate_) {
|
|
return;
|
|
}
|
|
emit("calendar-change", [minDate_.toDate(), maxDate_ && maxDate_.toDate()]);
|
|
maxDate.value = maxDate_;
|
|
minDate.value = minDate_;
|
|
if (!close2)
|
|
return;
|
|
handleConfirm();
|
|
};
|
|
const handleConfirm = (visible = false) => {
|
|
if (isValidRange2([minDate.value, maxDate.value])) {
|
|
emit("pick", [minDate.value, maxDate.value], visible);
|
|
}
|
|
};
|
|
const onSelect = (selecting) => {
|
|
rangeState.value.selecting = selecting;
|
|
if (!selecting) {
|
|
rangeState.value.endDate = null;
|
|
}
|
|
};
|
|
const pickerBase = inject("EP_PICKER_BASE");
|
|
const { shortcuts, disabledDate } = pickerBase.props;
|
|
const format2 = toRef(pickerBase.props, "format");
|
|
const defaultValue = toRef(pickerBase.props, "defaultValue");
|
|
const getDefaultValue2 = () => {
|
|
let start;
|
|
if (isArray(defaultValue.value)) {
|
|
const left = (0, import_dayjs16.default)(defaultValue.value[0]);
|
|
let right = (0, import_dayjs16.default)(defaultValue.value[1]);
|
|
if (!props2.unlinkPanels) {
|
|
right = left.add(10, unit3);
|
|
}
|
|
return [left, right];
|
|
} else if (defaultValue.value) {
|
|
start = (0, import_dayjs16.default)(defaultValue.value);
|
|
} else {
|
|
start = (0, import_dayjs16.default)();
|
|
}
|
|
start = start.locale(lang.value);
|
|
return [start, start.add(10, unit3)];
|
|
};
|
|
watch(() => defaultValue.value, (val) => {
|
|
if (val) {
|
|
const defaultArr = getDefaultValue2();
|
|
leftDate.value = defaultArr[0];
|
|
rightDate.value = defaultArr[1];
|
|
}
|
|
}, { immediate: true });
|
|
watch(() => props2.parsedValue, (newVal) => {
|
|
if (newVal && newVal.length === 2) {
|
|
minDate.value = newVal[0];
|
|
maxDate.value = newVal[1];
|
|
leftDate.value = minDate.value;
|
|
if (props2.unlinkPanels && maxDate.value) {
|
|
const minDateYear = minDate.value.year();
|
|
const maxDateYear = maxDate.value.year();
|
|
rightDate.value = minDateYear === maxDateYear ? maxDate.value.add(10, "year") : maxDate.value;
|
|
} else {
|
|
rightDate.value = leftDate.value.add(10, "year");
|
|
}
|
|
} else {
|
|
const defaultArr = getDefaultValue2();
|
|
minDate.value = void 0;
|
|
maxDate.value = void 0;
|
|
leftDate.value = defaultArr[0];
|
|
rightDate.value = defaultArr[1];
|
|
}
|
|
}, { immediate: true });
|
|
const parseUserInput = (value) => {
|
|
return correctlyParseUserInput(value, format2.value, lang.value, isDefaultFormat);
|
|
};
|
|
const formatToString = (value) => {
|
|
return isArray(value) ? value.map((day) => day.format(format2.value)) : value.format(format2.value);
|
|
};
|
|
const isValidValue3 = (date4) => {
|
|
return isValidRange2(date4) && (disabledDate ? !disabledDate(date4[0].toDate()) && !disabledDate(date4[1].toDate()) : true);
|
|
};
|
|
const handleClear = () => {
|
|
const defaultArr = getDefaultValue2();
|
|
leftDate.value = defaultArr[0];
|
|
rightDate.value = defaultArr[1];
|
|
maxDate.value = void 0;
|
|
minDate.value = void 0;
|
|
emit("pick", null);
|
|
};
|
|
emit("set-picker-option", ["isValidValue", isValidValue3]);
|
|
emit("set-picker-option", ["parseUserInput", parseUserInput]);
|
|
emit("set-picker-option", ["formatToString", formatToString]);
|
|
emit("set-picker-option", ["handleClear", handleClear]);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(unref(panelKls))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ppNs).e("body-wrapper"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "sidebar", {
|
|
class: normalizeClass(unref(ppNs).e("sidebar"))
|
|
}),
|
|
unref(hasShortcuts) ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ppNs).e("sidebar"))
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(shortcuts), (shortcut, key) => {
|
|
return openBlock(), createElementBlock("button", {
|
|
key,
|
|
type: "button",
|
|
class: normalizeClass(unref(ppNs).e("shortcut")),
|
|
onClick: ($event) => unref(handleShortcutClick)(shortcut)
|
|
}, toDisplayString(shortcut.text), 11, ["onClick"]);
|
|
}), 128))
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ppNs).e("body"))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(leftPanelKls).content)
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(drpNs).e("header"))
|
|
}, [
|
|
createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass(unref(leftPanelKls).arrowLeftBtn),
|
|
onClick: unref(leftPrevYear)
|
|
}, [
|
|
renderSlot(_ctx.$slots, "prev-year", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(d_arrow_left_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["onClick"]),
|
|
_ctx.unlinkPanels ? (openBlock(), createElementBlock("button", {
|
|
key: 0,
|
|
type: "button",
|
|
disabled: !unref(enableYearArrow),
|
|
class: normalizeClass(unref(leftPanelKls).arrowRightBtn),
|
|
onClick: unref(leftNextYear)
|
|
}, [
|
|
renderSlot(_ctx.$slots, "next-year", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(d_arrow_right_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["disabled", "onClick"])) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", null, toDisplayString(unref(leftLabel)), 1)
|
|
], 2),
|
|
createVNode(YearTable, {
|
|
"selection-mode": "range",
|
|
date: leftDate.value,
|
|
"min-date": minDate.value,
|
|
"max-date": maxDate.value,
|
|
"range-state": rangeState.value,
|
|
"disabled-date": unref(disabledDate),
|
|
onChangerange: handleChangeRange,
|
|
onPick: handleRangePick,
|
|
onSelect
|
|
}, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date"])
|
|
], 2),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(rightPanelKls).content)
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(drpNs).e("header"))
|
|
}, [
|
|
_ctx.unlinkPanels ? (openBlock(), createElementBlock("button", {
|
|
key: 0,
|
|
type: "button",
|
|
disabled: !unref(enableYearArrow),
|
|
class: normalizeClass(unref(rightPanelKls).arrowLeftBtn),
|
|
onClick: unref(rightPrevYear)
|
|
}, [
|
|
renderSlot(_ctx.$slots, "prev-year", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(d_arrow_left_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["disabled", "onClick"])) : createCommentVNode("v-if", true),
|
|
createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass(unref(rightPanelKls).arrowRightBtn),
|
|
onClick: unref(rightNextYear)
|
|
}, [
|
|
renderSlot(_ctx.$slots, "next-year", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(d_arrow_right_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 10, ["onClick"]),
|
|
createBaseVNode("div", null, toDisplayString(unref(rightLabel)), 1)
|
|
], 2),
|
|
createVNode(YearTable, {
|
|
"selection-mode": "range",
|
|
date: rightDate.value,
|
|
"min-date": minDate.value,
|
|
"max-date": maxDate.value,
|
|
"range-state": rangeState.value,
|
|
"disabled-date": unref(disabledDate),
|
|
onChangerange: handleChangeRange,
|
|
onPick: handleRangePick,
|
|
onSelect
|
|
}, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date"])
|
|
], 2)
|
|
], 2)
|
|
], 2)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var YearRangePickPanel = _export_sfc(_sfc_main67, [["__file", "panel-year-range.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/panel-utils.mjs
|
|
var getPanel = function(type4) {
|
|
switch (type4) {
|
|
case "daterange":
|
|
case "datetimerange": {
|
|
return DateRangePickPanel;
|
|
}
|
|
case "monthrange": {
|
|
return MonthRangePickPanel;
|
|
}
|
|
case "yearrange": {
|
|
return YearRangePickPanel;
|
|
}
|
|
default: {
|
|
return DatePickPanel;
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/date-picker.mjs
|
|
import_dayjs17.default.extend(import_localeData2.default);
|
|
import_dayjs17.default.extend(import_advancedFormat.default);
|
|
import_dayjs17.default.extend(import_customParseFormat2.default);
|
|
import_dayjs17.default.extend(import_weekOfYear.default);
|
|
import_dayjs17.default.extend(import_weekYear.default);
|
|
import_dayjs17.default.extend(import_dayOfYear.default);
|
|
import_dayjs17.default.extend(import_isSameOrAfter.default);
|
|
import_dayjs17.default.extend(import_isSameOrBefore.default);
|
|
var DatePicker = defineComponent({
|
|
name: "ElDatePicker",
|
|
install: null,
|
|
props: datePickerProps,
|
|
emits: [UPDATE_MODEL_EVENT],
|
|
setup(props2, {
|
|
expose,
|
|
emit,
|
|
slots
|
|
}) {
|
|
const ns = useNamespace("picker-panel");
|
|
const isDefaultFormat = computed(() => {
|
|
return !props2.format;
|
|
});
|
|
provide("ElIsDefaultFormat", isDefaultFormat);
|
|
provide("ElPopperOptions", reactive(toRef(props2, "popperOptions")));
|
|
provide(ROOT_PICKER_INJECTION_KEY, {
|
|
slots,
|
|
pickerNs: ns
|
|
});
|
|
const commonPicker = ref();
|
|
const refProps = {
|
|
focus: () => {
|
|
var _a2;
|
|
(_a2 = commonPicker.value) == null ? void 0 : _a2.focus();
|
|
},
|
|
blur: () => {
|
|
var _a2;
|
|
(_a2 = commonPicker.value) == null ? void 0 : _a2.blur();
|
|
},
|
|
handleOpen: () => {
|
|
var _a2;
|
|
(_a2 = commonPicker.value) == null ? void 0 : _a2.handleOpen();
|
|
},
|
|
handleClose: () => {
|
|
var _a2;
|
|
(_a2 = commonPicker.value) == null ? void 0 : _a2.handleClose();
|
|
}
|
|
};
|
|
expose(refProps);
|
|
const onModelValueUpdated = (val) => {
|
|
emit(UPDATE_MODEL_EVENT, val);
|
|
};
|
|
return () => {
|
|
var _a2;
|
|
const format2 = (_a2 = props2.format) != null ? _a2 : DEFAULT_FORMATS_DATEPICKER[props2.type] || DEFAULT_FORMATS_DATE;
|
|
const Component = getPanel(props2.type);
|
|
return createVNode(CommonPicker, mergeProps(props2, {
|
|
"format": format2,
|
|
"type": props2.type,
|
|
"ref": commonPicker,
|
|
"onUpdate:modelValue": onModelValueUpdated
|
|
}), {
|
|
default: (scopedProps) => createVNode(Component, scopedProps, {
|
|
"prev-month": slots["prev-month"],
|
|
"next-month": slots["next-month"],
|
|
"prev-year": slots["prev-year"],
|
|
"next-year": slots["next-year"]
|
|
}),
|
|
"range-separator": slots["range-separator"]
|
|
});
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker/index.mjs
|
|
var ElDatePicker = withInstall(DatePicker);
|
|
|
|
// node_modules/element-plus/es/components/descriptions/src/description.mjs
|
|
var descriptionProps = buildProps({
|
|
border: Boolean,
|
|
column: {
|
|
type: Number,
|
|
default: 3
|
|
},
|
|
direction: {
|
|
type: String,
|
|
values: ["horizontal", "vertical"],
|
|
default: "horizontal"
|
|
},
|
|
size: useSizeProp,
|
|
title: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
extra: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
labelWidth: {
|
|
type: [String, Number],
|
|
default: ""
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/constants/column-alignment.mjs
|
|
var columnAlignment = ["left", "center", "right"];
|
|
|
|
// node_modules/element-plus/es/components/descriptions/src/constants.mjs
|
|
var COMPONENT_NAME11 = "ElDescriptionsItem";
|
|
|
|
// node_modules/element-plus/es/components/descriptions/src/description-item.mjs
|
|
var descriptionItemProps = buildProps({
|
|
label: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
span: {
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
rowspan: {
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
width: {
|
|
type: [String, Number],
|
|
default: ""
|
|
},
|
|
minWidth: {
|
|
type: [String, Number],
|
|
default: ""
|
|
},
|
|
labelWidth: {
|
|
type: [String, Number],
|
|
default: ""
|
|
},
|
|
align: {
|
|
type: String,
|
|
values: columnAlignment,
|
|
default: "left"
|
|
},
|
|
labelAlign: {
|
|
type: String,
|
|
values: columnAlignment
|
|
},
|
|
className: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
labelClassName: {
|
|
type: String,
|
|
default: ""
|
|
}
|
|
});
|
|
var DescriptionItem = defineComponent({
|
|
name: COMPONENT_NAME11,
|
|
props: descriptionItemProps
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/descriptions/src/token.mjs
|
|
var descriptionsKey = Symbol("elDescriptions");
|
|
|
|
// node_modules/element-plus/es/components/descriptions/src/descriptions-cell.mjs
|
|
var ElDescriptionsCell = defineComponent({
|
|
name: "ElDescriptionsCell",
|
|
props: {
|
|
cell: {
|
|
type: Object
|
|
},
|
|
tag: {
|
|
type: String,
|
|
default: "td"
|
|
},
|
|
type: {
|
|
type: String
|
|
}
|
|
},
|
|
setup() {
|
|
const descriptions = inject(descriptionsKey, {});
|
|
return {
|
|
descriptions
|
|
};
|
|
},
|
|
render() {
|
|
var _a2;
|
|
const item = getNormalizedProps(this.cell);
|
|
const directives = (((_a2 = this.cell) == null ? void 0 : _a2.dirs) || []).map((dire) => {
|
|
const { dir, arg, modifiers, value } = dire;
|
|
return [dir, value, arg, modifiers];
|
|
});
|
|
const { border, direction: direction2 } = this.descriptions;
|
|
const isVertical = direction2 === "vertical";
|
|
const renderLabel = () => {
|
|
var _a22, _b, _c;
|
|
return ((_c = (_b = (_a22 = this.cell) == null ? void 0 : _a22.children) == null ? void 0 : _b.label) == null ? void 0 : _c.call(_b)) || item.label;
|
|
};
|
|
const renderContent = () => {
|
|
var _a22, _b, _c;
|
|
return (_c = (_b = (_a22 = this.cell) == null ? void 0 : _a22.children) == null ? void 0 : _b.default) == null ? void 0 : _c.call(_b);
|
|
};
|
|
const span = item.span;
|
|
const rowspan = item.rowspan;
|
|
const align = item.align ? `is-${item.align}` : "";
|
|
const labelAlign = item.labelAlign ? `is-${item.labelAlign}` : align;
|
|
const className = item.className;
|
|
const labelClassName = item.labelClassName;
|
|
const width = this.type === "label" ? item.labelWidth || this.descriptions.labelWidth || item.width : item.width;
|
|
const style = {
|
|
width: addUnit(width),
|
|
minWidth: addUnit(item.minWidth)
|
|
};
|
|
const ns = useNamespace("descriptions");
|
|
switch (this.type) {
|
|
case "label":
|
|
return withDirectives(h(this.tag, {
|
|
style,
|
|
class: [
|
|
ns.e("cell"),
|
|
ns.e("label"),
|
|
ns.is("bordered-label", border),
|
|
ns.is("vertical-label", isVertical),
|
|
labelAlign,
|
|
labelClassName
|
|
],
|
|
colSpan: isVertical ? span : 1,
|
|
rowspan: isVertical ? 1 : rowspan
|
|
}, renderLabel()), directives);
|
|
case "content":
|
|
return withDirectives(h(this.tag, {
|
|
style,
|
|
class: [
|
|
ns.e("cell"),
|
|
ns.e("content"),
|
|
ns.is("bordered-content", border),
|
|
ns.is("vertical-content", isVertical),
|
|
align,
|
|
className
|
|
],
|
|
colSpan: isVertical ? span : span * 2 - 1,
|
|
rowspan: isVertical ? rowspan * 2 - 1 : rowspan
|
|
}, renderContent()), directives);
|
|
default: {
|
|
const label = renderLabel();
|
|
const labelStyle = {};
|
|
const width2 = addUnit(item.labelWidth || this.descriptions.labelWidth);
|
|
if (width2) {
|
|
labelStyle.width = width2;
|
|
labelStyle.display = "inline-block";
|
|
}
|
|
return withDirectives(h("td", {
|
|
style,
|
|
class: [ns.e("cell"), align],
|
|
colSpan: span,
|
|
rowspan
|
|
}, [
|
|
!isNil_default(label) ? h("span", {
|
|
style: labelStyle,
|
|
class: [ns.e("label"), labelClassName]
|
|
}, label) : void 0,
|
|
h("span", {
|
|
class: [ns.e("content"), className]
|
|
}, renderContent())
|
|
]), directives);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/descriptions/src/descriptions-row2.mjs
|
|
var descriptionsRowProps = buildProps({
|
|
row: {
|
|
type: definePropType(Array),
|
|
default: () => []
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/descriptions/src/descriptions-row.mjs
|
|
var __default__50 = defineComponent({
|
|
name: "ElDescriptionsRow"
|
|
});
|
|
var _sfc_main68 = defineComponent({
|
|
...__default__50,
|
|
props: descriptionsRowProps,
|
|
setup(__props) {
|
|
const descriptions = inject(descriptionsKey, {});
|
|
return (_ctx, _cache) => {
|
|
return unref(descriptions).direction === "vertical" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
|
|
createBaseVNode("tr", null, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.row, (cell, _index) => {
|
|
return openBlock(), createBlock(unref(ElDescriptionsCell), {
|
|
key: `tr1-${_index}`,
|
|
cell,
|
|
tag: "th",
|
|
type: "label"
|
|
}, null, 8, ["cell"]);
|
|
}), 128))
|
|
]),
|
|
createBaseVNode("tr", null, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.row, (cell, _index) => {
|
|
return openBlock(), createBlock(unref(ElDescriptionsCell), {
|
|
key: `tr2-${_index}`,
|
|
cell,
|
|
tag: "td",
|
|
type: "content"
|
|
}, null, 8, ["cell"]);
|
|
}), 128))
|
|
])
|
|
], 64)) : (openBlock(), createElementBlock("tr", { key: 1 }, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.row, (cell, _index) => {
|
|
return openBlock(), createElementBlock(Fragment, {
|
|
key: `tr3-${_index}`
|
|
}, [
|
|
unref(descriptions).border ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
|
|
createVNode(unref(ElDescriptionsCell), {
|
|
cell,
|
|
tag: "td",
|
|
type: "label"
|
|
}, null, 8, ["cell"]),
|
|
createVNode(unref(ElDescriptionsCell), {
|
|
cell,
|
|
tag: "td",
|
|
type: "content"
|
|
}, null, 8, ["cell"])
|
|
], 64)) : (openBlock(), createBlock(unref(ElDescriptionsCell), {
|
|
key: 1,
|
|
cell,
|
|
tag: "td",
|
|
type: "both"
|
|
}, null, 8, ["cell"]))
|
|
], 64);
|
|
}), 128))
|
|
]));
|
|
};
|
|
}
|
|
});
|
|
var ElDescriptionsRow = _export_sfc(_sfc_main68, [["__file", "descriptions-row.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/descriptions/src/description2.mjs
|
|
var __default__51 = defineComponent({
|
|
name: "ElDescriptions"
|
|
});
|
|
var _sfc_main69 = defineComponent({
|
|
...__default__51,
|
|
props: descriptionProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("descriptions");
|
|
const descriptionsSize = useFormSize();
|
|
const slots = useSlots();
|
|
provide(descriptionsKey, props2);
|
|
const descriptionKls = computed(() => [ns.b(), ns.m(descriptionsSize.value)]);
|
|
const filledNode = (node, span, count, isLast = false) => {
|
|
if (!node.props) {
|
|
node.props = {};
|
|
}
|
|
if (span > count) {
|
|
node.props.span = count;
|
|
}
|
|
if (isLast) {
|
|
node.props.span = span;
|
|
}
|
|
return node;
|
|
};
|
|
const getRows = () => {
|
|
if (!slots.default)
|
|
return [];
|
|
const children = flattedChildren(slots.default()).filter((node) => {
|
|
var _a2;
|
|
return ((_a2 = node == null ? void 0 : node.type) == null ? void 0 : _a2.name) === COMPONENT_NAME11;
|
|
});
|
|
const rows = [];
|
|
let temp = [];
|
|
let count = props2.column;
|
|
let totalSpan = 0;
|
|
const rowspanTemp = [];
|
|
children.forEach((node, index) => {
|
|
var _a2, _b, _c;
|
|
const span = ((_a2 = node.props) == null ? void 0 : _a2.span) || 1;
|
|
const rowspan = ((_b = node.props) == null ? void 0 : _b.rowspan) || 1;
|
|
const rowNo = rows.length;
|
|
rowspanTemp[rowNo] || (rowspanTemp[rowNo] = 0);
|
|
if (rowspan > 1) {
|
|
for (let i = 1; i < rowspan; i++) {
|
|
rowspanTemp[_c = rowNo + i] || (rowspanTemp[_c] = 0);
|
|
rowspanTemp[rowNo + i]++;
|
|
totalSpan++;
|
|
}
|
|
}
|
|
if (rowspanTemp[rowNo] > 0) {
|
|
count -= rowspanTemp[rowNo];
|
|
rowspanTemp[rowNo] = 0;
|
|
}
|
|
if (index < children.length - 1) {
|
|
totalSpan += span > count ? count : span;
|
|
}
|
|
if (index === children.length - 1) {
|
|
const lastSpan = props2.column - totalSpan % props2.column;
|
|
temp.push(filledNode(node, lastSpan, count, true));
|
|
rows.push(temp);
|
|
return;
|
|
}
|
|
if (span < count) {
|
|
count -= span;
|
|
temp.push(node);
|
|
} else {
|
|
temp.push(filledNode(node, span, count));
|
|
rows.push(temp);
|
|
count = props2.column;
|
|
temp = [];
|
|
}
|
|
});
|
|
return rows;
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(unref(descriptionKls))
|
|
}, [
|
|
_ctx.title || _ctx.extra || _ctx.$slots.title || _ctx.$slots.extra ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("header"))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("title"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "title", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.title), 1)
|
|
])
|
|
], 2),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("extra"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "extra", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.extra), 1)
|
|
])
|
|
], 2)
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("body"))
|
|
}, [
|
|
createBaseVNode("table", {
|
|
class: normalizeClass([unref(ns).e("table"), unref(ns).is("bordered", _ctx.border)])
|
|
}, [
|
|
createBaseVNode("tbody", null, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(getRows(), (row, _index) => {
|
|
return openBlock(), createBlock(ElDescriptionsRow, {
|
|
key: _index,
|
|
row
|
|
}, null, 8, ["row"]);
|
|
}), 128))
|
|
])
|
|
], 2)
|
|
], 2)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Descriptions = _export_sfc(_sfc_main69, [["__file", "description.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/descriptions/index.mjs
|
|
var ElDescriptions = withInstall(Descriptions, {
|
|
DescriptionsItem: DescriptionItem
|
|
});
|
|
var ElDescriptionsItem = withNoopInstall(DescriptionItem);
|
|
|
|
// node_modules/element-plus/es/hooks/use-same-target/index.mjs
|
|
var useSameTarget = (handleClick) => {
|
|
if (!handleClick) {
|
|
return { onClick: NOOP, onMousedown: NOOP, onMouseup: NOOP };
|
|
}
|
|
let mousedownTarget = false;
|
|
let mouseupTarget = false;
|
|
const onClick = (e) => {
|
|
if (mousedownTarget && mouseupTarget) {
|
|
handleClick(e);
|
|
}
|
|
mousedownTarget = mouseupTarget = false;
|
|
};
|
|
const onMousedown = (e) => {
|
|
mousedownTarget = e.target === e.currentTarget;
|
|
};
|
|
const onMouseup = (e) => {
|
|
mouseupTarget = e.target === e.currentTarget;
|
|
};
|
|
return { onClick, onMousedown, onMouseup };
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/overlay/src/overlay.mjs
|
|
var overlayProps = buildProps({
|
|
mask: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
customMaskEvent: Boolean,
|
|
overlayClass: {
|
|
type: definePropType([
|
|
String,
|
|
Array,
|
|
Object
|
|
])
|
|
},
|
|
zIndex: {
|
|
type: definePropType([String, Number])
|
|
}
|
|
});
|
|
var overlayEmits = {
|
|
click: (evt) => evt instanceof MouseEvent
|
|
};
|
|
var BLOCK = "overlay";
|
|
var Overlay = defineComponent({
|
|
name: "ElOverlay",
|
|
props: overlayProps,
|
|
emits: overlayEmits,
|
|
setup(props2, { slots, emit }) {
|
|
const ns = useNamespace(BLOCK);
|
|
const onMaskClick = (e) => {
|
|
emit("click", e);
|
|
};
|
|
const { onClick, onMousedown, onMouseup } = useSameTarget(props2.customMaskEvent ? void 0 : onMaskClick);
|
|
return () => {
|
|
return props2.mask ? createVNode("div", {
|
|
class: [ns.b(), props2.overlayClass],
|
|
style: {
|
|
zIndex: props2.zIndex
|
|
},
|
|
onClick,
|
|
onMousedown,
|
|
onMouseup
|
|
}, [renderSlot(slots, "default")], PatchFlags.STYLE | PatchFlags.CLASS | PatchFlags.PROPS, ["onClick", "onMouseup", "onMousedown"]) : h("div", {
|
|
class: props2.overlayClass,
|
|
style: {
|
|
zIndex: props2.zIndex,
|
|
position: "fixed",
|
|
top: "0px",
|
|
right: "0px",
|
|
bottom: "0px",
|
|
left: "0px"
|
|
}
|
|
}, [renderSlot(slots, "default")]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/overlay/index.mjs
|
|
var ElOverlay = Overlay;
|
|
|
|
// node_modules/element-plus/es/components/dialog/src/constants.mjs
|
|
var dialogInjectionKey = Symbol("dialogInjectionKey");
|
|
|
|
// node_modules/element-plus/es/hooks/use-draggable/index.mjs
|
|
var useDraggable = (targetRef, dragRef, draggable2, overflow) => {
|
|
const transform2 = {
|
|
offsetX: 0,
|
|
offsetY: 0
|
|
};
|
|
const adjustPosition = (moveX, moveY) => {
|
|
if (targetRef.value) {
|
|
const { offsetX, offsetY } = transform2;
|
|
const targetRect = targetRef.value.getBoundingClientRect();
|
|
const targetLeft = targetRect.left;
|
|
const targetTop = targetRect.top;
|
|
const targetWidth = targetRect.width;
|
|
const targetHeight = targetRect.height;
|
|
const clientWidth = document.documentElement.clientWidth;
|
|
const clientHeight = document.documentElement.clientHeight;
|
|
const minLeft = -targetLeft + offsetX;
|
|
const minTop = -targetTop + offsetY;
|
|
const maxLeft = clientWidth - targetLeft - targetWidth + offsetX;
|
|
const maxTop = clientHeight - targetTop - targetHeight + offsetY;
|
|
if (!(overflow == null ? void 0 : overflow.value)) {
|
|
moveX = Math.min(Math.max(moveX, minLeft), maxLeft);
|
|
moveY = Math.min(Math.max(moveY, minTop), maxTop);
|
|
}
|
|
transform2.offsetX = moveX;
|
|
transform2.offsetY = moveY;
|
|
targetRef.value.style.transform = `translate(${addUnit(moveX)}, ${addUnit(moveY)})`;
|
|
}
|
|
};
|
|
const onMousedown = (e) => {
|
|
const downX = e.clientX;
|
|
const downY = e.clientY;
|
|
const { offsetX, offsetY } = transform2;
|
|
const onMousemove = (e2) => {
|
|
const moveX = offsetX + e2.clientX - downX;
|
|
const moveY = offsetY + e2.clientY - downY;
|
|
adjustPosition(moveX, moveY);
|
|
};
|
|
const onMouseup = () => {
|
|
document.removeEventListener("mousemove", onMousemove);
|
|
document.removeEventListener("mouseup", onMouseup);
|
|
};
|
|
document.addEventListener("mousemove", onMousemove);
|
|
document.addEventListener("mouseup", onMouseup);
|
|
};
|
|
const onDraggable = () => {
|
|
if (dragRef.value && targetRef.value) {
|
|
dragRef.value.addEventListener("mousedown", onMousedown);
|
|
window.addEventListener("resize", updatePosition);
|
|
}
|
|
};
|
|
const offDraggable = () => {
|
|
if (dragRef.value && targetRef.value) {
|
|
dragRef.value.removeEventListener("mousedown", onMousedown);
|
|
window.removeEventListener("resize", updatePosition);
|
|
}
|
|
};
|
|
const resetPosition = () => {
|
|
transform2.offsetX = 0;
|
|
transform2.offsetY = 0;
|
|
if (targetRef.value) {
|
|
targetRef.value.style.transform = "";
|
|
}
|
|
};
|
|
const updatePosition = () => {
|
|
const { offsetX, offsetY } = transform2;
|
|
adjustPosition(offsetX, offsetY);
|
|
};
|
|
onMounted(() => {
|
|
watchEffect(() => {
|
|
if (draggable2.value) {
|
|
onDraggable();
|
|
} else {
|
|
offDraggable();
|
|
}
|
|
});
|
|
});
|
|
onBeforeUnmount(() => {
|
|
offDraggable();
|
|
});
|
|
return {
|
|
resetPosition,
|
|
updatePosition
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/dialog/src/dialog-content.mjs
|
|
var dialogContentProps = buildProps({
|
|
center: Boolean,
|
|
alignCenter: Boolean,
|
|
closeIcon: {
|
|
type: iconPropType
|
|
},
|
|
draggable: Boolean,
|
|
overflow: Boolean,
|
|
fullscreen: Boolean,
|
|
headerClass: String,
|
|
bodyClass: String,
|
|
footerClass: String,
|
|
showClose: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
title: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
ariaLevel: {
|
|
type: String,
|
|
default: "2"
|
|
}
|
|
});
|
|
var dialogContentEmits = {
|
|
close: () => true
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/dialog/src/dialog2.mjs
|
|
var dialogProps = buildProps({
|
|
...dialogContentProps,
|
|
appendToBody: Boolean,
|
|
appendTo: {
|
|
type: teleportProps.to.type,
|
|
default: "body"
|
|
},
|
|
beforeClose: {
|
|
type: definePropType(Function)
|
|
},
|
|
destroyOnClose: Boolean,
|
|
closeOnClickModal: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
closeOnPressEscape: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
lockScroll: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
modal: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
openDelay: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
closeDelay: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
top: {
|
|
type: String
|
|
},
|
|
modelValue: Boolean,
|
|
modalClass: String,
|
|
headerClass: String,
|
|
bodyClass: String,
|
|
footerClass: String,
|
|
width: {
|
|
type: [String, Number]
|
|
},
|
|
zIndex: {
|
|
type: Number
|
|
},
|
|
trapFocus: Boolean,
|
|
headerAriaLevel: {
|
|
type: String,
|
|
default: "2"
|
|
}
|
|
});
|
|
var dialogEmits = {
|
|
open: () => true,
|
|
opened: () => true,
|
|
close: () => true,
|
|
closed: () => true,
|
|
[UPDATE_MODEL_EVENT]: (value) => isBoolean2(value),
|
|
openAutoFocus: () => true,
|
|
closeAutoFocus: () => true
|
|
};
|
|
|
|
// node_modules/element-plus/es/hooks/use-lockscreen/index.mjs
|
|
var useLockscreen = (trigger, options = {}) => {
|
|
if (!isRef(trigger)) {
|
|
throwError("[useLockscreen]", "You need to pass a ref param to this function");
|
|
}
|
|
const ns = options.ns || useNamespace("popup");
|
|
const hiddenCls = computed(() => ns.bm("parent", "hidden"));
|
|
if (!isClient || hasClass(document.body, hiddenCls.value)) {
|
|
return;
|
|
}
|
|
let scrollBarWidth2 = 0;
|
|
let withoutHiddenClass = false;
|
|
let bodyWidth = "0";
|
|
const cleanup = () => {
|
|
setTimeout(() => {
|
|
if (typeof document === "undefined")
|
|
return;
|
|
if (withoutHiddenClass && document) {
|
|
document.body.style.width = bodyWidth;
|
|
removeClass(document.body, hiddenCls.value);
|
|
}
|
|
}, 200);
|
|
};
|
|
watch(trigger, (val) => {
|
|
if (!val) {
|
|
cleanup();
|
|
return;
|
|
}
|
|
withoutHiddenClass = !hasClass(document.body, hiddenCls.value);
|
|
if (withoutHiddenClass) {
|
|
bodyWidth = document.body.style.width;
|
|
addClass(document.body, hiddenCls.value);
|
|
}
|
|
scrollBarWidth2 = getScrollBarWidth(ns.namespace.value);
|
|
const bodyHasOverflow = document.documentElement.clientHeight < document.body.scrollHeight;
|
|
const bodyOverflowY = getStyle(document.body, "overflowY");
|
|
if (scrollBarWidth2 > 0 && (bodyHasOverflow || bodyOverflowY === "scroll") && withoutHiddenClass) {
|
|
document.body.style.width = `calc(100% - ${scrollBarWidth2}px)`;
|
|
}
|
|
});
|
|
onScopeDispose(() => cleanup());
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/dialog/src/use-dialog.mjs
|
|
var useDialog = (props2, targetRef) => {
|
|
var _a2;
|
|
const instance = getCurrentInstance();
|
|
const emit = instance.emit;
|
|
const { nextZIndex } = useZIndex();
|
|
let lastPosition = "";
|
|
const titleId = useId();
|
|
const bodyId = useId();
|
|
const visible = ref(false);
|
|
const closed = ref(false);
|
|
const rendered = ref(false);
|
|
const zIndex2 = ref((_a2 = props2.zIndex) != null ? _a2 : nextZIndex());
|
|
let openTimer = void 0;
|
|
let closeTimer = void 0;
|
|
const namespace = useGlobalConfig("namespace", defaultNamespace);
|
|
const style = computed(() => {
|
|
const style2 = {};
|
|
const varPrefix = `--${namespace.value}-dialog`;
|
|
if (!props2.fullscreen) {
|
|
if (props2.top) {
|
|
style2[`${varPrefix}-margin-top`] = props2.top;
|
|
}
|
|
if (props2.width) {
|
|
style2[`${varPrefix}-width`] = addUnit(props2.width);
|
|
}
|
|
}
|
|
return style2;
|
|
});
|
|
const overlayDialogStyle = computed(() => {
|
|
if (props2.alignCenter) {
|
|
return { display: "flex" };
|
|
}
|
|
return {};
|
|
});
|
|
function afterEnter() {
|
|
emit("opened");
|
|
}
|
|
function afterLeave() {
|
|
emit("closed");
|
|
emit(UPDATE_MODEL_EVENT, false);
|
|
if (props2.destroyOnClose) {
|
|
rendered.value = false;
|
|
}
|
|
}
|
|
function beforeLeave() {
|
|
emit("close");
|
|
}
|
|
function open() {
|
|
closeTimer == null ? void 0 : closeTimer();
|
|
openTimer == null ? void 0 : openTimer();
|
|
if (props2.openDelay && props2.openDelay > 0) {
|
|
({ stop: openTimer } = useTimeoutFn(() => doOpen(), props2.openDelay));
|
|
} else {
|
|
doOpen();
|
|
}
|
|
}
|
|
function close2() {
|
|
openTimer == null ? void 0 : openTimer();
|
|
closeTimer == null ? void 0 : closeTimer();
|
|
if (props2.closeDelay && props2.closeDelay > 0) {
|
|
({ stop: closeTimer } = useTimeoutFn(() => doClose(), props2.closeDelay));
|
|
} else {
|
|
doClose();
|
|
}
|
|
}
|
|
function handleClose() {
|
|
function hide2(shouldCancel) {
|
|
if (shouldCancel)
|
|
return;
|
|
closed.value = true;
|
|
visible.value = false;
|
|
}
|
|
if (props2.beforeClose) {
|
|
props2.beforeClose(hide2);
|
|
} else {
|
|
close2();
|
|
}
|
|
}
|
|
function onModalClick() {
|
|
if (props2.closeOnClickModal) {
|
|
handleClose();
|
|
}
|
|
}
|
|
function doOpen() {
|
|
if (!isClient)
|
|
return;
|
|
visible.value = true;
|
|
}
|
|
function doClose() {
|
|
visible.value = false;
|
|
}
|
|
function onOpenAutoFocus() {
|
|
emit("openAutoFocus");
|
|
}
|
|
function onCloseAutoFocus() {
|
|
emit("closeAutoFocus");
|
|
}
|
|
function onFocusoutPrevented(event) {
|
|
var _a22;
|
|
if (((_a22 = event.detail) == null ? void 0 : _a22.focusReason) === "pointer") {
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
if (props2.lockScroll) {
|
|
useLockscreen(visible);
|
|
}
|
|
function onCloseRequested() {
|
|
if (props2.closeOnPressEscape) {
|
|
handleClose();
|
|
}
|
|
}
|
|
watch(() => props2.modelValue, (val) => {
|
|
if (val) {
|
|
closed.value = false;
|
|
open();
|
|
rendered.value = true;
|
|
zIndex2.value = isUndefined_default(props2.zIndex) ? nextZIndex() : zIndex2.value++;
|
|
nextTick(() => {
|
|
emit("open");
|
|
if (targetRef.value) {
|
|
targetRef.value.parentElement.scrollTop = 0;
|
|
targetRef.value.parentElement.scrollLeft = 0;
|
|
targetRef.value.scrollTop = 0;
|
|
}
|
|
});
|
|
} else {
|
|
if (visible.value) {
|
|
close2();
|
|
}
|
|
}
|
|
});
|
|
watch(() => props2.fullscreen, (val) => {
|
|
if (!targetRef.value)
|
|
return;
|
|
if (val) {
|
|
lastPosition = targetRef.value.style.transform;
|
|
targetRef.value.style.transform = "";
|
|
} else {
|
|
targetRef.value.style.transform = lastPosition;
|
|
}
|
|
});
|
|
onMounted(() => {
|
|
if (props2.modelValue) {
|
|
visible.value = true;
|
|
rendered.value = true;
|
|
open();
|
|
}
|
|
});
|
|
return {
|
|
afterEnter,
|
|
afterLeave,
|
|
beforeLeave,
|
|
handleClose,
|
|
onModalClick,
|
|
close: close2,
|
|
doClose,
|
|
onOpenAutoFocus,
|
|
onCloseAutoFocus,
|
|
onCloseRequested,
|
|
onFocusoutPrevented,
|
|
titleId,
|
|
bodyId,
|
|
closed,
|
|
style,
|
|
overlayDialogStyle,
|
|
rendered,
|
|
visible,
|
|
zIndex: zIndex2
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/utils/vue/refs.mjs
|
|
var composeRefs = (...refs) => {
|
|
return (el) => {
|
|
refs.forEach((ref2) => {
|
|
if (isFunction(ref2)) {
|
|
ref2(el);
|
|
} else {
|
|
ref2.value = el;
|
|
}
|
|
});
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/dialog/src/dialog-content2.mjs
|
|
var __default__52 = defineComponent({ name: "ElDialogContent" });
|
|
var _sfc_main70 = defineComponent({
|
|
...__default__52,
|
|
props: dialogContentProps,
|
|
emits: dialogContentEmits,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const { t } = useLocale();
|
|
const { Close } = CloseComponents;
|
|
const { dialogRef, headerRef, bodyId, ns, style } = inject(dialogInjectionKey);
|
|
const { focusTrapRef } = inject(FOCUS_TRAP_INJECTION_KEY);
|
|
const dialogKls = computed(() => [
|
|
ns.b(),
|
|
ns.is("fullscreen", props2.fullscreen),
|
|
ns.is("draggable", props2.draggable),
|
|
ns.is("align-center", props2.alignCenter),
|
|
{ [ns.m("center")]: props2.center }
|
|
]);
|
|
const composedDialogRef = composeRefs(focusTrapRef, dialogRef);
|
|
const draggable2 = computed(() => props2.draggable);
|
|
const overflow = computed(() => props2.overflow);
|
|
const { resetPosition, updatePosition } = useDraggable(dialogRef, headerRef, draggable2, overflow);
|
|
expose({
|
|
resetPosition,
|
|
updatePosition
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref: unref(composedDialogRef),
|
|
class: normalizeClass(unref(dialogKls)),
|
|
style: normalizeStyle(unref(style)),
|
|
tabindex: "-1"
|
|
}, [
|
|
createBaseVNode("header", {
|
|
ref_key: "headerRef",
|
|
ref: headerRef,
|
|
class: normalizeClass([unref(ns).e("header"), _ctx.headerClass, { "show-close": _ctx.showClose }])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "header", {}, () => [
|
|
createBaseVNode("span", {
|
|
role: "heading",
|
|
"aria-level": _ctx.ariaLevel,
|
|
class: normalizeClass(unref(ns).e("title"))
|
|
}, toDisplayString(_ctx.title), 11, ["aria-level"])
|
|
]),
|
|
_ctx.showClose ? (openBlock(), createElementBlock("button", {
|
|
key: 0,
|
|
"aria-label": unref(t)("el.dialog.close"),
|
|
class: normalizeClass(unref(ns).e("headerbtn")),
|
|
type: "button",
|
|
onClick: ($event) => _ctx.$emit("close")
|
|
}, [
|
|
createVNode(unref(ElIcon), {
|
|
class: normalizeClass(unref(ns).e("close"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.closeIcon || unref(Close))))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])
|
|
], 10, ["aria-label", "onClick"])) : createCommentVNode("v-if", true)
|
|
], 2),
|
|
createBaseVNode("div", {
|
|
id: unref(bodyId),
|
|
class: normalizeClass([unref(ns).e("body"), _ctx.bodyClass])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 10, ["id"]),
|
|
_ctx.$slots.footer ? (openBlock(), createElementBlock("footer", {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("footer"), _ctx.footerClass])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "footer")
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 6);
|
|
};
|
|
}
|
|
});
|
|
var ElDialogContent = _export_sfc(_sfc_main70, [["__file", "dialog-content.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/dialog/src/dialog.mjs
|
|
var __default__53 = defineComponent({
|
|
name: "ElDialog",
|
|
inheritAttrs: false
|
|
});
|
|
var _sfc_main71 = defineComponent({
|
|
...__default__53,
|
|
props: dialogProps,
|
|
emits: dialogEmits,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const slots = useSlots();
|
|
useDeprecated({
|
|
scope: "el-dialog",
|
|
from: "the title slot",
|
|
replacement: "the header slot",
|
|
version: "3.0.0",
|
|
ref: "https://element-plus.org/en-US/component/dialog.html#slots"
|
|
}, computed(() => !!slots.title));
|
|
const ns = useNamespace("dialog");
|
|
const dialogRef = ref();
|
|
const headerRef = ref();
|
|
const dialogContentRef = ref();
|
|
const {
|
|
visible,
|
|
titleId,
|
|
bodyId,
|
|
style,
|
|
overlayDialogStyle,
|
|
rendered,
|
|
zIndex: zIndex2,
|
|
afterEnter,
|
|
afterLeave,
|
|
beforeLeave,
|
|
handleClose,
|
|
onModalClick,
|
|
onOpenAutoFocus,
|
|
onCloseAutoFocus,
|
|
onCloseRequested,
|
|
onFocusoutPrevented
|
|
} = useDialog(props2, dialogRef);
|
|
provide(dialogInjectionKey, {
|
|
dialogRef,
|
|
headerRef,
|
|
bodyId,
|
|
ns,
|
|
rendered,
|
|
style
|
|
});
|
|
const overlayEvent = useSameTarget(onModalClick);
|
|
const draggable2 = computed(() => props2.draggable && !props2.fullscreen);
|
|
const resetPosition = () => {
|
|
var _a2;
|
|
(_a2 = dialogContentRef.value) == null ? void 0 : _a2.resetPosition();
|
|
};
|
|
expose({
|
|
visible,
|
|
dialogContentRef,
|
|
resetPosition,
|
|
handleClose
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElTeleport), {
|
|
to: _ctx.appendTo,
|
|
disabled: _ctx.appendTo !== "body" ? false : !_ctx.appendToBody
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(Transition, {
|
|
name: "dialog-fade",
|
|
onAfterEnter: unref(afterEnter),
|
|
onAfterLeave: unref(afterLeave),
|
|
onBeforeLeave: unref(beforeLeave),
|
|
persisted: ""
|
|
}, {
|
|
default: withCtx(() => [
|
|
withDirectives(createVNode(unref(ElOverlay), {
|
|
"custom-mask-event": "",
|
|
mask: _ctx.modal,
|
|
"overlay-class": _ctx.modalClass,
|
|
"z-index": unref(zIndex2)
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
role: "dialog",
|
|
"aria-modal": "true",
|
|
"aria-label": _ctx.title || void 0,
|
|
"aria-labelledby": !_ctx.title ? unref(titleId) : void 0,
|
|
"aria-describedby": unref(bodyId),
|
|
class: normalizeClass(`${unref(ns).namespace.value}-overlay-dialog`),
|
|
style: normalizeStyle(unref(overlayDialogStyle)),
|
|
onClick: unref(overlayEvent).onClick,
|
|
onMousedown: unref(overlayEvent).onMousedown,
|
|
onMouseup: unref(overlayEvent).onMouseup
|
|
}, [
|
|
createVNode(unref(ElFocusTrap), {
|
|
loop: "",
|
|
trapped: unref(visible),
|
|
"focus-start-el": "container",
|
|
onFocusAfterTrapped: unref(onOpenAutoFocus),
|
|
onFocusAfterReleased: unref(onCloseAutoFocus),
|
|
onFocusoutPrevented: unref(onFocusoutPrevented),
|
|
onReleaseRequested: unref(onCloseRequested)
|
|
}, {
|
|
default: withCtx(() => [
|
|
unref(rendered) ? (openBlock(), createBlock(ElDialogContent, mergeProps({
|
|
key: 0,
|
|
ref_key: "dialogContentRef",
|
|
ref: dialogContentRef
|
|
}, _ctx.$attrs, {
|
|
center: _ctx.center,
|
|
"align-center": _ctx.alignCenter,
|
|
"close-icon": _ctx.closeIcon,
|
|
draggable: unref(draggable2),
|
|
overflow: _ctx.overflow,
|
|
fullscreen: _ctx.fullscreen,
|
|
"header-class": _ctx.headerClass,
|
|
"body-class": _ctx.bodyClass,
|
|
"footer-class": _ctx.footerClass,
|
|
"show-close": _ctx.showClose,
|
|
title: _ctx.title,
|
|
"aria-level": _ctx.headerAriaLevel,
|
|
onClose: unref(handleClose)
|
|
}), createSlots({
|
|
header: withCtx(() => [
|
|
!_ctx.$slots.title ? renderSlot(_ctx.$slots, "header", {
|
|
key: 0,
|
|
close: unref(handleClose),
|
|
titleId: unref(titleId),
|
|
titleClass: unref(ns).e("title")
|
|
}) : renderSlot(_ctx.$slots, "title", { key: 1 })
|
|
]),
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 2
|
|
}, [
|
|
_ctx.$slots.footer ? {
|
|
name: "footer",
|
|
fn: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "footer")
|
|
])
|
|
} : void 0
|
|
]), 1040, ["center", "align-center", "close-icon", "draggable", "overflow", "fullscreen", "header-class", "body-class", "footer-class", "show-close", "title", "aria-level", "onClose"])) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 8, ["trapped", "onFocusAfterTrapped", "onFocusAfterReleased", "onFocusoutPrevented", "onReleaseRequested"])
|
|
], 46, ["aria-label", "aria-labelledby", "aria-describedby", "onClick", "onMousedown", "onMouseup"])
|
|
]),
|
|
_: 3
|
|
}, 8, ["mask", "overlay-class", "z-index"]), [
|
|
[vShow, unref(visible)]
|
|
])
|
|
]),
|
|
_: 3
|
|
}, 8, ["onAfterEnter", "onAfterLeave", "onBeforeLeave"])
|
|
]),
|
|
_: 3
|
|
}, 8, ["to", "disabled"]);
|
|
};
|
|
}
|
|
});
|
|
var Dialog = _export_sfc(_sfc_main71, [["__file", "dialog.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/dialog/index.mjs
|
|
var ElDialog = withInstall(Dialog);
|
|
|
|
// node_modules/element-plus/es/components/divider/src/divider.mjs
|
|
var dividerProps = buildProps({
|
|
direction: {
|
|
type: String,
|
|
values: ["horizontal", "vertical"],
|
|
default: "horizontal"
|
|
},
|
|
contentPosition: {
|
|
type: String,
|
|
values: ["left", "center", "right"],
|
|
default: "center"
|
|
},
|
|
borderStyle: {
|
|
type: definePropType(String),
|
|
default: "solid"
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/divider/src/divider2.mjs
|
|
var __default__54 = defineComponent({
|
|
name: "ElDivider"
|
|
});
|
|
var _sfc_main72 = defineComponent({
|
|
...__default__54,
|
|
props: dividerProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("divider");
|
|
const dividerStyle = computed(() => {
|
|
return ns.cssVar({
|
|
"border-style": props2.borderStyle
|
|
});
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([unref(ns).b(), unref(ns).m(_ctx.direction)]),
|
|
style: normalizeStyle(unref(dividerStyle)),
|
|
role: "separator"
|
|
}, [
|
|
_ctx.$slots.default && _ctx.direction !== "vertical" ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("text"), unref(ns).is(_ctx.contentPosition)])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 6);
|
|
};
|
|
}
|
|
});
|
|
var Divider = _export_sfc(_sfc_main72, [["__file", "divider.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/divider/index.mjs
|
|
var ElDivider = withInstall(Divider);
|
|
|
|
// node_modules/element-plus/es/components/drawer/src/drawer2.mjs
|
|
var drawerProps = buildProps({
|
|
...dialogProps,
|
|
direction: {
|
|
type: String,
|
|
default: "rtl",
|
|
values: ["ltr", "rtl", "ttb", "btt"]
|
|
},
|
|
size: {
|
|
type: [String, Number],
|
|
default: "30%"
|
|
},
|
|
withHeader: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
modalFade: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
headerAriaLevel: {
|
|
type: String,
|
|
default: "2"
|
|
}
|
|
});
|
|
var drawerEmits = dialogEmits;
|
|
|
|
// node_modules/element-plus/es/components/drawer/src/drawer.mjs
|
|
var __default__55 = defineComponent({
|
|
name: "ElDrawer",
|
|
inheritAttrs: false
|
|
});
|
|
var _sfc_main73 = defineComponent({
|
|
...__default__55,
|
|
props: drawerProps,
|
|
emits: drawerEmits,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const slots = useSlots();
|
|
useDeprecated({
|
|
scope: "el-drawer",
|
|
from: "the title slot",
|
|
replacement: "the header slot",
|
|
version: "3.0.0",
|
|
ref: "https://element-plus.org/en-US/component/drawer.html#slots"
|
|
}, computed(() => !!slots.title));
|
|
const drawerRef = ref();
|
|
const focusStartRef = ref();
|
|
const ns = useNamespace("drawer");
|
|
const { t } = useLocale();
|
|
const {
|
|
afterEnter,
|
|
afterLeave,
|
|
beforeLeave,
|
|
visible,
|
|
rendered,
|
|
titleId,
|
|
bodyId,
|
|
zIndex: zIndex2,
|
|
onModalClick,
|
|
onOpenAutoFocus,
|
|
onCloseAutoFocus,
|
|
onFocusoutPrevented,
|
|
onCloseRequested,
|
|
handleClose
|
|
} = useDialog(props2, drawerRef);
|
|
const isHorizontal2 = computed(() => props2.direction === "rtl" || props2.direction === "ltr");
|
|
const drawerSize = computed(() => addUnit(props2.size));
|
|
expose({
|
|
handleClose,
|
|
afterEnter,
|
|
afterLeave
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElTeleport), {
|
|
to: _ctx.appendTo,
|
|
disabled: _ctx.appendTo !== "body" ? false : !_ctx.appendToBody
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(Transition, {
|
|
name: unref(ns).b("fade"),
|
|
onAfterEnter: unref(afterEnter),
|
|
onAfterLeave: unref(afterLeave),
|
|
onBeforeLeave: unref(beforeLeave),
|
|
persisted: ""
|
|
}, {
|
|
default: withCtx(() => [
|
|
withDirectives(createVNode(unref(ElOverlay), {
|
|
mask: _ctx.modal,
|
|
"overlay-class": _ctx.modalClass,
|
|
"z-index": unref(zIndex2),
|
|
onClick: unref(onModalClick)
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(ElFocusTrap), {
|
|
loop: "",
|
|
trapped: unref(visible),
|
|
"focus-trap-el": drawerRef.value,
|
|
"focus-start-el": focusStartRef.value,
|
|
onFocusAfterTrapped: unref(onOpenAutoFocus),
|
|
onFocusAfterReleased: unref(onCloseAutoFocus),
|
|
onFocusoutPrevented: unref(onFocusoutPrevented),
|
|
onReleaseRequested: unref(onCloseRequested)
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("div", mergeProps({
|
|
ref_key: "drawerRef",
|
|
ref: drawerRef,
|
|
"aria-modal": "true",
|
|
"aria-label": _ctx.title || void 0,
|
|
"aria-labelledby": !_ctx.title ? unref(titleId) : void 0,
|
|
"aria-describedby": unref(bodyId)
|
|
}, _ctx.$attrs, {
|
|
class: [unref(ns).b(), _ctx.direction, unref(visible) && "open"],
|
|
style: unref(isHorizontal2) ? "width: " + unref(drawerSize) : "height: " + unref(drawerSize),
|
|
role: "dialog",
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"])
|
|
}), [
|
|
createBaseVNode("span", {
|
|
ref_key: "focusStartRef",
|
|
ref: focusStartRef,
|
|
class: normalizeClass(unref(ns).e("sr-focus")),
|
|
tabindex: "-1"
|
|
}, null, 2),
|
|
_ctx.withHeader ? (openBlock(), createElementBlock("header", {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("header"), _ctx.headerClass])
|
|
}, [
|
|
!_ctx.$slots.title ? renderSlot(_ctx.$slots, "header", {
|
|
key: 0,
|
|
close: unref(handleClose),
|
|
titleId: unref(titleId),
|
|
titleClass: unref(ns).e("title")
|
|
}, () => [
|
|
!_ctx.$slots.title ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
id: unref(titleId),
|
|
role: "heading",
|
|
"aria-level": _ctx.headerAriaLevel,
|
|
class: normalizeClass(unref(ns).e("title"))
|
|
}, toDisplayString(_ctx.title), 11, ["id", "aria-level"])) : createCommentVNode("v-if", true)
|
|
]) : renderSlot(_ctx.$slots, "title", { key: 1 }, () => [
|
|
createCommentVNode(" DEPRECATED SLOT ")
|
|
]),
|
|
_ctx.showClose ? (openBlock(), createElementBlock("button", {
|
|
key: 2,
|
|
"aria-label": unref(t)("el.drawer.close"),
|
|
class: normalizeClass(unref(ns).e("close-btn")),
|
|
type: "button",
|
|
onClick: unref(handleClose)
|
|
}, [
|
|
createVNode(unref(ElIcon), {
|
|
class: normalizeClass(unref(ns).e("close"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(close_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])
|
|
], 10, ["aria-label", "onClick"])) : createCommentVNode("v-if", true)
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
unref(rendered) ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
id: unref(bodyId),
|
|
class: normalizeClass([unref(ns).e("body"), _ctx.bodyClass])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 10, ["id"])) : createCommentVNode("v-if", true),
|
|
_ctx.$slots.footer ? (openBlock(), createElementBlock("div", {
|
|
key: 2,
|
|
class: normalizeClass([unref(ns).e("footer"), _ctx.footerClass])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "footer")
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 16, ["aria-label", "aria-labelledby", "aria-describedby", "onClick"])
|
|
]),
|
|
_: 3
|
|
}, 8, ["trapped", "focus-trap-el", "focus-start-el", "onFocusAfterTrapped", "onFocusAfterReleased", "onFocusoutPrevented", "onReleaseRequested"])
|
|
]),
|
|
_: 3
|
|
}, 8, ["mask", "overlay-class", "z-index", "onClick"]), [
|
|
[vShow, unref(visible)]
|
|
])
|
|
]),
|
|
_: 3
|
|
}, 8, ["name", "onAfterEnter", "onAfterLeave", "onBeforeLeave"])
|
|
]),
|
|
_: 3
|
|
}, 8, ["to", "disabled"]);
|
|
};
|
|
}
|
|
});
|
|
var Drawer = _export_sfc(_sfc_main73, [["__file", "drawer.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/drawer/index.mjs
|
|
var ElDrawer = withInstall(Drawer);
|
|
|
|
// node_modules/element-plus/es/components/collection/src/collection2.mjs
|
|
var _sfc_main74 = defineComponent({
|
|
inheritAttrs: false
|
|
});
|
|
function _sfc_render8(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return renderSlot(_ctx.$slots, "default");
|
|
}
|
|
var Collection = _export_sfc(_sfc_main74, [["render", _sfc_render8], ["__file", "collection.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/collection/src/collection-item.mjs
|
|
var _sfc_main75 = defineComponent({
|
|
name: "ElCollectionItem",
|
|
inheritAttrs: false
|
|
});
|
|
function _sfc_render9(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return renderSlot(_ctx.$slots, "default");
|
|
}
|
|
var CollectionItem = _export_sfc(_sfc_main75, [["render", _sfc_render9], ["__file", "collection-item.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/collection/src/collection.mjs
|
|
var COLLECTION_ITEM_SIGN = `data-el-collection-item`;
|
|
var createCollectionWithScope = (name) => {
|
|
const COLLECTION_NAME = `El${name}Collection`;
|
|
const COLLECTION_ITEM_NAME = `${COLLECTION_NAME}Item`;
|
|
const COLLECTION_INJECTION_KEY3 = Symbol(COLLECTION_NAME);
|
|
const COLLECTION_ITEM_INJECTION_KEY3 = Symbol(COLLECTION_ITEM_NAME);
|
|
const ElCollection3 = {
|
|
...Collection,
|
|
name: COLLECTION_NAME,
|
|
setup() {
|
|
const collectionRef = ref();
|
|
const itemMap = new Map();
|
|
const getItems = () => {
|
|
const collectionEl = unref(collectionRef);
|
|
if (!collectionEl)
|
|
return [];
|
|
const orderedNodes = Array.from(collectionEl.querySelectorAll(`[${COLLECTION_ITEM_SIGN}]`));
|
|
const items = [...itemMap.values()];
|
|
return items.sort((a2, b2) => orderedNodes.indexOf(a2.ref) - orderedNodes.indexOf(b2.ref));
|
|
};
|
|
provide(COLLECTION_INJECTION_KEY3, {
|
|
itemMap,
|
|
getItems,
|
|
collectionRef
|
|
});
|
|
}
|
|
};
|
|
const ElCollectionItem3 = {
|
|
...CollectionItem,
|
|
name: COLLECTION_ITEM_NAME,
|
|
setup(_2, { attrs }) {
|
|
const collectionItemRef = ref();
|
|
const collectionInjection = inject(COLLECTION_INJECTION_KEY3, void 0);
|
|
provide(COLLECTION_ITEM_INJECTION_KEY3, {
|
|
collectionItemRef
|
|
});
|
|
onMounted(() => {
|
|
const collectionItemEl = unref(collectionItemRef);
|
|
if (collectionItemEl) {
|
|
collectionInjection.itemMap.set(collectionItemEl, {
|
|
ref: collectionItemEl,
|
|
...attrs
|
|
});
|
|
}
|
|
});
|
|
onBeforeUnmount(() => {
|
|
const collectionItemEl = unref(collectionItemRef);
|
|
collectionInjection.itemMap.delete(collectionItemEl);
|
|
});
|
|
}
|
|
};
|
|
return {
|
|
COLLECTION_INJECTION_KEY: COLLECTION_INJECTION_KEY3,
|
|
COLLECTION_ITEM_INJECTION_KEY: COLLECTION_ITEM_INJECTION_KEY3,
|
|
ElCollection: ElCollection3,
|
|
ElCollectionItem: ElCollectionItem3
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/dropdown.mjs
|
|
var dropdownProps = buildProps({
|
|
trigger: useTooltipTriggerProps.trigger,
|
|
triggerKeys: {
|
|
type: definePropType(Array),
|
|
default: () => [
|
|
EVENT_CODE.enter,
|
|
EVENT_CODE.numpadEnter,
|
|
EVENT_CODE.space,
|
|
EVENT_CODE.down
|
|
]
|
|
},
|
|
effect: {
|
|
...useTooltipContentProps.effect,
|
|
default: "light"
|
|
},
|
|
type: {
|
|
type: definePropType(String)
|
|
},
|
|
placement: {
|
|
type: definePropType(String),
|
|
default: "bottom"
|
|
},
|
|
popperOptions: {
|
|
type: definePropType(Object),
|
|
default: () => ({})
|
|
},
|
|
id: String,
|
|
size: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
splitButton: Boolean,
|
|
hideOnClick: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
loop: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
showTimeout: {
|
|
type: Number,
|
|
default: 150
|
|
},
|
|
hideTimeout: {
|
|
type: Number,
|
|
default: 150
|
|
},
|
|
tabindex: {
|
|
type: definePropType([Number, String]),
|
|
default: 0
|
|
},
|
|
maxHeight: {
|
|
type: definePropType([Number, String]),
|
|
default: ""
|
|
},
|
|
popperClass: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
disabled: Boolean,
|
|
role: {
|
|
type: String,
|
|
values: roleTypes,
|
|
default: "menu"
|
|
},
|
|
buttonProps: {
|
|
type: definePropType(Object)
|
|
},
|
|
teleported: useTooltipContentProps.teleported,
|
|
persistent: {
|
|
type: Boolean,
|
|
default: true
|
|
}
|
|
});
|
|
var dropdownItemProps = buildProps({
|
|
command: {
|
|
type: [Object, String, Number],
|
|
default: () => ({})
|
|
},
|
|
disabled: Boolean,
|
|
divided: Boolean,
|
|
textValue: String,
|
|
icon: {
|
|
type: iconPropType
|
|
}
|
|
});
|
|
var dropdownMenuProps = buildProps({
|
|
onKeydown: { type: definePropType(Function) }
|
|
});
|
|
var FIRST_KEYS = [
|
|
EVENT_CODE.down,
|
|
EVENT_CODE.pageDown,
|
|
EVENT_CODE.home
|
|
];
|
|
var LAST_KEYS = [EVENT_CODE.up, EVENT_CODE.pageUp, EVENT_CODE.end];
|
|
var FIRST_LAST_KEYS = [...FIRST_KEYS, ...LAST_KEYS];
|
|
var {
|
|
ElCollection,
|
|
ElCollectionItem,
|
|
COLLECTION_INJECTION_KEY,
|
|
COLLECTION_ITEM_INJECTION_KEY
|
|
} = createCollectionWithScope("Dropdown");
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/tokens.mjs
|
|
var DROPDOWN_INJECTION_KEY = Symbol("elDropdown");
|
|
|
|
// node_modules/element-plus/es/components/roving-focus-group/src/roving-focus-group.mjs
|
|
var rovingFocusGroupProps = buildProps({
|
|
style: { type: definePropType([String, Array, Object]) },
|
|
currentTabId: {
|
|
type: definePropType(String)
|
|
},
|
|
defaultCurrentTabId: String,
|
|
loop: Boolean,
|
|
dir: {
|
|
type: String,
|
|
values: ["ltr", "rtl"],
|
|
default: "ltr"
|
|
},
|
|
orientation: {
|
|
type: definePropType(String)
|
|
},
|
|
onBlur: Function,
|
|
onFocus: Function,
|
|
onMousedown: Function
|
|
});
|
|
var {
|
|
ElCollection: ElCollection2,
|
|
ElCollectionItem: ElCollectionItem2,
|
|
COLLECTION_INJECTION_KEY: COLLECTION_INJECTION_KEY2,
|
|
COLLECTION_ITEM_INJECTION_KEY: COLLECTION_ITEM_INJECTION_KEY2
|
|
} = createCollectionWithScope("RovingFocusGroup");
|
|
|
|
// node_modules/element-plus/es/components/roving-focus-group/src/tokens.mjs
|
|
var ROVING_FOCUS_GROUP_INJECTION_KEY = Symbol("elRovingFocusGroup");
|
|
var ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY = Symbol("elRovingFocusGroupItem");
|
|
|
|
// node_modules/element-plus/es/components/roving-focus-group/src/utils.mjs
|
|
var MAP_KEY_TO_FOCUS_INTENT = {
|
|
ArrowLeft: "prev",
|
|
ArrowUp: "prev",
|
|
ArrowRight: "next",
|
|
ArrowDown: "next",
|
|
PageUp: "first",
|
|
Home: "first",
|
|
PageDown: "last",
|
|
End: "last"
|
|
};
|
|
var getDirectionAwareKey = (key, dir) => {
|
|
if (dir !== "rtl")
|
|
return key;
|
|
switch (key) {
|
|
case EVENT_CODE.right:
|
|
return EVENT_CODE.left;
|
|
case EVENT_CODE.left:
|
|
return EVENT_CODE.right;
|
|
default:
|
|
return key;
|
|
}
|
|
};
|
|
var getFocusIntent = (event, orientation, dir) => {
|
|
const key = getDirectionAwareKey(event.code, dir);
|
|
if (orientation === "vertical" && [EVENT_CODE.left, EVENT_CODE.right].includes(key))
|
|
return void 0;
|
|
if (orientation === "horizontal" && [EVENT_CODE.up, EVENT_CODE.down].includes(key))
|
|
return void 0;
|
|
return MAP_KEY_TO_FOCUS_INTENT[key];
|
|
};
|
|
var reorderArray = (array4, atIdx) => {
|
|
return array4.map((_2, idx) => array4[(idx + atIdx) % array4.length]);
|
|
};
|
|
var focusFirst = (elements) => {
|
|
const { activeElement: prevActive } = document;
|
|
for (const element of elements) {
|
|
if (element === prevActive)
|
|
return;
|
|
element.focus();
|
|
if (prevActive !== document.activeElement)
|
|
return;
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/roving-focus-group/src/roving-focus-group-impl.mjs
|
|
var CURRENT_TAB_ID_CHANGE_EVT = "currentTabIdChange";
|
|
var ENTRY_FOCUS_EVT = "rovingFocusGroup.entryFocus";
|
|
var EVT_OPTS = { bubbles: false, cancelable: true };
|
|
var _sfc_main76 = defineComponent({
|
|
name: "ElRovingFocusGroupImpl",
|
|
inheritAttrs: false,
|
|
props: rovingFocusGroupProps,
|
|
emits: [CURRENT_TAB_ID_CHANGE_EVT, "entryFocus"],
|
|
setup(props2, { emit }) {
|
|
var _a2;
|
|
const currentTabbedId = ref((_a2 = props2.currentTabId || props2.defaultCurrentTabId) != null ? _a2 : null);
|
|
const isBackingOut = ref(false);
|
|
const isClickFocus = ref(false);
|
|
const rovingFocusGroupRef = ref();
|
|
const { getItems } = inject(COLLECTION_INJECTION_KEY2, void 0);
|
|
const rovingFocusGroupRootStyle = computed(() => {
|
|
return [
|
|
{
|
|
outline: "none"
|
|
},
|
|
props2.style
|
|
];
|
|
});
|
|
const onItemFocus = (tabbedId) => {
|
|
emit(CURRENT_TAB_ID_CHANGE_EVT, tabbedId);
|
|
};
|
|
const onItemShiftTab = () => {
|
|
isBackingOut.value = true;
|
|
};
|
|
const onMousedown = composeEventHandlers((e) => {
|
|
var _a22;
|
|
(_a22 = props2.onMousedown) == null ? void 0 : _a22.call(props2, e);
|
|
}, () => {
|
|
isClickFocus.value = true;
|
|
});
|
|
const onFocus = composeEventHandlers((e) => {
|
|
var _a22;
|
|
(_a22 = props2.onFocus) == null ? void 0 : _a22.call(props2, e);
|
|
}, (e) => {
|
|
const isKeyboardFocus = !unref(isClickFocus);
|
|
const { target: target2, currentTarget } = e;
|
|
if (target2 === currentTarget && isKeyboardFocus && !unref(isBackingOut)) {
|
|
const entryFocusEvt = new Event(ENTRY_FOCUS_EVT, EVT_OPTS);
|
|
currentTarget == null ? void 0 : currentTarget.dispatchEvent(entryFocusEvt);
|
|
if (!entryFocusEvt.defaultPrevented) {
|
|
const items = getItems().filter((item) => item.focusable);
|
|
const activeItem = items.find((item) => item.active);
|
|
const currentItem = items.find((item) => item.id === unref(currentTabbedId));
|
|
const candidates = [activeItem, currentItem, ...items].filter(Boolean);
|
|
const candidateNodes = candidates.map((item) => item.ref);
|
|
focusFirst(candidateNodes);
|
|
}
|
|
}
|
|
isClickFocus.value = false;
|
|
});
|
|
const onBlur = composeEventHandlers((e) => {
|
|
var _a22;
|
|
(_a22 = props2.onBlur) == null ? void 0 : _a22.call(props2, e);
|
|
}, () => {
|
|
isBackingOut.value = false;
|
|
});
|
|
const handleEntryFocus = (...args) => {
|
|
emit("entryFocus", ...args);
|
|
};
|
|
provide(ROVING_FOCUS_GROUP_INJECTION_KEY, {
|
|
currentTabbedId: readonly(currentTabbedId),
|
|
loop: toRef(props2, "loop"),
|
|
tabIndex: computed(() => {
|
|
return unref(isBackingOut) ? -1 : 0;
|
|
}),
|
|
rovingFocusGroupRef,
|
|
rovingFocusGroupRootStyle,
|
|
orientation: toRef(props2, "orientation"),
|
|
dir: toRef(props2, "dir"),
|
|
onItemFocus,
|
|
onItemShiftTab,
|
|
onBlur,
|
|
onFocus,
|
|
onMousedown
|
|
});
|
|
watch(() => props2.currentTabId, (val) => {
|
|
currentTabbedId.value = val != null ? val : null;
|
|
});
|
|
useEventListener(rovingFocusGroupRef, ENTRY_FOCUS_EVT, handleEntryFocus);
|
|
}
|
|
});
|
|
function _sfc_render10(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return renderSlot(_ctx.$slots, "default");
|
|
}
|
|
var ElRovingFocusGroupImpl = _export_sfc(_sfc_main76, [["render", _sfc_render10], ["__file", "roving-focus-group-impl.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/roving-focus-group/src/roving-focus-group2.mjs
|
|
var _sfc_main77 = defineComponent({
|
|
name: "ElRovingFocusGroup",
|
|
components: {
|
|
ElFocusGroupCollection: ElCollection2,
|
|
ElRovingFocusGroupImpl
|
|
}
|
|
});
|
|
function _sfc_render11(_ctx, _cache, $props, $setup, $data, $options) {
|
|
const _component_el_roving_focus_group_impl = resolveComponent("el-roving-focus-group-impl");
|
|
const _component_el_focus_group_collection = resolveComponent("el-focus-group-collection");
|
|
return openBlock(), createBlock(_component_el_focus_group_collection, null, {
|
|
default: withCtx(() => [
|
|
createVNode(_component_el_roving_focus_group_impl, normalizeProps(guardReactiveProps(_ctx.$attrs)), {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 16)
|
|
]),
|
|
_: 3
|
|
});
|
|
}
|
|
var ElRovingFocusGroup = _export_sfc(_sfc_main77, [["render", _sfc_render11], ["__file", "roving-focus-group.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/dropdown2.mjs
|
|
var { ButtonGroup: ElButtonGroup2 } = ElButton;
|
|
var _sfc_main78 = defineComponent({
|
|
name: "ElDropdown",
|
|
components: {
|
|
ElButton,
|
|
ElButtonGroup: ElButtonGroup2,
|
|
ElScrollbar,
|
|
ElDropdownCollection: ElCollection,
|
|
ElTooltip,
|
|
ElRovingFocusGroup,
|
|
ElOnlyChild: OnlyChild,
|
|
ElIcon,
|
|
ArrowDown: arrow_down_default
|
|
},
|
|
props: dropdownProps,
|
|
emits: ["visible-change", "click", "command"],
|
|
setup(props2, { emit }) {
|
|
const _instance = getCurrentInstance();
|
|
const ns = useNamespace("dropdown");
|
|
const { t } = useLocale();
|
|
const triggeringElementRef = ref();
|
|
const referenceElementRef = ref();
|
|
const popperRef = ref();
|
|
const contentRef = ref();
|
|
const scrollbar = ref(null);
|
|
const currentTabId = ref(null);
|
|
const isUsingKeyboard = ref(false);
|
|
const wrapStyle = computed(() => ({
|
|
maxHeight: addUnit(props2.maxHeight)
|
|
}));
|
|
const dropdownTriggerKls = computed(() => [ns.m(dropdownSize.value)]);
|
|
const trigger = computed(() => castArray_default(props2.trigger));
|
|
const defaultTriggerId = useId().value;
|
|
const triggerId = computed(() => props2.id || defaultTriggerId);
|
|
watch([triggeringElementRef, trigger], ([triggeringElement, trigger2], [prevTriggeringElement]) => {
|
|
var _a2, _b, _c;
|
|
if ((_a2 = prevTriggeringElement == null ? void 0 : prevTriggeringElement.$el) == null ? void 0 : _a2.removeEventListener) {
|
|
prevTriggeringElement.$el.removeEventListener("pointerenter", onAutofocusTriggerEnter);
|
|
}
|
|
if ((_b = triggeringElement == null ? void 0 : triggeringElement.$el) == null ? void 0 : _b.removeEventListener) {
|
|
triggeringElement.$el.removeEventListener("pointerenter", onAutofocusTriggerEnter);
|
|
}
|
|
if (((_c = triggeringElement == null ? void 0 : triggeringElement.$el) == null ? void 0 : _c.addEventListener) && trigger2.includes("hover")) {
|
|
triggeringElement.$el.addEventListener("pointerenter", onAutofocusTriggerEnter);
|
|
}
|
|
}, { immediate: true });
|
|
onBeforeUnmount(() => {
|
|
var _a2, _b;
|
|
if ((_b = (_a2 = triggeringElementRef.value) == null ? void 0 : _a2.$el) == null ? void 0 : _b.removeEventListener) {
|
|
triggeringElementRef.value.$el.removeEventListener("pointerenter", onAutofocusTriggerEnter);
|
|
}
|
|
});
|
|
function handleClick() {
|
|
handleClose();
|
|
}
|
|
function handleClose() {
|
|
var _a2;
|
|
(_a2 = popperRef.value) == null ? void 0 : _a2.onClose();
|
|
}
|
|
function handleOpen() {
|
|
var _a2;
|
|
(_a2 = popperRef.value) == null ? void 0 : _a2.onOpen();
|
|
}
|
|
const dropdownSize = useFormSize();
|
|
function commandHandler(...args) {
|
|
emit("command", ...args);
|
|
}
|
|
function onAutofocusTriggerEnter() {
|
|
var _a2, _b;
|
|
(_b = (_a2 = triggeringElementRef.value) == null ? void 0 : _a2.$el) == null ? void 0 : _b.focus();
|
|
}
|
|
function onItemEnter() {
|
|
}
|
|
function onItemLeave() {
|
|
const contentEl = unref(contentRef);
|
|
trigger.value.includes("hover") && (contentEl == null ? void 0 : contentEl.focus());
|
|
currentTabId.value = null;
|
|
}
|
|
function handleCurrentTabIdChange(id) {
|
|
currentTabId.value = id;
|
|
}
|
|
function handleEntryFocus(e) {
|
|
if (!isUsingKeyboard.value) {
|
|
e.preventDefault();
|
|
e.stopImmediatePropagation();
|
|
}
|
|
}
|
|
function handleBeforeShowTooltip() {
|
|
emit("visible-change", true);
|
|
}
|
|
function handleShowTooltip(event) {
|
|
var _a2;
|
|
if ((event == null ? void 0 : event.type) === "keydown") {
|
|
(_a2 = contentRef.value) == null ? void 0 : _a2.focus();
|
|
}
|
|
}
|
|
function handleBeforeHideTooltip() {
|
|
emit("visible-change", false);
|
|
}
|
|
provide(DROPDOWN_INJECTION_KEY, {
|
|
contentRef,
|
|
role: computed(() => props2.role),
|
|
triggerId,
|
|
isUsingKeyboard,
|
|
onItemEnter,
|
|
onItemLeave
|
|
});
|
|
provide("elDropdown", {
|
|
instance: _instance,
|
|
dropdownSize,
|
|
handleClick,
|
|
commandHandler,
|
|
trigger: toRef(props2, "trigger"),
|
|
hideOnClick: toRef(props2, "hideOnClick")
|
|
});
|
|
const onFocusAfterTrapped = (e) => {
|
|
var _a2, _b;
|
|
e.preventDefault();
|
|
(_b = (_a2 = contentRef.value) == null ? void 0 : _a2.focus) == null ? void 0 : _b.call(_a2, {
|
|
preventScroll: true
|
|
});
|
|
};
|
|
const handlerMainButtonClick = (event) => {
|
|
emit("click", event);
|
|
};
|
|
return {
|
|
t,
|
|
ns,
|
|
scrollbar,
|
|
wrapStyle,
|
|
dropdownTriggerKls,
|
|
dropdownSize,
|
|
triggerId,
|
|
currentTabId,
|
|
handleCurrentTabIdChange,
|
|
handlerMainButtonClick,
|
|
handleEntryFocus,
|
|
handleClose,
|
|
handleOpen,
|
|
handleBeforeShowTooltip,
|
|
handleShowTooltip,
|
|
handleBeforeHideTooltip,
|
|
onFocusAfterTrapped,
|
|
popperRef,
|
|
contentRef,
|
|
triggeringElementRef,
|
|
referenceElementRef
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render12(_ctx, _cache, $props, $setup, $data, $options) {
|
|
var _a2;
|
|
const _component_el_dropdown_collection = resolveComponent("el-dropdown-collection");
|
|
const _component_el_roving_focus_group = resolveComponent("el-roving-focus-group");
|
|
const _component_el_scrollbar = resolveComponent("el-scrollbar");
|
|
const _component_el_only_child = resolveComponent("el-only-child");
|
|
const _component_el_tooltip = resolveComponent("el-tooltip");
|
|
const _component_el_button = resolveComponent("el-button");
|
|
const _component_arrow_down = resolveComponent("arrow-down");
|
|
const _component_el_icon = resolveComponent("el-icon");
|
|
const _component_el_button_group = resolveComponent("el-button-group");
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([_ctx.ns.b(), _ctx.ns.is("disabled", _ctx.disabled)])
|
|
}, [
|
|
createVNode(_component_el_tooltip, {
|
|
ref: "popperRef",
|
|
role: _ctx.role,
|
|
effect: _ctx.effect,
|
|
"fallback-placements": ["bottom", "top"],
|
|
"popper-options": _ctx.popperOptions,
|
|
"gpu-acceleration": false,
|
|
"hide-after": _ctx.trigger === "hover" ? _ctx.hideTimeout : 0,
|
|
"manual-mode": true,
|
|
placement: _ctx.placement,
|
|
"popper-class": [_ctx.ns.e("popper"), _ctx.popperClass],
|
|
"reference-element": (_a2 = _ctx.referenceElementRef) == null ? void 0 : _a2.$el,
|
|
trigger: _ctx.trigger,
|
|
"trigger-keys": _ctx.triggerKeys,
|
|
"trigger-target-el": _ctx.contentRef,
|
|
"show-after": _ctx.trigger === "hover" ? _ctx.showTimeout : 0,
|
|
"stop-popper-mouse-event": false,
|
|
"virtual-ref": _ctx.triggeringElementRef,
|
|
"virtual-triggering": _ctx.splitButton,
|
|
disabled: _ctx.disabled,
|
|
transition: `${_ctx.ns.namespace.value}-zoom-in-top`,
|
|
teleported: _ctx.teleported,
|
|
pure: "",
|
|
persistent: _ctx.persistent,
|
|
onBeforeShow: _ctx.handleBeforeShowTooltip,
|
|
onShow: _ctx.handleShowTooltip,
|
|
onBeforeHide: _ctx.handleBeforeHideTooltip
|
|
}, createSlots({
|
|
content: withCtx(() => [
|
|
createVNode(_component_el_scrollbar, {
|
|
ref: "scrollbar",
|
|
"wrap-style": _ctx.wrapStyle,
|
|
tag: "div",
|
|
"view-class": _ctx.ns.e("list")
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(_component_el_roving_focus_group, {
|
|
loop: _ctx.loop,
|
|
"current-tab-id": _ctx.currentTabId,
|
|
orientation: "horizontal",
|
|
onCurrentTabIdChange: _ctx.handleCurrentTabIdChange,
|
|
onEntryFocus: _ctx.handleEntryFocus
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(_component_el_dropdown_collection, null, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "dropdown")
|
|
]),
|
|
_: 3
|
|
})
|
|
]),
|
|
_: 3
|
|
}, 8, ["loop", "current-tab-id", "onCurrentTabIdChange", "onEntryFocus"])
|
|
]),
|
|
_: 3
|
|
}, 8, ["wrap-style", "view-class"])
|
|
]),
|
|
_: 2
|
|
}, [
|
|
!_ctx.splitButton ? {
|
|
name: "default",
|
|
fn: withCtx(() => [
|
|
createVNode(_component_el_only_child, {
|
|
id: _ctx.triggerId,
|
|
ref: "triggeringElementRef",
|
|
role: "button",
|
|
tabindex: _ctx.tabindex
|
|
}, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 8, ["id", "tabindex"])
|
|
])
|
|
} : void 0
|
|
]), 1032, ["role", "effect", "popper-options", "hide-after", "placement", "popper-class", "reference-element", "trigger", "trigger-keys", "trigger-target-el", "show-after", "virtual-ref", "virtual-triggering", "disabled", "transition", "teleported", "persistent", "onBeforeShow", "onShow", "onBeforeHide"]),
|
|
_ctx.splitButton ? (openBlock(), createBlock(_component_el_button_group, { key: 0 }, {
|
|
default: withCtx(() => [
|
|
createVNode(_component_el_button, mergeProps({ ref: "referenceElementRef" }, _ctx.buttonProps, {
|
|
size: _ctx.dropdownSize,
|
|
type: _ctx.type,
|
|
disabled: _ctx.disabled,
|
|
tabindex: _ctx.tabindex,
|
|
onClick: _ctx.handlerMainButtonClick
|
|
}), {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 16, ["size", "type", "disabled", "tabindex", "onClick"]),
|
|
createVNode(_component_el_button, mergeProps({
|
|
id: _ctx.triggerId,
|
|
ref: "triggeringElementRef"
|
|
}, _ctx.buttonProps, {
|
|
role: "button",
|
|
size: _ctx.dropdownSize,
|
|
type: _ctx.type,
|
|
class: _ctx.ns.e("caret-button"),
|
|
disabled: _ctx.disabled,
|
|
tabindex: _ctx.tabindex,
|
|
"aria-label": _ctx.t("el.dropdown.toggleDropdown")
|
|
}), {
|
|
default: withCtx(() => [
|
|
createVNode(_component_el_icon, {
|
|
class: normalizeClass(_ctx.ns.e("icon"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(_component_arrow_down)
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])
|
|
]),
|
|
_: 1
|
|
}, 16, ["id", "size", "type", "class", "disabled", "tabindex", "aria-label"])
|
|
]),
|
|
_: 3
|
|
})) : createCommentVNode("v-if", true)
|
|
], 2);
|
|
}
|
|
var Dropdown = _export_sfc(_sfc_main78, [["render", _sfc_render12], ["__file", "dropdown.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/roving-focus-group/src/roving-focus-item.mjs
|
|
var _sfc_main79 = defineComponent({
|
|
components: {
|
|
ElRovingFocusCollectionItem: ElCollectionItem2
|
|
},
|
|
props: {
|
|
focusable: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
active: {
|
|
type: Boolean,
|
|
default: false
|
|
}
|
|
},
|
|
emits: ["mousedown", "focus", "keydown"],
|
|
setup(props2, { emit }) {
|
|
const { currentTabbedId, loop, onItemFocus, onItemShiftTab } = inject(ROVING_FOCUS_GROUP_INJECTION_KEY, void 0);
|
|
const { getItems } = inject(COLLECTION_INJECTION_KEY2, void 0);
|
|
const id = useId();
|
|
const rovingFocusGroupItemRef = ref();
|
|
const handleMousedown = composeEventHandlers((e) => {
|
|
emit("mousedown", e);
|
|
}, (e) => {
|
|
if (!props2.focusable) {
|
|
e.preventDefault();
|
|
} else {
|
|
onItemFocus(unref(id));
|
|
}
|
|
});
|
|
const handleFocus = composeEventHandlers((e) => {
|
|
emit("focus", e);
|
|
}, () => {
|
|
onItemFocus(unref(id));
|
|
});
|
|
const handleKeydown = composeEventHandlers((e) => {
|
|
emit("keydown", e);
|
|
}, (e) => {
|
|
const { code, shiftKey, target: target2, currentTarget } = e;
|
|
if (code === EVENT_CODE.tab && shiftKey) {
|
|
onItemShiftTab();
|
|
return;
|
|
}
|
|
if (target2 !== currentTarget)
|
|
return;
|
|
const focusIntent = getFocusIntent(e);
|
|
if (focusIntent) {
|
|
e.preventDefault();
|
|
const items = getItems().filter((item) => item.focusable);
|
|
let elements = items.map((item) => item.ref);
|
|
switch (focusIntent) {
|
|
case "last": {
|
|
elements.reverse();
|
|
break;
|
|
}
|
|
case "prev":
|
|
case "next": {
|
|
if (focusIntent === "prev") {
|
|
elements.reverse();
|
|
}
|
|
const currentIdx = elements.indexOf(currentTarget);
|
|
elements = loop.value ? reorderArray(elements, currentIdx + 1) : elements.slice(currentIdx + 1);
|
|
break;
|
|
}
|
|
}
|
|
nextTick(() => {
|
|
focusFirst(elements);
|
|
});
|
|
}
|
|
});
|
|
const isCurrentTab = computed(() => currentTabbedId.value === unref(id));
|
|
provide(ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY, {
|
|
rovingFocusGroupItemRef,
|
|
tabIndex: computed(() => unref(isCurrentTab) ? 0 : -1),
|
|
handleMousedown,
|
|
handleFocus,
|
|
handleKeydown
|
|
});
|
|
return {
|
|
id,
|
|
handleKeydown,
|
|
handleFocus,
|
|
handleMousedown
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render13(_ctx, _cache, $props, $setup, $data, $options) {
|
|
const _component_el_roving_focus_collection_item = resolveComponent("el-roving-focus-collection-item");
|
|
return openBlock(), createBlock(_component_el_roving_focus_collection_item, {
|
|
id: _ctx.id,
|
|
focusable: _ctx.focusable,
|
|
active: _ctx.active
|
|
}, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 8, ["id", "focusable", "active"]);
|
|
}
|
|
var ElRovingFocusItem = _export_sfc(_sfc_main79, [["render", _sfc_render13], ["__file", "roving-focus-item.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/dropdown-item-impl.mjs
|
|
var _sfc_main80 = defineComponent({
|
|
name: "DropdownItemImpl",
|
|
components: {
|
|
ElIcon
|
|
},
|
|
props: dropdownItemProps,
|
|
emits: ["pointermove", "pointerleave", "click", "clickimpl"],
|
|
setup(_2, { emit }) {
|
|
const ns = useNamespace("dropdown");
|
|
const { role: menuRole } = inject(DROPDOWN_INJECTION_KEY, void 0);
|
|
const { collectionItemRef: dropdownCollectionItemRef } = inject(COLLECTION_ITEM_INJECTION_KEY, void 0);
|
|
const { collectionItemRef: rovingFocusCollectionItemRef } = inject(COLLECTION_ITEM_INJECTION_KEY2, void 0);
|
|
const {
|
|
rovingFocusGroupItemRef,
|
|
tabIndex,
|
|
handleFocus,
|
|
handleKeydown: handleItemKeydown,
|
|
handleMousedown
|
|
} = inject(ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY, void 0);
|
|
const itemRef = composeRefs(dropdownCollectionItemRef, rovingFocusCollectionItemRef, rovingFocusGroupItemRef);
|
|
const role = computed(() => {
|
|
if (menuRole.value === "menu") {
|
|
return "menuitem";
|
|
} else if (menuRole.value === "navigation") {
|
|
return "link";
|
|
}
|
|
return "button";
|
|
});
|
|
const handleKeydown = composeEventHandlers((e) => {
|
|
if ([EVENT_CODE.enter, EVENT_CODE.numpadEnter, EVENT_CODE.space].includes(e.code)) {
|
|
e.preventDefault();
|
|
e.stopImmediatePropagation();
|
|
emit("clickimpl", e);
|
|
return true;
|
|
}
|
|
}, handleItemKeydown);
|
|
return {
|
|
ns,
|
|
itemRef,
|
|
dataset: {
|
|
[COLLECTION_ITEM_SIGN]: ""
|
|
},
|
|
role,
|
|
tabIndex,
|
|
handleFocus,
|
|
handleKeydown,
|
|
handleMousedown
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render14(_ctx, _cache, $props, $setup, $data, $options) {
|
|
const _component_el_icon = resolveComponent("el-icon");
|
|
return openBlock(), createElementBlock(Fragment, null, [
|
|
_ctx.divided ? (openBlock(), createElementBlock("li", {
|
|
key: 0,
|
|
role: "separator",
|
|
class: normalizeClass(_ctx.ns.bem("menu", "item", "divided"))
|
|
}, null, 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("li", mergeProps({ ref: _ctx.itemRef }, { ..._ctx.dataset, ..._ctx.$attrs }, {
|
|
"aria-disabled": _ctx.disabled,
|
|
class: [_ctx.ns.be("menu", "item"), _ctx.ns.is("disabled", _ctx.disabled)],
|
|
tabindex: _ctx.tabIndex,
|
|
role: _ctx.role,
|
|
onClick: (e) => _ctx.$emit("clickimpl", e),
|
|
onFocus: _ctx.handleFocus,
|
|
onKeydown: withModifiers(_ctx.handleKeydown, ["self"]),
|
|
onMousedown: _ctx.handleMousedown,
|
|
onPointermove: (e) => _ctx.$emit("pointermove", e),
|
|
onPointerleave: (e) => _ctx.$emit("pointerleave", e)
|
|
}), [
|
|
_ctx.icon ? (openBlock(), createBlock(_component_el_icon, { key: 0 }, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
|
|
]),
|
|
_: 1
|
|
})) : createCommentVNode("v-if", true),
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 16, ["aria-disabled", "tabindex", "role", "onClick", "onFocus", "onKeydown", "onMousedown", "onPointermove", "onPointerleave"])
|
|
], 64);
|
|
}
|
|
var ElDropdownItemImpl = _export_sfc(_sfc_main80, [["render", _sfc_render14], ["__file", "dropdown-item-impl.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/useDropdown.mjs
|
|
var useDropdown = () => {
|
|
const elDropdown = inject("elDropdown", {});
|
|
const _elDropdownSize = computed(() => elDropdown == null ? void 0 : elDropdown.dropdownSize);
|
|
return {
|
|
elDropdown,
|
|
_elDropdownSize
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/dropdown-item.mjs
|
|
var _sfc_main81 = defineComponent({
|
|
name: "ElDropdownItem",
|
|
components: {
|
|
ElDropdownCollectionItem: ElCollectionItem,
|
|
ElRovingFocusItem,
|
|
ElDropdownItemImpl
|
|
},
|
|
inheritAttrs: false,
|
|
props: dropdownItemProps,
|
|
emits: ["pointermove", "pointerleave", "click"],
|
|
setup(props2, { emit, attrs }) {
|
|
const { elDropdown } = useDropdown();
|
|
const _instance = getCurrentInstance();
|
|
const itemRef = ref(null);
|
|
const textContent = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = unref(itemRef)) == null ? void 0 : _a2.textContent) != null ? _b : "";
|
|
});
|
|
const { onItemEnter, onItemLeave } = inject(DROPDOWN_INJECTION_KEY, void 0);
|
|
const handlePointerMove = composeEventHandlers((e) => {
|
|
emit("pointermove", e);
|
|
return e.defaultPrevented;
|
|
}, whenMouse((e) => {
|
|
if (props2.disabled) {
|
|
onItemLeave(e);
|
|
return;
|
|
}
|
|
const target2 = e.currentTarget;
|
|
if (target2 === document.activeElement || target2.contains(document.activeElement)) {
|
|
return;
|
|
}
|
|
onItemEnter(e);
|
|
if (!e.defaultPrevented) {
|
|
target2 == null ? void 0 : target2.focus();
|
|
}
|
|
}));
|
|
const handlePointerLeave = composeEventHandlers((e) => {
|
|
emit("pointerleave", e);
|
|
return e.defaultPrevented;
|
|
}, whenMouse(onItemLeave));
|
|
const handleClick = composeEventHandlers((e) => {
|
|
if (props2.disabled) {
|
|
return;
|
|
}
|
|
emit("click", e);
|
|
return e.type !== "keydown" && e.defaultPrevented;
|
|
}, (e) => {
|
|
var _a2, _b, _c;
|
|
if (props2.disabled) {
|
|
e.stopImmediatePropagation();
|
|
return;
|
|
}
|
|
if ((_a2 = elDropdown == null ? void 0 : elDropdown.hideOnClick) == null ? void 0 : _a2.value) {
|
|
(_b = elDropdown.handleClick) == null ? void 0 : _b.call(elDropdown);
|
|
}
|
|
(_c = elDropdown.commandHandler) == null ? void 0 : _c.call(elDropdown, props2.command, _instance, e);
|
|
});
|
|
const propsAndAttrs = computed(() => ({ ...props2, ...attrs }));
|
|
return {
|
|
handleClick,
|
|
handlePointerMove,
|
|
handlePointerLeave,
|
|
textContent,
|
|
propsAndAttrs
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render15(_ctx, _cache, $props, $setup, $data, $options) {
|
|
var _a2;
|
|
const _component_el_dropdown_item_impl = resolveComponent("el-dropdown-item-impl");
|
|
const _component_el_roving_focus_item = resolveComponent("el-roving-focus-item");
|
|
const _component_el_dropdown_collection_item = resolveComponent("el-dropdown-collection-item");
|
|
return openBlock(), createBlock(_component_el_dropdown_collection_item, {
|
|
disabled: _ctx.disabled,
|
|
"text-value": (_a2 = _ctx.textValue) != null ? _a2 : _ctx.textContent
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(_component_el_roving_focus_item, {
|
|
focusable: !_ctx.disabled
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(_component_el_dropdown_item_impl, mergeProps(_ctx.propsAndAttrs, {
|
|
onPointerleave: _ctx.handlePointerLeave,
|
|
onPointermove: _ctx.handlePointerMove,
|
|
onClickimpl: _ctx.handleClick
|
|
}), {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 16, ["onPointerleave", "onPointermove", "onClickimpl"])
|
|
]),
|
|
_: 3
|
|
}, 8, ["focusable"])
|
|
]),
|
|
_: 3
|
|
}, 8, ["disabled", "text-value"]);
|
|
}
|
|
var DropdownItem = _export_sfc(_sfc_main81, [["render", _sfc_render15], ["__file", "dropdown-item.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/dropdown-menu.mjs
|
|
var _sfc_main82 = defineComponent({
|
|
name: "ElDropdownMenu",
|
|
props: dropdownMenuProps,
|
|
setup(props2) {
|
|
const ns = useNamespace("dropdown");
|
|
const { _elDropdownSize } = useDropdown();
|
|
const size3 = _elDropdownSize.value;
|
|
const { focusTrapRef, onKeydown } = inject(FOCUS_TRAP_INJECTION_KEY, void 0);
|
|
const { contentRef, role, triggerId } = inject(DROPDOWN_INJECTION_KEY, void 0);
|
|
const { collectionRef: dropdownCollectionRef, getItems } = inject(COLLECTION_INJECTION_KEY, void 0);
|
|
const {
|
|
rovingFocusGroupRef,
|
|
rovingFocusGroupRootStyle,
|
|
tabIndex,
|
|
onBlur,
|
|
onFocus,
|
|
onMousedown
|
|
} = inject(ROVING_FOCUS_GROUP_INJECTION_KEY, void 0);
|
|
const { collectionRef: rovingFocusGroupCollectionRef } = inject(COLLECTION_INJECTION_KEY2, void 0);
|
|
const dropdownKls = computed(() => {
|
|
return [ns.b("menu"), ns.bm("menu", size3 == null ? void 0 : size3.value)];
|
|
});
|
|
const dropdownListWrapperRef = composeRefs(contentRef, dropdownCollectionRef, focusTrapRef, rovingFocusGroupRef, rovingFocusGroupCollectionRef);
|
|
const composedKeydown = composeEventHandlers((e) => {
|
|
var _a2;
|
|
(_a2 = props2.onKeydown) == null ? void 0 : _a2.call(props2, e);
|
|
}, (e) => {
|
|
const { currentTarget, code, target: target2 } = e;
|
|
currentTarget.contains(target2);
|
|
if (EVENT_CODE.tab === code) {
|
|
e.stopImmediatePropagation();
|
|
}
|
|
e.preventDefault();
|
|
if (target2 !== unref(contentRef) || !FIRST_LAST_KEYS.includes(code))
|
|
return;
|
|
const items = getItems().filter((item) => !item.disabled);
|
|
const targets = items.map((item) => item.ref);
|
|
if (LAST_KEYS.includes(code)) {
|
|
targets.reverse();
|
|
}
|
|
focusFirst(targets);
|
|
});
|
|
const handleKeydown = (e) => {
|
|
composedKeydown(e);
|
|
onKeydown(e);
|
|
};
|
|
return {
|
|
size: size3,
|
|
rovingFocusGroupRootStyle,
|
|
tabIndex,
|
|
dropdownKls,
|
|
role,
|
|
triggerId,
|
|
dropdownListWrapperRef,
|
|
handleKeydown,
|
|
onBlur,
|
|
onFocus,
|
|
onMousedown
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render16(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return openBlock(), createElementBlock("ul", {
|
|
ref: _ctx.dropdownListWrapperRef,
|
|
class: normalizeClass(_ctx.dropdownKls),
|
|
style: normalizeStyle(_ctx.rovingFocusGroupRootStyle),
|
|
tabindex: -1,
|
|
role: _ctx.role,
|
|
"aria-labelledby": _ctx.triggerId,
|
|
onBlur: _ctx.onBlur,
|
|
onFocus: _ctx.onFocus,
|
|
onKeydown: withModifiers(_ctx.handleKeydown, ["self"]),
|
|
onMousedown: withModifiers(_ctx.onMousedown, ["self"])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 46, ["role", "aria-labelledby", "onBlur", "onFocus", "onKeydown", "onMousedown"]);
|
|
}
|
|
var DropdownMenu = _export_sfc(_sfc_main82, [["render", _sfc_render16], ["__file", "dropdown-menu.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/dropdown/index.mjs
|
|
var ElDropdown = withInstall(Dropdown, {
|
|
DropdownItem,
|
|
DropdownMenu
|
|
});
|
|
var ElDropdownItem = withNoopInstall(DropdownItem);
|
|
var ElDropdownMenu = withNoopInstall(DropdownMenu);
|
|
|
|
// node_modules/element-plus/es/components/empty/src/empty.mjs
|
|
var emptyProps = buildProps({
|
|
image: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
imageSize: Number,
|
|
description: {
|
|
type: String,
|
|
default: ""
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/empty/src/img-empty.mjs
|
|
var __default__56 = defineComponent({
|
|
name: "ImgEmpty"
|
|
});
|
|
var _sfc_main83 = defineComponent({
|
|
...__default__56,
|
|
setup(__props) {
|
|
const ns = useNamespace("empty");
|
|
const id = useId();
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("svg", {
|
|
viewBox: "0 0 79 86",
|
|
version: "1.1",
|
|
xmlns: "http://www.w3.org/2000/svg",
|
|
"xmlns:xlink": "http://www.w3.org/1999/xlink"
|
|
}, [
|
|
createBaseVNode("defs", null, [
|
|
createBaseVNode("linearGradient", {
|
|
id: `linearGradient-1-${unref(id)}`,
|
|
x1: "38.8503086%",
|
|
y1: "0%",
|
|
x2: "61.1496914%",
|
|
y2: "100%"
|
|
}, [
|
|
createBaseVNode("stop", {
|
|
"stop-color": `var(${unref(ns).cssVarBlockName("fill-color-1")})`,
|
|
offset: "0%"
|
|
}, null, 8, ["stop-color"]),
|
|
createBaseVNode("stop", {
|
|
"stop-color": `var(${unref(ns).cssVarBlockName("fill-color-4")})`,
|
|
offset: "100%"
|
|
}, null, 8, ["stop-color"])
|
|
], 8, ["id"]),
|
|
createBaseVNode("linearGradient", {
|
|
id: `linearGradient-2-${unref(id)}`,
|
|
x1: "0%",
|
|
y1: "9.5%",
|
|
x2: "100%",
|
|
y2: "90.5%"
|
|
}, [
|
|
createBaseVNode("stop", {
|
|
"stop-color": `var(${unref(ns).cssVarBlockName("fill-color-1")})`,
|
|
offset: "0%"
|
|
}, null, 8, ["stop-color"]),
|
|
createBaseVNode("stop", {
|
|
"stop-color": `var(${unref(ns).cssVarBlockName("fill-color-6")})`,
|
|
offset: "100%"
|
|
}, null, 8, ["stop-color"])
|
|
], 8, ["id"]),
|
|
createBaseVNode("rect", {
|
|
id: `path-3-${unref(id)}`,
|
|
x: "0",
|
|
y: "0",
|
|
width: "17",
|
|
height: "36"
|
|
}, null, 8, ["id"])
|
|
]),
|
|
createBaseVNode("g", {
|
|
stroke: "none",
|
|
"stroke-width": "1",
|
|
fill: "none",
|
|
"fill-rule": "evenodd"
|
|
}, [
|
|
createBaseVNode("g", { transform: "translate(-1268.000000, -535.000000)" }, [
|
|
createBaseVNode("g", { transform: "translate(1268.000000, 535.000000)" }, [
|
|
createBaseVNode("path", {
|
|
d: "M39.5,86 C61.3152476,86 79,83.9106622 79,81.3333333 C79,78.7560045 57.3152476,78 35.5,78 C13.6847524,78 0,78.7560045 0,81.3333333 C0,83.9106622 17.6847524,86 39.5,86 Z",
|
|
fill: `var(${unref(ns).cssVarBlockName("fill-color-3")})`
|
|
}, null, 8, ["fill"]),
|
|
createBaseVNode("polygon", {
|
|
fill: `var(${unref(ns).cssVarBlockName("fill-color-7")})`,
|
|
transform: "translate(27.500000, 51.500000) scale(1, -1) translate(-27.500000, -51.500000) ",
|
|
points: "13 58 53 58 42 45 2 45"
|
|
}, null, 8, ["fill"]),
|
|
createBaseVNode("g", { transform: "translate(34.500000, 31.500000) scale(-1, 1) rotate(-25.000000) translate(-34.500000, -31.500000) translate(7.000000, 10.000000)" }, [
|
|
createBaseVNode("polygon", {
|
|
fill: `var(${unref(ns).cssVarBlockName("fill-color-7")})`,
|
|
transform: "translate(11.500000, 5.000000) scale(1, -1) translate(-11.500000, -5.000000) ",
|
|
points: "2.84078316e-14 3 18 3 23 7 5 7"
|
|
}, null, 8, ["fill"]),
|
|
createBaseVNode("polygon", {
|
|
fill: `var(${unref(ns).cssVarBlockName("fill-color-5")})`,
|
|
points: "-3.69149156e-15 7 38 7 38 43 -3.69149156e-15 43"
|
|
}, null, 8, ["fill"]),
|
|
createBaseVNode("rect", {
|
|
fill: `url(#linearGradient-1-${unref(id)})`,
|
|
transform: "translate(46.500000, 25.000000) scale(-1, 1) translate(-46.500000, -25.000000) ",
|
|
x: "38",
|
|
y: "7",
|
|
width: "17",
|
|
height: "36"
|
|
}, null, 8, ["fill"]),
|
|
createBaseVNode("polygon", {
|
|
fill: `var(${unref(ns).cssVarBlockName("fill-color-2")})`,
|
|
transform: "translate(39.500000, 3.500000) scale(-1, 1) translate(-39.500000, -3.500000) ",
|
|
points: "24 7 41 7 55 -3.63806207e-12 38 -3.63806207e-12"
|
|
}, null, 8, ["fill"])
|
|
]),
|
|
createBaseVNode("rect", {
|
|
fill: `url(#linearGradient-2-${unref(id)})`,
|
|
x: "13",
|
|
y: "45",
|
|
width: "40",
|
|
height: "36"
|
|
}, null, 8, ["fill"]),
|
|
createBaseVNode("g", { transform: "translate(53.000000, 45.000000)" }, [
|
|
createBaseVNode("use", {
|
|
fill: `var(${unref(ns).cssVarBlockName("fill-color-8")})`,
|
|
transform: "translate(8.500000, 18.000000) scale(-1, 1) translate(-8.500000, -18.000000) ",
|
|
"xlink:href": `#path-3-${unref(id)}`
|
|
}, null, 8, ["fill", "xlink:href"]),
|
|
createBaseVNode("polygon", {
|
|
fill: `var(${unref(ns).cssVarBlockName("fill-color-9")})`,
|
|
mask: `url(#mask-4-${unref(id)})`,
|
|
transform: "translate(12.000000, 9.000000) scale(-1, 1) translate(-12.000000, -9.000000) ",
|
|
points: "7 0 24 0 20 18 7 16.5"
|
|
}, null, 8, ["fill", "mask"])
|
|
]),
|
|
createBaseVNode("polygon", {
|
|
fill: `var(${unref(ns).cssVarBlockName("fill-color-2")})`,
|
|
transform: "translate(66.000000, 51.500000) scale(-1, 1) translate(-66.000000, -51.500000) ",
|
|
points: "62 45 79 45 70 58 53 58"
|
|
}, null, 8, ["fill"])
|
|
])
|
|
])
|
|
])
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
var ImgEmpty = _export_sfc(_sfc_main83, [["__file", "img-empty.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/empty/src/empty2.mjs
|
|
var __default__57 = defineComponent({
|
|
name: "ElEmpty"
|
|
});
|
|
var _sfc_main84 = defineComponent({
|
|
...__default__57,
|
|
props: emptyProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("empty");
|
|
const emptyDescription = computed(() => props2.description || t("el.table.emptyText"));
|
|
const imageStyle = computed(() => ({
|
|
width: addUnit(props2.imageSize)
|
|
}));
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(unref(ns).b())
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("image")),
|
|
style: normalizeStyle(unref(imageStyle))
|
|
}, [
|
|
_ctx.image ? (openBlock(), createElementBlock("img", {
|
|
key: 0,
|
|
src: _ctx.image,
|
|
ondragstart: "return false"
|
|
}, null, 8, ["src"])) : renderSlot(_ctx.$slots, "image", { key: 1 }, () => [
|
|
createVNode(ImgEmpty)
|
|
])
|
|
], 6),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("description"))
|
|
}, [
|
|
_ctx.$slots.description ? renderSlot(_ctx.$slots, "description", { key: 0 }) : (openBlock(), createElementBlock("p", { key: 1 }, toDisplayString(unref(emptyDescription)), 1))
|
|
], 2),
|
|
_ctx.$slots.default ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("bottom"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Empty = _export_sfc(_sfc_main84, [["__file", "empty.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/empty/index.mjs
|
|
var ElEmpty = withInstall(Empty);
|
|
|
|
// node_modules/element-plus/es/components/form/src/form.mjs
|
|
var formMetaProps = buildProps({
|
|
size: {
|
|
type: String,
|
|
values: componentSizes
|
|
},
|
|
disabled: Boolean
|
|
});
|
|
var formProps = buildProps({
|
|
...formMetaProps,
|
|
model: Object,
|
|
rules: {
|
|
type: definePropType(Object)
|
|
},
|
|
labelPosition: {
|
|
type: String,
|
|
values: ["left", "right", "top"],
|
|
default: "right"
|
|
},
|
|
requireAsteriskPosition: {
|
|
type: String,
|
|
values: ["left", "right"],
|
|
default: "left"
|
|
},
|
|
labelWidth: {
|
|
type: [String, Number],
|
|
default: ""
|
|
},
|
|
labelSuffix: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
inline: Boolean,
|
|
inlineMessage: Boolean,
|
|
statusIcon: Boolean,
|
|
showMessage: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
validateOnRuleChange: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
hideRequiredAsterisk: Boolean,
|
|
scrollToError: Boolean,
|
|
scrollIntoViewOptions: {
|
|
type: [Object, Boolean],
|
|
default: true
|
|
}
|
|
});
|
|
var formEmits = {
|
|
validate: (prop, isValid, message2) => (isArray(prop) || isString(prop)) && isBoolean2(isValid) && isString(message2)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/form/src/form-item.mjs
|
|
var formItemValidateStates = [
|
|
"",
|
|
"error",
|
|
"validating",
|
|
"success"
|
|
];
|
|
var formItemProps = buildProps({
|
|
label: String,
|
|
labelWidth: {
|
|
type: [String, Number],
|
|
default: ""
|
|
},
|
|
labelPosition: {
|
|
type: String,
|
|
values: ["left", "right", "top", ""],
|
|
default: ""
|
|
},
|
|
prop: {
|
|
type: definePropType([String, Array])
|
|
},
|
|
required: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
rules: {
|
|
type: definePropType([Object, Array])
|
|
},
|
|
error: String,
|
|
validateStatus: {
|
|
type: String,
|
|
values: formItemValidateStates
|
|
},
|
|
for: String,
|
|
inlineMessage: {
|
|
type: [String, Boolean],
|
|
default: ""
|
|
},
|
|
showMessage: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
size: {
|
|
type: String,
|
|
values: componentSizes
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/form/src/utils.mjs
|
|
var SCOPE5 = "ElForm";
|
|
function useFormLabelWidth() {
|
|
const potentialLabelWidthArr = ref([]);
|
|
const autoLabelWidth = computed(() => {
|
|
if (!potentialLabelWidthArr.value.length)
|
|
return "0";
|
|
const max4 = Math.max(...potentialLabelWidthArr.value);
|
|
return max4 ? `${max4}px` : "";
|
|
});
|
|
function getLabelWidthIndex(width) {
|
|
const index = potentialLabelWidthArr.value.indexOf(width);
|
|
if (index === -1 && autoLabelWidth.value === "0") {
|
|
debugWarn(SCOPE5, `unexpected width ${width}`);
|
|
}
|
|
return index;
|
|
}
|
|
function registerLabelWidth(val, oldVal) {
|
|
if (val && oldVal) {
|
|
const index = getLabelWidthIndex(oldVal);
|
|
potentialLabelWidthArr.value.splice(index, 1, val);
|
|
} else if (val) {
|
|
potentialLabelWidthArr.value.push(val);
|
|
}
|
|
}
|
|
function deregisterLabelWidth(val) {
|
|
const index = getLabelWidthIndex(val);
|
|
if (index > -1) {
|
|
potentialLabelWidthArr.value.splice(index, 1);
|
|
}
|
|
}
|
|
return {
|
|
autoLabelWidth,
|
|
registerLabelWidth,
|
|
deregisterLabelWidth
|
|
};
|
|
}
|
|
var filterFields = (fields, props2) => {
|
|
const normalized = castArray_default(props2);
|
|
return normalized.length > 0 ? fields.filter((field) => field.prop && normalized.includes(field.prop)) : fields;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/form/src/form2.mjs
|
|
var COMPONENT_NAME12 = "ElForm";
|
|
var __default__58 = defineComponent({
|
|
name: COMPONENT_NAME12
|
|
});
|
|
var _sfc_main85 = defineComponent({
|
|
...__default__58,
|
|
props: formProps,
|
|
emits: formEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const formRef = ref();
|
|
const fields = reactive([]);
|
|
const formSize = useFormSize();
|
|
const ns = useNamespace("form");
|
|
const formClasses = computed(() => {
|
|
const { labelPosition, inline: inline2 } = props2;
|
|
return [
|
|
ns.b(),
|
|
ns.m(formSize.value || "default"),
|
|
{
|
|
[ns.m(`label-${labelPosition}`)]: labelPosition,
|
|
[ns.m("inline")]: inline2
|
|
}
|
|
];
|
|
});
|
|
const getField = (prop) => {
|
|
return fields.find((field) => field.prop === prop);
|
|
};
|
|
const addField = (field) => {
|
|
fields.push(field);
|
|
};
|
|
const removeField = (field) => {
|
|
if (field.prop) {
|
|
fields.splice(fields.indexOf(field), 1);
|
|
}
|
|
};
|
|
const resetFields = (properties = []) => {
|
|
if (!props2.model) {
|
|
debugWarn(COMPONENT_NAME12, "model is required for resetFields to work.");
|
|
return;
|
|
}
|
|
filterFields(fields, properties).forEach((field) => field.resetField());
|
|
};
|
|
const clearValidate = (props22 = []) => {
|
|
filterFields(fields, props22).forEach((field) => field.clearValidate());
|
|
};
|
|
const isValidatable = computed(() => {
|
|
const hasModel = !!props2.model;
|
|
if (!hasModel) {
|
|
debugWarn(COMPONENT_NAME12, "model is required for validate to work.");
|
|
}
|
|
return hasModel;
|
|
});
|
|
const obtainValidateFields = (props22) => {
|
|
if (fields.length === 0)
|
|
return [];
|
|
const filteredFields = filterFields(fields, props22);
|
|
if (!filteredFields.length) {
|
|
debugWarn(COMPONENT_NAME12, "please pass correct props!");
|
|
return [];
|
|
}
|
|
return filteredFields;
|
|
};
|
|
const validate = async (callback) => validateField(void 0, callback);
|
|
const doValidateField = async (props22 = []) => {
|
|
if (!isValidatable.value)
|
|
return false;
|
|
const fields2 = obtainValidateFields(props22);
|
|
if (fields2.length === 0)
|
|
return true;
|
|
let validationErrors = {};
|
|
for (const field of fields2) {
|
|
try {
|
|
await field.validate("");
|
|
if (field.validateState === "error")
|
|
field.resetField();
|
|
} catch (fields3) {
|
|
validationErrors = {
|
|
...validationErrors,
|
|
...fields3
|
|
};
|
|
}
|
|
}
|
|
if (Object.keys(validationErrors).length === 0)
|
|
return true;
|
|
return Promise.reject(validationErrors);
|
|
};
|
|
const validateField = async (modelProps = [], callback) => {
|
|
const shouldThrow = !isFunction(callback);
|
|
try {
|
|
const result2 = await doValidateField(modelProps);
|
|
if (result2 === true) {
|
|
await (callback == null ? void 0 : callback(result2));
|
|
}
|
|
return result2;
|
|
} catch (e) {
|
|
if (e instanceof Error)
|
|
throw e;
|
|
const invalidFields = e;
|
|
if (props2.scrollToError) {
|
|
if (formRef.value) {
|
|
const formItem = formRef.value.querySelector(`.${ns.b()}-item.is-error`);
|
|
formItem == null ? void 0 : formItem.scrollIntoView(props2.scrollIntoViewOptions);
|
|
}
|
|
}
|
|
await (callback == null ? void 0 : callback(false, invalidFields));
|
|
return shouldThrow && Promise.reject(invalidFields);
|
|
}
|
|
};
|
|
const scrollToField = (prop) => {
|
|
var _a2;
|
|
const field = filterFields(fields, prop)[0];
|
|
if (field) {
|
|
(_a2 = field.$el) == null ? void 0 : _a2.scrollIntoView(props2.scrollIntoViewOptions);
|
|
}
|
|
};
|
|
watch(() => props2.rules, () => {
|
|
if (props2.validateOnRuleChange) {
|
|
validate().catch((err) => debugWarn(err));
|
|
}
|
|
}, { deep: true, flush: "post" });
|
|
provide(formContextKey, reactive({
|
|
...toRefs(props2),
|
|
emit,
|
|
resetFields,
|
|
clearValidate,
|
|
validateField,
|
|
getField,
|
|
addField,
|
|
removeField,
|
|
...useFormLabelWidth()
|
|
}));
|
|
expose({
|
|
validate,
|
|
validateField,
|
|
resetFields,
|
|
clearValidate,
|
|
scrollToField,
|
|
fields
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("form", {
|
|
ref_key: "formRef",
|
|
ref: formRef,
|
|
class: normalizeClass(unref(formClasses))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Form = _export_sfc(_sfc_main85, [["__file", "form.vue"]]);
|
|
|
|
// node_modules/async-validator/dist-web/index.js
|
|
function _extends() {
|
|
_extends = Object.assign ? Object.assign.bind() : function(target2) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) {
|
|
if (Object.prototype.hasOwnProperty.call(source, key)) {
|
|
target2[key] = source[key];
|
|
}
|
|
}
|
|
}
|
|
return target2;
|
|
};
|
|
return _extends.apply(this, arguments);
|
|
}
|
|
function _inheritsLoose(subClass, superClass) {
|
|
subClass.prototype = Object.create(superClass.prototype);
|
|
subClass.prototype.constructor = subClass;
|
|
_setPrototypeOf(subClass, superClass);
|
|
}
|
|
function _getPrototypeOf(o2) {
|
|
_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o3) {
|
|
return o3.__proto__ || Object.getPrototypeOf(o3);
|
|
};
|
|
return _getPrototypeOf(o2);
|
|
}
|
|
function _setPrototypeOf(o2, p2) {
|
|
_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o3, p3) {
|
|
o3.__proto__ = p3;
|
|
return o3;
|
|
};
|
|
return _setPrototypeOf(o2, p2);
|
|
}
|
|
function _isNativeReflectConstruct() {
|
|
if (typeof Reflect === "undefined" || !Reflect.construct)
|
|
return false;
|
|
if (Reflect.construct.sham)
|
|
return false;
|
|
if (typeof Proxy === "function")
|
|
return true;
|
|
try {
|
|
Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
|
|
}));
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
function _construct(Parent, args, Class) {
|
|
if (_isNativeReflectConstruct()) {
|
|
_construct = Reflect.construct.bind();
|
|
} else {
|
|
_construct = function _construct2(Parent2, args2, Class2) {
|
|
var a2 = [null];
|
|
a2.push.apply(a2, args2);
|
|
var Constructor = Function.bind.apply(Parent2, a2);
|
|
var instance = new Constructor();
|
|
if (Class2)
|
|
_setPrototypeOf(instance, Class2.prototype);
|
|
return instance;
|
|
};
|
|
}
|
|
return _construct.apply(null, arguments);
|
|
}
|
|
function _isNativeFunction(fn2) {
|
|
return Function.toString.call(fn2).indexOf("[native code]") !== -1;
|
|
}
|
|
function _wrapNativeSuper(Class) {
|
|
var _cache = typeof Map === "function" ? new Map() : void 0;
|
|
_wrapNativeSuper = function _wrapNativeSuper2(Class2) {
|
|
if (Class2 === null || !_isNativeFunction(Class2))
|
|
return Class2;
|
|
if (typeof Class2 !== "function") {
|
|
throw new TypeError("Super expression must either be null or a function");
|
|
}
|
|
if (typeof _cache !== "undefined") {
|
|
if (_cache.has(Class2))
|
|
return _cache.get(Class2);
|
|
_cache.set(Class2, Wrapper);
|
|
}
|
|
function Wrapper() {
|
|
return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
|
|
}
|
|
Wrapper.prototype = Object.create(Class2.prototype, {
|
|
constructor: {
|
|
value: Wrapper,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
return _setPrototypeOf(Wrapper, Class2);
|
|
};
|
|
return _wrapNativeSuper(Class);
|
|
}
|
|
var formatRegExp = /%[sdj%]/g;
|
|
var warning = function warning2() {
|
|
};
|
|
if (typeof process !== "undefined" && process.env && true && typeof window !== "undefined" && typeof document !== "undefined") {
|
|
warning = function warning3(type4, errors) {
|
|
if (typeof console !== "undefined" && console.warn && typeof ASYNC_VALIDATOR_NO_WARNING === "undefined") {
|
|
if (errors.every(function(e) {
|
|
return typeof e === "string";
|
|
})) {
|
|
console.warn(type4, errors);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function convertFieldsError(errors) {
|
|
if (!errors || !errors.length)
|
|
return null;
|
|
var fields = {};
|
|
errors.forEach(function(error) {
|
|
var field = error.field;
|
|
fields[field] = fields[field] || [];
|
|
fields[field].push(error);
|
|
});
|
|
return fields;
|
|
}
|
|
function format(template2) {
|
|
for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
args[_key - 1] = arguments[_key];
|
|
}
|
|
var i = 0;
|
|
var len = args.length;
|
|
if (typeof template2 === "function") {
|
|
return template2.apply(null, args);
|
|
}
|
|
if (typeof template2 === "string") {
|
|
var str = template2.replace(formatRegExp, function(x2) {
|
|
if (x2 === "%%") {
|
|
return "%";
|
|
}
|
|
if (i >= len) {
|
|
return x2;
|
|
}
|
|
switch (x2) {
|
|
case "%s":
|
|
return String(args[i++]);
|
|
case "%d":
|
|
return Number(args[i++]);
|
|
case "%j":
|
|
try {
|
|
return JSON.stringify(args[i++]);
|
|
} catch (_2) {
|
|
return "[Circular]";
|
|
}
|
|
break;
|
|
default:
|
|
return x2;
|
|
}
|
|
});
|
|
return str;
|
|
}
|
|
return template2;
|
|
}
|
|
function isNativeStringType(type4) {
|
|
return type4 === "string" || type4 === "url" || type4 === "hex" || type4 === "email" || type4 === "date" || type4 === "pattern";
|
|
}
|
|
function isEmptyValue(value, type4) {
|
|
if (value === void 0 || value === null) {
|
|
return true;
|
|
}
|
|
if (type4 === "array" && Array.isArray(value) && !value.length) {
|
|
return true;
|
|
}
|
|
if (isNativeStringType(type4) && typeof value === "string" && !value) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function asyncParallelArray(arr, func, callback) {
|
|
var results = [];
|
|
var total2 = 0;
|
|
var arrLength = arr.length;
|
|
function count(errors) {
|
|
results.push.apply(results, errors || []);
|
|
total2++;
|
|
if (total2 === arrLength) {
|
|
callback(results);
|
|
}
|
|
}
|
|
arr.forEach(function(a2) {
|
|
func(a2, count);
|
|
});
|
|
}
|
|
function asyncSerialArray(arr, func, callback) {
|
|
var index = 0;
|
|
var arrLength = arr.length;
|
|
function next(errors) {
|
|
if (errors && errors.length) {
|
|
callback(errors);
|
|
return;
|
|
}
|
|
var original = index;
|
|
index = index + 1;
|
|
if (original < arrLength) {
|
|
func(arr[original], next);
|
|
} else {
|
|
callback([]);
|
|
}
|
|
}
|
|
next([]);
|
|
}
|
|
function flattenObjArr(objArr) {
|
|
var ret = [];
|
|
Object.keys(objArr).forEach(function(k) {
|
|
ret.push.apply(ret, objArr[k] || []);
|
|
});
|
|
return ret;
|
|
}
|
|
var AsyncValidationError = function(_Error) {
|
|
_inheritsLoose(AsyncValidationError2, _Error);
|
|
function AsyncValidationError2(errors, fields) {
|
|
var _this;
|
|
_this = _Error.call(this, "Async Validation Error") || this;
|
|
_this.errors = errors;
|
|
_this.fields = fields;
|
|
return _this;
|
|
}
|
|
return AsyncValidationError2;
|
|
}(_wrapNativeSuper(Error));
|
|
function asyncMap(objArr, option, func, callback, source) {
|
|
if (option.first) {
|
|
var _pending = new Promise(function(resolve, reject2) {
|
|
var next = function next2(errors) {
|
|
callback(errors);
|
|
return errors.length ? reject2(new AsyncValidationError(errors, convertFieldsError(errors))) : resolve(source);
|
|
};
|
|
var flattenArr = flattenObjArr(objArr);
|
|
asyncSerialArray(flattenArr, func, next);
|
|
});
|
|
_pending["catch"](function(e) {
|
|
return e;
|
|
});
|
|
return _pending;
|
|
}
|
|
var firstFields = option.firstFields === true ? Object.keys(objArr) : option.firstFields || [];
|
|
var objArrKeys = Object.keys(objArr);
|
|
var objArrLength = objArrKeys.length;
|
|
var total2 = 0;
|
|
var results = [];
|
|
var pending = new Promise(function(resolve, reject2) {
|
|
var next = function next2(errors) {
|
|
results.push.apply(results, errors);
|
|
total2++;
|
|
if (total2 === objArrLength) {
|
|
callback(results);
|
|
return results.length ? reject2(new AsyncValidationError(results, convertFieldsError(results))) : resolve(source);
|
|
}
|
|
};
|
|
if (!objArrKeys.length) {
|
|
callback(results);
|
|
resolve(source);
|
|
}
|
|
objArrKeys.forEach(function(key) {
|
|
var arr = objArr[key];
|
|
if (firstFields.indexOf(key) !== -1) {
|
|
asyncSerialArray(arr, func, next);
|
|
} else {
|
|
asyncParallelArray(arr, func, next);
|
|
}
|
|
});
|
|
});
|
|
pending["catch"](function(e) {
|
|
return e;
|
|
});
|
|
return pending;
|
|
}
|
|
function isErrorObj(obj) {
|
|
return !!(obj && obj.message !== void 0);
|
|
}
|
|
function getValue2(value, path) {
|
|
var v2 = value;
|
|
for (var i = 0; i < path.length; i++) {
|
|
if (v2 == void 0) {
|
|
return v2;
|
|
}
|
|
v2 = v2[path[i]];
|
|
}
|
|
return v2;
|
|
}
|
|
function complementError(rule, source) {
|
|
return function(oe) {
|
|
var fieldValue;
|
|
if (rule.fullFields) {
|
|
fieldValue = getValue2(source, rule.fullFields);
|
|
} else {
|
|
fieldValue = source[oe.field || rule.fullField];
|
|
}
|
|
if (isErrorObj(oe)) {
|
|
oe.field = oe.field || rule.fullField;
|
|
oe.fieldValue = fieldValue;
|
|
return oe;
|
|
}
|
|
return {
|
|
message: typeof oe === "function" ? oe() : oe,
|
|
fieldValue,
|
|
field: oe.field || rule.fullField
|
|
};
|
|
};
|
|
}
|
|
function deepMerge(target2, source) {
|
|
if (source) {
|
|
for (var s2 in source) {
|
|
if (source.hasOwnProperty(s2)) {
|
|
var value = source[s2];
|
|
if (typeof value === "object" && typeof target2[s2] === "object") {
|
|
target2[s2] = _extends({}, target2[s2], value);
|
|
} else {
|
|
target2[s2] = value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return target2;
|
|
}
|
|
var required$1 = function required(rule, value, source, errors, options, type4) {
|
|
if (rule.required && (!source.hasOwnProperty(rule.field) || isEmptyValue(value, type4 || rule.type))) {
|
|
errors.push(format(options.messages.required, rule.fullField));
|
|
}
|
|
};
|
|
var whitespace = function whitespace2(rule, value, source, errors, options) {
|
|
if (/^\s+$/.test(value) || value === "") {
|
|
errors.push(format(options.messages.whitespace, rule.fullField));
|
|
}
|
|
};
|
|
var urlReg;
|
|
var getUrlRegex = function() {
|
|
if (urlReg) {
|
|
return urlReg;
|
|
}
|
|
var word = "[a-fA-F\\d:]";
|
|
var b2 = function b3(options) {
|
|
return options && options.includeBoundaries ? "(?:(?<=\\s|^)(?=" + word + ")|(?<=" + word + ")(?=\\s|$))" : "";
|
|
};
|
|
var v4 = "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}";
|
|
var v6seg = "[a-fA-F\\d]{1,4}";
|
|
var v6 = ("\n(?:\n(?:" + v6seg + ":){7}(?:" + v6seg + "|:)| // 1:2:3:4:5:6:7:: 1:2:3:4:5:6:7:8\n(?:" + v6seg + ":){6}(?:" + v4 + "|:" + v6seg + "|:)| // 1:2:3:4:5:6:: 1:2:3:4:5:6::8 1:2:3:4:5:6::8 1:2:3:4:5:6::1.2.3.4\n(?:" + v6seg + ":){5}(?::" + v4 + "|(?::" + v6seg + "){1,2}|:)| // 1:2:3:4:5:: 1:2:3:4:5::7:8 1:2:3:4:5::8 1:2:3:4:5::7:1.2.3.4\n(?:" + v6seg + ":){4}(?:(?::" + v6seg + "){0,1}:" + v4 + "|(?::" + v6seg + "){1,3}|:)| // 1:2:3:4:: 1:2:3:4::6:7:8 1:2:3:4::8 1:2:3:4::6:7:1.2.3.4\n(?:" + v6seg + ":){3}(?:(?::" + v6seg + "){0,2}:" + v4 + "|(?::" + v6seg + "){1,4}|:)| // 1:2:3:: 1:2:3::5:6:7:8 1:2:3::8 1:2:3::5:6:7:1.2.3.4\n(?:" + v6seg + ":){2}(?:(?::" + v6seg + "){0,3}:" + v4 + "|(?::" + v6seg + "){1,5}|:)| // 1:2:: 1:2::4:5:6:7:8 1:2::8 1:2::4:5:6:7:1.2.3.4\n(?:" + v6seg + ":){1}(?:(?::" + v6seg + "){0,4}:" + v4 + "|(?::" + v6seg + "){1,6}|:)| // 1:: 1::3:4:5:6:7:8 1::8 1::3:4:5:6:7:1.2.3.4\n(?::(?:(?::" + v6seg + "){0,5}:" + v4 + "|(?::" + v6seg + "){1,7}|:)) // ::2:3:4:5:6:7:8 ::2:3:4:5:6:7:8 ::8 ::1.2.3.4\n)(?:%[0-9a-zA-Z]{1,})? // %eth0 %1\n").replace(/\s*\/\/.*$/gm, "").replace(/\n/g, "").trim();
|
|
var v46Exact = new RegExp("(?:^" + v4 + "$)|(?:^" + v6 + "$)");
|
|
var v4exact = new RegExp("^" + v4 + "$");
|
|
var v6exact = new RegExp("^" + v6 + "$");
|
|
var ip = function ip2(options) {
|
|
return options && options.exact ? v46Exact : new RegExp("(?:" + b2(options) + v4 + b2(options) + ")|(?:" + b2(options) + v6 + b2(options) + ")", "g");
|
|
};
|
|
ip.v4 = function(options) {
|
|
return options && options.exact ? v4exact : new RegExp("" + b2(options) + v4 + b2(options), "g");
|
|
};
|
|
ip.v6 = function(options) {
|
|
return options && options.exact ? v6exact : new RegExp("" + b2(options) + v6 + b2(options), "g");
|
|
};
|
|
var protocol = "(?:(?:[a-z]+:)?//)";
|
|
var auth = "(?:\\S+(?::\\S*)?@)?";
|
|
var ipv4 = ip.v4().source;
|
|
var ipv6 = ip.v6().source;
|
|
var host = "(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)";
|
|
var domain = "(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*";
|
|
var tld = "(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))";
|
|
var port = "(?::\\d{2,5})?";
|
|
var path = '(?:[/?#][^\\s"]*)?';
|
|
var regex = "(?:" + protocol + "|www\\.)" + auth + "(?:localhost|" + ipv4 + "|" + ipv6 + "|" + host + domain + tld + ")" + port + path;
|
|
urlReg = new RegExp("(?:^" + regex + "$)", "i");
|
|
return urlReg;
|
|
};
|
|
var pattern$2 = {
|
|
email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+\.)+[a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{2,}))$/,
|
|
hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i
|
|
};
|
|
var types = {
|
|
integer: function integer(value) {
|
|
return types.number(value) && parseInt(value, 10) === value;
|
|
},
|
|
"float": function float(value) {
|
|
return types.number(value) && !types.integer(value);
|
|
},
|
|
array: function array(value) {
|
|
return Array.isArray(value);
|
|
},
|
|
regexp: function regexp(value) {
|
|
if (value instanceof RegExp) {
|
|
return true;
|
|
}
|
|
try {
|
|
return !!new RegExp(value);
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
},
|
|
date: function date(value) {
|
|
return typeof value.getTime === "function" && typeof value.getMonth === "function" && typeof value.getYear === "function" && !isNaN(value.getTime());
|
|
},
|
|
number: function number(value) {
|
|
if (isNaN(value)) {
|
|
return false;
|
|
}
|
|
return typeof value === "number";
|
|
},
|
|
object: function object(value) {
|
|
return typeof value === "object" && !types.array(value);
|
|
},
|
|
method: function method2(value) {
|
|
return typeof value === "function";
|
|
},
|
|
email: function email(value) {
|
|
return typeof value === "string" && value.length <= 320 && !!value.match(pattern$2.email);
|
|
},
|
|
url: function url(value) {
|
|
return typeof value === "string" && value.length <= 2048 && !!value.match(getUrlRegex());
|
|
},
|
|
hex: function hex(value) {
|
|
return typeof value === "string" && !!value.match(pattern$2.hex);
|
|
}
|
|
};
|
|
var type$1 = function type(rule, value, source, errors, options) {
|
|
if (rule.required && value === void 0) {
|
|
required$1(rule, value, source, errors, options);
|
|
return;
|
|
}
|
|
var custom = ["integer", "float", "array", "regexp", "object", "method", "email", "number", "date", "url", "hex"];
|
|
var ruleType = rule.type;
|
|
if (custom.indexOf(ruleType) > -1) {
|
|
if (!types[ruleType](value)) {
|
|
errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
|
|
}
|
|
} else if (ruleType && typeof value !== rule.type) {
|
|
errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
|
|
}
|
|
};
|
|
var range2 = function range3(rule, value, source, errors, options) {
|
|
var len = typeof rule.len === "number";
|
|
var min4 = typeof rule.min === "number";
|
|
var max4 = typeof rule.max === "number";
|
|
var spRegexp = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
|
|
var val = value;
|
|
var key = null;
|
|
var num = typeof value === "number";
|
|
var str = typeof value === "string";
|
|
var arr = Array.isArray(value);
|
|
if (num) {
|
|
key = "number";
|
|
} else if (str) {
|
|
key = "string";
|
|
} else if (arr) {
|
|
key = "array";
|
|
}
|
|
if (!key) {
|
|
return false;
|
|
}
|
|
if (arr) {
|
|
val = value.length;
|
|
}
|
|
if (str) {
|
|
val = value.replace(spRegexp, "_").length;
|
|
}
|
|
if (len) {
|
|
if (val !== rule.len) {
|
|
errors.push(format(options.messages[key].len, rule.fullField, rule.len));
|
|
}
|
|
} else if (min4 && !max4 && val < rule.min) {
|
|
errors.push(format(options.messages[key].min, rule.fullField, rule.min));
|
|
} else if (max4 && !min4 && val > rule.max) {
|
|
errors.push(format(options.messages[key].max, rule.fullField, rule.max));
|
|
} else if (min4 && max4 && (val < rule.min || val > rule.max)) {
|
|
errors.push(format(options.messages[key].range, rule.fullField, rule.min, rule.max));
|
|
}
|
|
};
|
|
var ENUM$1 = "enum";
|
|
var enumerable$1 = function enumerable(rule, value, source, errors, options) {
|
|
rule[ENUM$1] = Array.isArray(rule[ENUM$1]) ? rule[ENUM$1] : [];
|
|
if (rule[ENUM$1].indexOf(value) === -1) {
|
|
errors.push(format(options.messages[ENUM$1], rule.fullField, rule[ENUM$1].join(", ")));
|
|
}
|
|
};
|
|
var pattern$1 = function pattern(rule, value, source, errors, options) {
|
|
if (rule.pattern) {
|
|
if (rule.pattern instanceof RegExp) {
|
|
rule.pattern.lastIndex = 0;
|
|
if (!rule.pattern.test(value)) {
|
|
errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
|
|
}
|
|
} else if (typeof rule.pattern === "string") {
|
|
var _pattern = new RegExp(rule.pattern);
|
|
if (!_pattern.test(value)) {
|
|
errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var rules = {
|
|
required: required$1,
|
|
whitespace,
|
|
type: type$1,
|
|
range: range2,
|
|
"enum": enumerable$1,
|
|
pattern: pattern$1
|
|
};
|
|
var string = function string2(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
|
if (validate) {
|
|
if (isEmptyValue(value, "string") && !rule.required) {
|
|
return callback();
|
|
}
|
|
rules.required(rule, value, source, errors, options, "string");
|
|
if (!isEmptyValue(value, "string")) {
|
|
rules.type(rule, value, source, errors, options);
|
|
rules.range(rule, value, source, errors, options);
|
|
rules.pattern(rule, value, source, errors, options);
|
|
if (rule.whitespace === true) {
|
|
rules.whitespace(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var method3 = function method4(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
|
if (validate) {
|
|
if (isEmptyValue(value) && !rule.required) {
|
|
return callback();
|
|
}
|
|
rules.required(rule, value, source, errors, options);
|
|
if (value !== void 0) {
|
|
rules.type(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var number2 = function number3(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
|
if (validate) {
|
|
if (value === "") {
|
|
value = void 0;
|
|
}
|
|
if (isEmptyValue(value) && !rule.required) {
|
|
return callback();
|
|
}
|
|
rules.required(rule, value, source, errors, options);
|
|
if (value !== void 0) {
|
|
rules.type(rule, value, source, errors, options);
|
|
rules.range(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var _boolean = function _boolean2(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
|
if (validate) {
|
|
if (isEmptyValue(value) && !rule.required) {
|
|
return callback();
|
|
}
|
|
rules.required(rule, value, source, errors, options);
|
|
if (value !== void 0) {
|
|
rules.type(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var regexp2 = function regexp3(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
|
if (validate) {
|
|
if (isEmptyValue(value) && !rule.required) {
|
|
return callback();
|
|
}
|
|
rules.required(rule, value, source, errors, options);
|
|
if (!isEmptyValue(value)) {
|
|
rules.type(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var integer2 = function integer3(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
|
if (validate) {
|
|
if (isEmptyValue(value) && !rule.required) {
|
|
return callback();
|
|
}
|
|
rules.required(rule, value, source, errors, options);
|
|
if (value !== void 0) {
|
|
rules.type(rule, value, source, errors, options);
|
|
rules.range(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var floatFn = function floatFn2(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
|
if (validate) {
|
|
if (isEmptyValue(value) && !rule.required) {
|
|
return callback();
|
|
}
|
|
rules.required(rule, value, source, errors, options);
|
|
if (value !== void 0) {
|
|
rules.type(rule, value, source, errors, options);
|
|
rules.range(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var array2 = function array3(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
|
if (validate) {
|
|
if ((value === void 0 || value === null) && !rule.required) {
|
|
return callback();
|
|
}
|
|
rules.required(rule, value, source, errors, options, "array");
|
|
if (value !== void 0 && value !== null) {
|
|
rules.type(rule, value, source, errors, options);
|
|
rules.range(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var object2 = function object3(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
|
if (validate) {
|
|
if (isEmptyValue(value) && !rule.required) {
|
|
return callback();
|
|
}
|
|
rules.required(rule, value, source, errors, options);
|
|
if (value !== void 0) {
|
|
rules.type(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var ENUM = "enum";
|
|
var enumerable2 = function enumerable3(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
|
if (validate) {
|
|
if (isEmptyValue(value) && !rule.required) {
|
|
return callback();
|
|
}
|
|
rules.required(rule, value, source, errors, options);
|
|
if (value !== void 0) {
|
|
rules[ENUM](rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var pattern2 = function pattern3(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
|
if (validate) {
|
|
if (isEmptyValue(value, "string") && !rule.required) {
|
|
return callback();
|
|
}
|
|
rules.required(rule, value, source, errors, options);
|
|
if (!isEmptyValue(value, "string")) {
|
|
rules.pattern(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var date2 = function date3(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
|
if (validate) {
|
|
if (isEmptyValue(value, "date") && !rule.required) {
|
|
return callback();
|
|
}
|
|
rules.required(rule, value, source, errors, options);
|
|
if (!isEmptyValue(value, "date")) {
|
|
var dateObject;
|
|
if (value instanceof Date) {
|
|
dateObject = value;
|
|
} else {
|
|
dateObject = new Date(value);
|
|
}
|
|
rules.type(rule, dateObject, source, errors, options);
|
|
if (dateObject) {
|
|
rules.range(rule, dateObject.getTime(), source, errors, options);
|
|
}
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var required2 = function required3(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var type4 = Array.isArray(value) ? "array" : typeof value;
|
|
rules.required(rule, value, source, errors, options, type4);
|
|
callback(errors);
|
|
};
|
|
var type2 = function type3(rule, value, callback, source, options) {
|
|
var ruleType = rule.type;
|
|
var errors = [];
|
|
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
|
if (validate) {
|
|
if (isEmptyValue(value, ruleType) && !rule.required) {
|
|
return callback();
|
|
}
|
|
rules.required(rule, value, source, errors, options, ruleType);
|
|
if (!isEmptyValue(value, ruleType)) {
|
|
rules.type(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var any = function any2(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
|
if (validate) {
|
|
if (isEmptyValue(value) && !rule.required) {
|
|
return callback();
|
|
}
|
|
rules.required(rule, value, source, errors, options);
|
|
}
|
|
callback(errors);
|
|
};
|
|
var validators = {
|
|
string,
|
|
method: method3,
|
|
number: number2,
|
|
"boolean": _boolean,
|
|
regexp: regexp2,
|
|
integer: integer2,
|
|
"float": floatFn,
|
|
array: array2,
|
|
object: object2,
|
|
"enum": enumerable2,
|
|
pattern: pattern2,
|
|
date: date2,
|
|
url: type2,
|
|
hex: type2,
|
|
email: type2,
|
|
required: required2,
|
|
any
|
|
};
|
|
function newMessages() {
|
|
return {
|
|
"default": "Validation error on field %s",
|
|
required: "%s is required",
|
|
"enum": "%s must be one of %s",
|
|
whitespace: "%s cannot be empty",
|
|
date: {
|
|
format: "%s date %s is invalid for format %s",
|
|
parse: "%s date could not be parsed, %s is invalid ",
|
|
invalid: "%s date %s is invalid"
|
|
},
|
|
types: {
|
|
string: "%s is not a %s",
|
|
method: "%s is not a %s (function)",
|
|
array: "%s is not an %s",
|
|
object: "%s is not an %s",
|
|
number: "%s is not a %s",
|
|
date: "%s is not a %s",
|
|
"boolean": "%s is not a %s",
|
|
integer: "%s is not an %s",
|
|
"float": "%s is not a %s",
|
|
regexp: "%s is not a valid %s",
|
|
email: "%s is not a valid %s",
|
|
url: "%s is not a valid %s",
|
|
hex: "%s is not a valid %s"
|
|
},
|
|
string: {
|
|
len: "%s must be exactly %s characters",
|
|
min: "%s must be at least %s characters",
|
|
max: "%s cannot be longer than %s characters",
|
|
range: "%s must be between %s and %s characters"
|
|
},
|
|
number: {
|
|
len: "%s must equal %s",
|
|
min: "%s cannot be less than %s",
|
|
max: "%s cannot be greater than %s",
|
|
range: "%s must be between %s and %s"
|
|
},
|
|
array: {
|
|
len: "%s must be exactly %s in length",
|
|
min: "%s cannot be less than %s in length",
|
|
max: "%s cannot be greater than %s in length",
|
|
range: "%s must be between %s and %s in length"
|
|
},
|
|
pattern: {
|
|
mismatch: "%s value %s does not match pattern %s"
|
|
},
|
|
clone: function clone2() {
|
|
var cloned = JSON.parse(JSON.stringify(this));
|
|
cloned.clone = this.clone;
|
|
return cloned;
|
|
}
|
|
};
|
|
}
|
|
var messages = newMessages();
|
|
var Schema = function() {
|
|
function Schema2(descriptor) {
|
|
this.rules = null;
|
|
this._messages = messages;
|
|
this.define(descriptor);
|
|
}
|
|
var _proto = Schema2.prototype;
|
|
_proto.define = function define2(rules2) {
|
|
var _this = this;
|
|
if (!rules2) {
|
|
throw new Error("Cannot configure a schema with no rules");
|
|
}
|
|
if (typeof rules2 !== "object" || Array.isArray(rules2)) {
|
|
throw new Error("Rules must be an object");
|
|
}
|
|
this.rules = {};
|
|
Object.keys(rules2).forEach(function(name) {
|
|
var item = rules2[name];
|
|
_this.rules[name] = Array.isArray(item) ? item : [item];
|
|
});
|
|
};
|
|
_proto.messages = function messages2(_messages) {
|
|
if (_messages) {
|
|
this._messages = deepMerge(newMessages(), _messages);
|
|
}
|
|
return this._messages;
|
|
};
|
|
_proto.validate = function validate(source_, o2, oc) {
|
|
var _this2 = this;
|
|
if (o2 === void 0) {
|
|
o2 = {};
|
|
}
|
|
if (oc === void 0) {
|
|
oc = function oc2() {
|
|
};
|
|
}
|
|
var source = source_;
|
|
var options = o2;
|
|
var callback = oc;
|
|
if (typeof options === "function") {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
if (!this.rules || Object.keys(this.rules).length === 0) {
|
|
if (callback) {
|
|
callback(null, source);
|
|
}
|
|
return Promise.resolve(source);
|
|
}
|
|
function complete(results) {
|
|
var errors = [];
|
|
var fields = {};
|
|
function add2(e) {
|
|
if (Array.isArray(e)) {
|
|
var _errors;
|
|
errors = (_errors = errors).concat.apply(_errors, e);
|
|
} else {
|
|
errors.push(e);
|
|
}
|
|
}
|
|
for (var i = 0; i < results.length; i++) {
|
|
add2(results[i]);
|
|
}
|
|
if (!errors.length) {
|
|
callback(null, source);
|
|
} else {
|
|
fields = convertFieldsError(errors);
|
|
callback(errors, fields);
|
|
}
|
|
}
|
|
if (options.messages) {
|
|
var messages$1 = this.messages();
|
|
if (messages$1 === messages) {
|
|
messages$1 = newMessages();
|
|
}
|
|
deepMerge(messages$1, options.messages);
|
|
options.messages = messages$1;
|
|
} else {
|
|
options.messages = this.messages();
|
|
}
|
|
var series = {};
|
|
var keys3 = options.keys || Object.keys(this.rules);
|
|
keys3.forEach(function(z) {
|
|
var arr = _this2.rules[z];
|
|
var value = source[z];
|
|
arr.forEach(function(r) {
|
|
var rule = r;
|
|
if (typeof rule.transform === "function") {
|
|
if (source === source_) {
|
|
source = _extends({}, source);
|
|
}
|
|
value = source[z] = rule.transform(value);
|
|
}
|
|
if (typeof rule === "function") {
|
|
rule = {
|
|
validator: rule
|
|
};
|
|
} else {
|
|
rule = _extends({}, rule);
|
|
}
|
|
rule.validator = _this2.getValidationMethod(rule);
|
|
if (!rule.validator) {
|
|
return;
|
|
}
|
|
rule.field = z;
|
|
rule.fullField = rule.fullField || z;
|
|
rule.type = _this2.getType(rule);
|
|
series[z] = series[z] || [];
|
|
series[z].push({
|
|
rule,
|
|
value,
|
|
source,
|
|
field: z
|
|
});
|
|
});
|
|
});
|
|
var errorFields = {};
|
|
return asyncMap(series, options, function(data, doIt) {
|
|
var rule = data.rule;
|
|
var deep = (rule.type === "object" || rule.type === "array") && (typeof rule.fields === "object" || typeof rule.defaultField === "object");
|
|
deep = deep && (rule.required || !rule.required && data.value);
|
|
rule.field = data.field;
|
|
function addFullField(key, schema) {
|
|
return _extends({}, schema, {
|
|
fullField: rule.fullField + "." + key,
|
|
fullFields: rule.fullFields ? [].concat(rule.fullFields, [key]) : [key]
|
|
});
|
|
}
|
|
function cb(e) {
|
|
if (e === void 0) {
|
|
e = [];
|
|
}
|
|
var errorList = Array.isArray(e) ? e : [e];
|
|
if (!options.suppressWarning && errorList.length) {
|
|
Schema2.warning("async-validator:", errorList);
|
|
}
|
|
if (errorList.length && rule.message !== void 0) {
|
|
errorList = [].concat(rule.message);
|
|
}
|
|
var filledErrors = errorList.map(complementError(rule, source));
|
|
if (options.first && filledErrors.length) {
|
|
errorFields[rule.field] = 1;
|
|
return doIt(filledErrors);
|
|
}
|
|
if (!deep) {
|
|
doIt(filledErrors);
|
|
} else {
|
|
if (rule.required && !data.value) {
|
|
if (rule.message !== void 0) {
|
|
filledErrors = [].concat(rule.message).map(complementError(rule, source));
|
|
} else if (options.error) {
|
|
filledErrors = [options.error(rule, format(options.messages.required, rule.field))];
|
|
}
|
|
return doIt(filledErrors);
|
|
}
|
|
var fieldsSchema = {};
|
|
if (rule.defaultField) {
|
|
Object.keys(data.value).map(function(key) {
|
|
fieldsSchema[key] = rule.defaultField;
|
|
});
|
|
}
|
|
fieldsSchema = _extends({}, fieldsSchema, data.rule.fields);
|
|
var paredFieldsSchema = {};
|
|
Object.keys(fieldsSchema).forEach(function(field) {
|
|
var fieldSchema = fieldsSchema[field];
|
|
var fieldSchemaList = Array.isArray(fieldSchema) ? fieldSchema : [fieldSchema];
|
|
paredFieldsSchema[field] = fieldSchemaList.map(addFullField.bind(null, field));
|
|
});
|
|
var schema = new Schema2(paredFieldsSchema);
|
|
schema.messages(options.messages);
|
|
if (data.rule.options) {
|
|
data.rule.options.messages = options.messages;
|
|
data.rule.options.error = options.error;
|
|
}
|
|
schema.validate(data.value, data.rule.options || options, function(errs) {
|
|
var finalErrors = [];
|
|
if (filledErrors && filledErrors.length) {
|
|
finalErrors.push.apply(finalErrors, filledErrors);
|
|
}
|
|
if (errs && errs.length) {
|
|
finalErrors.push.apply(finalErrors, errs);
|
|
}
|
|
doIt(finalErrors.length ? finalErrors : null);
|
|
});
|
|
}
|
|
}
|
|
var res;
|
|
if (rule.asyncValidator) {
|
|
res = rule.asyncValidator(rule, data.value, cb, data.source, options);
|
|
} else if (rule.validator) {
|
|
try {
|
|
res = rule.validator(rule, data.value, cb, data.source, options);
|
|
} catch (error) {
|
|
console.error == null ? void 0 : console.error(error);
|
|
if (!options.suppressValidatorError) {
|
|
setTimeout(function() {
|
|
throw error;
|
|
}, 0);
|
|
}
|
|
cb(error.message);
|
|
}
|
|
if (res === true) {
|
|
cb();
|
|
} else if (res === false) {
|
|
cb(typeof rule.message === "function" ? rule.message(rule.fullField || rule.field) : rule.message || (rule.fullField || rule.field) + " fails");
|
|
} else if (res instanceof Array) {
|
|
cb(res);
|
|
} else if (res instanceof Error) {
|
|
cb(res.message);
|
|
}
|
|
}
|
|
if (res && res.then) {
|
|
res.then(function() {
|
|
return cb();
|
|
}, function(e) {
|
|
return cb(e);
|
|
});
|
|
}
|
|
}, function(results) {
|
|
complete(results);
|
|
}, source);
|
|
};
|
|
_proto.getType = function getType(rule) {
|
|
if (rule.type === void 0 && rule.pattern instanceof RegExp) {
|
|
rule.type = "pattern";
|
|
}
|
|
if (typeof rule.validator !== "function" && rule.type && !validators.hasOwnProperty(rule.type)) {
|
|
throw new Error(format("Unknown rule type %s", rule.type));
|
|
}
|
|
return rule.type || "string";
|
|
};
|
|
_proto.getValidationMethod = function getValidationMethod(rule) {
|
|
if (typeof rule.validator === "function") {
|
|
return rule.validator;
|
|
}
|
|
var keys3 = Object.keys(rule);
|
|
var messageIndex = keys3.indexOf("message");
|
|
if (messageIndex !== -1) {
|
|
keys3.splice(messageIndex, 1);
|
|
}
|
|
if (keys3.length === 1 && keys3[0] === "required") {
|
|
return validators.required;
|
|
}
|
|
return validators[this.getType(rule)] || void 0;
|
|
};
|
|
return Schema2;
|
|
}();
|
|
Schema.register = function register(type4, validator) {
|
|
if (typeof validator !== "function") {
|
|
throw new Error("Cannot register a validator by type, validator is not a function");
|
|
}
|
|
validators[type4] = validator;
|
|
};
|
|
Schema.warning = warning;
|
|
Schema.messages = messages;
|
|
Schema.validators = validators;
|
|
|
|
// node_modules/element-plus/es/components/form/src/form-label-wrap.mjs
|
|
var COMPONENT_NAME13 = "ElLabelWrap";
|
|
var FormLabelWrap = defineComponent({
|
|
name: COMPONENT_NAME13,
|
|
props: {
|
|
isAutoWidth: Boolean,
|
|
updateAll: Boolean
|
|
},
|
|
setup(props2, {
|
|
slots
|
|
}) {
|
|
const formContext = inject(formContextKey, void 0);
|
|
const formItemContext = inject(formItemContextKey);
|
|
if (!formItemContext)
|
|
throwError(COMPONENT_NAME13, "usage: <el-form-item><label-wrap /></el-form-item>");
|
|
const ns = useNamespace("form");
|
|
const el = ref();
|
|
const computedWidth = ref(0);
|
|
const getLabelWidth = () => {
|
|
var _a2;
|
|
if ((_a2 = el.value) == null ? void 0 : _a2.firstElementChild) {
|
|
const width = window.getComputedStyle(el.value.firstElementChild).width;
|
|
return Math.ceil(Number.parseFloat(width));
|
|
} else {
|
|
return 0;
|
|
}
|
|
};
|
|
const updateLabelWidth = (action = "update") => {
|
|
nextTick(() => {
|
|
if (slots.default && props2.isAutoWidth) {
|
|
if (action === "update") {
|
|
computedWidth.value = getLabelWidth();
|
|
} else if (action === "remove") {
|
|
formContext == null ? void 0 : formContext.deregisterLabelWidth(computedWidth.value);
|
|
}
|
|
}
|
|
});
|
|
};
|
|
const updateLabelWidthFn = () => updateLabelWidth("update");
|
|
onMounted(() => {
|
|
updateLabelWidthFn();
|
|
});
|
|
onBeforeUnmount(() => {
|
|
updateLabelWidth("remove");
|
|
});
|
|
onUpdated(() => updateLabelWidthFn());
|
|
watch(computedWidth, (val, oldVal) => {
|
|
if (props2.updateAll) {
|
|
formContext == null ? void 0 : formContext.registerLabelWidth(val, oldVal);
|
|
}
|
|
});
|
|
useResizeObserver(computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = el.value) == null ? void 0 : _a2.firstElementChild) != null ? _b : null;
|
|
}), updateLabelWidthFn);
|
|
return () => {
|
|
var _a2, _b;
|
|
if (!slots)
|
|
return null;
|
|
const {
|
|
isAutoWidth
|
|
} = props2;
|
|
if (isAutoWidth) {
|
|
const autoLabelWidth = formContext == null ? void 0 : formContext.autoLabelWidth;
|
|
const hasLabel = formItemContext == null ? void 0 : formItemContext.hasLabel;
|
|
const style = {};
|
|
if (hasLabel && autoLabelWidth && autoLabelWidth !== "auto") {
|
|
const marginWidth = Math.max(0, Number.parseInt(autoLabelWidth, 10) - computedWidth.value);
|
|
const labelPosition = formItemContext.labelPosition || formContext.labelPosition;
|
|
const marginPosition = labelPosition === "left" ? "marginRight" : "marginLeft";
|
|
if (marginWidth) {
|
|
style[marginPosition] = `${marginWidth}px`;
|
|
}
|
|
}
|
|
return createVNode("div", {
|
|
"ref": el,
|
|
"class": [ns.be("item", "label-wrap")],
|
|
"style": style
|
|
}, [(_a2 = slots.default) == null ? void 0 : _a2.call(slots)]);
|
|
} else {
|
|
return createVNode(Fragment, {
|
|
"ref": el
|
|
}, [(_b = slots.default) == null ? void 0 : _b.call(slots)]);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/form/src/form-item2.mjs
|
|
var __default__59 = defineComponent({
|
|
name: "ElFormItem"
|
|
});
|
|
var _sfc_main86 = defineComponent({
|
|
...__default__59,
|
|
props: formItemProps,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const slots = useSlots();
|
|
const formContext = inject(formContextKey, void 0);
|
|
const parentFormItemContext = inject(formItemContextKey, void 0);
|
|
const _size = useFormSize(void 0, { formItem: false });
|
|
const ns = useNamespace("form-item");
|
|
const labelId = useId().value;
|
|
const inputIds = ref([]);
|
|
const validateState = ref("");
|
|
const validateStateDebounced = refDebounced(validateState, 100);
|
|
const validateMessage = ref("");
|
|
const formItemRef = ref();
|
|
let initialValue = void 0;
|
|
let isResettingField = false;
|
|
const labelPosition = computed(() => props2.labelPosition || (formContext == null ? void 0 : formContext.labelPosition));
|
|
const labelStyle = computed(() => {
|
|
if (labelPosition.value === "top") {
|
|
return {};
|
|
}
|
|
const labelWidth = addUnit(props2.labelWidth || (formContext == null ? void 0 : formContext.labelWidth) || "");
|
|
if (labelWidth)
|
|
return { width: labelWidth };
|
|
return {};
|
|
});
|
|
const contentStyle = computed(() => {
|
|
if (labelPosition.value === "top" || (formContext == null ? void 0 : formContext.inline)) {
|
|
return {};
|
|
}
|
|
if (!props2.label && !props2.labelWidth && isNested) {
|
|
return {};
|
|
}
|
|
const labelWidth = addUnit(props2.labelWidth || (formContext == null ? void 0 : formContext.labelWidth) || "");
|
|
if (!props2.label && !slots.label) {
|
|
return { marginLeft: labelWidth };
|
|
}
|
|
return {};
|
|
});
|
|
const formItemClasses = computed(() => [
|
|
ns.b(),
|
|
ns.m(_size.value),
|
|
ns.is("error", validateState.value === "error"),
|
|
ns.is("validating", validateState.value === "validating"),
|
|
ns.is("success", validateState.value === "success"),
|
|
ns.is("required", isRequired.value || props2.required),
|
|
ns.is("no-asterisk", formContext == null ? void 0 : formContext.hideRequiredAsterisk),
|
|
(formContext == null ? void 0 : formContext.requireAsteriskPosition) === "right" ? "asterisk-right" : "asterisk-left",
|
|
{
|
|
[ns.m("feedback")]: formContext == null ? void 0 : formContext.statusIcon,
|
|
[ns.m(`label-${labelPosition.value}`)]: labelPosition.value
|
|
}
|
|
]);
|
|
const _inlineMessage = computed(() => isBoolean2(props2.inlineMessage) ? props2.inlineMessage : (formContext == null ? void 0 : formContext.inlineMessage) || false);
|
|
const validateClasses = computed(() => [
|
|
ns.e("error"),
|
|
{ [ns.em("error", "inline")]: _inlineMessage.value }
|
|
]);
|
|
const propString = computed(() => {
|
|
if (!props2.prop)
|
|
return "";
|
|
return isString(props2.prop) ? props2.prop : props2.prop.join(".");
|
|
});
|
|
const hasLabel = computed(() => {
|
|
return !!(props2.label || slots.label);
|
|
});
|
|
const labelFor = computed(() => {
|
|
return props2.for || (inputIds.value.length === 1 ? inputIds.value[0] : void 0);
|
|
});
|
|
const isGroup = computed(() => {
|
|
return !labelFor.value && hasLabel.value;
|
|
});
|
|
const isNested = !!parentFormItemContext;
|
|
const fieldValue = computed(() => {
|
|
const model = formContext == null ? void 0 : formContext.model;
|
|
if (!model || !props2.prop) {
|
|
return;
|
|
}
|
|
return getProp(model, props2.prop).value;
|
|
});
|
|
const normalizedRules = computed(() => {
|
|
const { required: required4 } = props2;
|
|
const rules2 = [];
|
|
if (props2.rules) {
|
|
rules2.push(...castArray_default(props2.rules));
|
|
}
|
|
const formRules = formContext == null ? void 0 : formContext.rules;
|
|
if (formRules && props2.prop) {
|
|
const _rules = getProp(formRules, props2.prop).value;
|
|
if (_rules) {
|
|
rules2.push(...castArray_default(_rules));
|
|
}
|
|
}
|
|
if (required4 !== void 0) {
|
|
const requiredRules = rules2.map((rule, i) => [rule, i]).filter(([rule]) => Object.keys(rule).includes("required"));
|
|
if (requiredRules.length > 0) {
|
|
for (const [rule, i] of requiredRules) {
|
|
if (rule.required === required4)
|
|
continue;
|
|
rules2[i] = { ...rule, required: required4 };
|
|
}
|
|
} else {
|
|
rules2.push({ required: required4 });
|
|
}
|
|
}
|
|
return rules2;
|
|
});
|
|
const validateEnabled = computed(() => normalizedRules.value.length > 0);
|
|
const getFilteredRule = (trigger) => {
|
|
const rules2 = normalizedRules.value;
|
|
return rules2.filter((rule) => {
|
|
if (!rule.trigger || !trigger)
|
|
return true;
|
|
if (isArray(rule.trigger)) {
|
|
return rule.trigger.includes(trigger);
|
|
} else {
|
|
return rule.trigger === trigger;
|
|
}
|
|
}).map(({ trigger: trigger2, ...rule }) => rule);
|
|
};
|
|
const isRequired = computed(() => normalizedRules.value.some((rule) => rule.required));
|
|
const shouldShowError = computed(() => {
|
|
var _a2;
|
|
return validateStateDebounced.value === "error" && props2.showMessage && ((_a2 = formContext == null ? void 0 : formContext.showMessage) != null ? _a2 : true);
|
|
});
|
|
const currentLabel = computed(() => `${props2.label || ""}${(formContext == null ? void 0 : formContext.labelSuffix) || ""}`);
|
|
const setValidationState = (state) => {
|
|
validateState.value = state;
|
|
};
|
|
const onValidationFailed = (error) => {
|
|
var _a2, _b;
|
|
const { errors, fields } = error;
|
|
if (!errors || !fields) {
|
|
console.error(error);
|
|
}
|
|
setValidationState("error");
|
|
validateMessage.value = errors ? (_b = (_a2 = errors == null ? void 0 : errors[0]) == null ? void 0 : _a2.message) != null ? _b : `${props2.prop} is required` : "";
|
|
formContext == null ? void 0 : formContext.emit("validate", props2.prop, false, validateMessage.value);
|
|
};
|
|
const onValidationSucceeded = () => {
|
|
setValidationState("success");
|
|
formContext == null ? void 0 : formContext.emit("validate", props2.prop, true, "");
|
|
};
|
|
const doValidate = async (rules2) => {
|
|
const modelName = propString.value;
|
|
const validator = new Schema({
|
|
[modelName]: rules2
|
|
});
|
|
return validator.validate({ [modelName]: fieldValue.value }, { firstFields: true }).then(() => {
|
|
onValidationSucceeded();
|
|
return true;
|
|
}).catch((err) => {
|
|
onValidationFailed(err);
|
|
return Promise.reject(err);
|
|
});
|
|
};
|
|
const validate = async (trigger, callback) => {
|
|
if (isResettingField || !props2.prop) {
|
|
return false;
|
|
}
|
|
const hasCallback = isFunction(callback);
|
|
if (!validateEnabled.value) {
|
|
callback == null ? void 0 : callback(false);
|
|
return false;
|
|
}
|
|
const rules2 = getFilteredRule(trigger);
|
|
if (rules2.length === 0) {
|
|
callback == null ? void 0 : callback(true);
|
|
return true;
|
|
}
|
|
setValidationState("validating");
|
|
return doValidate(rules2).then(() => {
|
|
callback == null ? void 0 : callback(true);
|
|
return true;
|
|
}).catch((err) => {
|
|
const { fields } = err;
|
|
callback == null ? void 0 : callback(false, fields);
|
|
return hasCallback ? false : Promise.reject(fields);
|
|
});
|
|
};
|
|
const clearValidate = () => {
|
|
setValidationState("");
|
|
validateMessage.value = "";
|
|
isResettingField = false;
|
|
};
|
|
const resetField = async () => {
|
|
const model = formContext == null ? void 0 : formContext.model;
|
|
if (!model || !props2.prop)
|
|
return;
|
|
const computedValue = getProp(model, props2.prop);
|
|
isResettingField = true;
|
|
computedValue.value = clone_default(initialValue);
|
|
await nextTick();
|
|
clearValidate();
|
|
isResettingField = false;
|
|
};
|
|
const addInputId = (id) => {
|
|
if (!inputIds.value.includes(id)) {
|
|
inputIds.value.push(id);
|
|
}
|
|
};
|
|
const removeInputId = (id) => {
|
|
inputIds.value = inputIds.value.filter((listId) => listId !== id);
|
|
};
|
|
watch(() => props2.error, (val) => {
|
|
validateMessage.value = val || "";
|
|
setValidationState(val ? "error" : "");
|
|
}, { immediate: true });
|
|
watch(() => props2.validateStatus, (val) => setValidationState(val || ""));
|
|
const context = reactive({
|
|
...toRefs(props2),
|
|
$el: formItemRef,
|
|
size: _size,
|
|
validateState,
|
|
labelId,
|
|
inputIds,
|
|
isGroup,
|
|
hasLabel,
|
|
fieldValue,
|
|
addInputId,
|
|
removeInputId,
|
|
resetField,
|
|
clearValidate,
|
|
validate
|
|
});
|
|
provide(formItemContextKey, context);
|
|
onMounted(() => {
|
|
if (props2.prop) {
|
|
formContext == null ? void 0 : formContext.addField(context);
|
|
initialValue = clone_default(fieldValue.value);
|
|
}
|
|
});
|
|
onBeforeUnmount(() => {
|
|
formContext == null ? void 0 : formContext.removeField(context);
|
|
});
|
|
expose({
|
|
size: _size,
|
|
validateMessage,
|
|
validateState,
|
|
validate,
|
|
clearValidate,
|
|
resetField
|
|
});
|
|
return (_ctx, _cache) => {
|
|
var _a2;
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "formItemRef",
|
|
ref: formItemRef,
|
|
class: normalizeClass(unref(formItemClasses)),
|
|
role: unref(isGroup) ? "group" : void 0,
|
|
"aria-labelledby": unref(isGroup) ? unref(labelId) : void 0
|
|
}, [
|
|
createVNode(unref(FormLabelWrap), {
|
|
"is-auto-width": unref(labelStyle).width === "auto",
|
|
"update-all": ((_a2 = unref(formContext)) == null ? void 0 : _a2.labelWidth) === "auto"
|
|
}, {
|
|
default: withCtx(() => [
|
|
unref(hasLabel) ? (openBlock(), createBlock(resolveDynamicComponent(unref(labelFor) ? "label" : "div"), {
|
|
key: 0,
|
|
id: unref(labelId),
|
|
for: unref(labelFor),
|
|
class: normalizeClass(unref(ns).e("label")),
|
|
style: normalizeStyle(unref(labelStyle))
|
|
}, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "label", { label: unref(currentLabel) }, () => [
|
|
createTextVNode(toDisplayString(unref(currentLabel)), 1)
|
|
])
|
|
]),
|
|
_: 3
|
|
}, 8, ["id", "for", "class", "style"])) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 8, ["is-auto-width", "update-all"]),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("content")),
|
|
style: normalizeStyle(unref(contentStyle))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default"),
|
|
createVNode(TransitionGroup, {
|
|
name: `${unref(ns).namespace.value}-zoom-in-top`
|
|
}, {
|
|
default: withCtx(() => [
|
|
unref(shouldShowError) ? renderSlot(_ctx.$slots, "error", {
|
|
key: 0,
|
|
error: validateMessage.value
|
|
}, () => [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(validateClasses))
|
|
}, toDisplayString(validateMessage.value), 3)
|
|
]) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 8, ["name"])
|
|
], 6)
|
|
], 10, ["role", "aria-labelledby"]);
|
|
};
|
|
}
|
|
});
|
|
var FormItem = _export_sfc(_sfc_main86, [["__file", "form-item.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/form/index.mjs
|
|
var ElForm = withInstall(Form, {
|
|
FormItem
|
|
});
|
|
var ElFormItem = withNoopInstall(FormItem);
|
|
|
|
// node_modules/element-plus/es/components/image-viewer/src/image-viewer.mjs
|
|
var imageViewerProps = buildProps({
|
|
urlList: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([])
|
|
},
|
|
zIndex: {
|
|
type: Number
|
|
},
|
|
initialIndex: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
infinite: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
hideOnClickModal: Boolean,
|
|
teleported: Boolean,
|
|
closeOnPressEscape: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
zoomRate: {
|
|
type: Number,
|
|
default: 1.2
|
|
},
|
|
minScale: {
|
|
type: Number,
|
|
default: 0.2
|
|
},
|
|
maxScale: {
|
|
type: Number,
|
|
default: 7
|
|
},
|
|
showProgress: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
crossorigin: {
|
|
type: definePropType(String)
|
|
}
|
|
});
|
|
var imageViewerEmits = {
|
|
close: () => true,
|
|
switch: (index) => isNumber2(index),
|
|
rotate: (deg) => isNumber2(deg)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/image-viewer/src/image-viewer2.mjs
|
|
var __default__60 = defineComponent({
|
|
name: "ElImageViewer"
|
|
});
|
|
var _sfc_main87 = defineComponent({
|
|
...__default__60,
|
|
props: imageViewerProps,
|
|
emits: imageViewerEmits,
|
|
setup(__props, { expose, emit }) {
|
|
var _a2;
|
|
const props2 = __props;
|
|
const modes = {
|
|
CONTAIN: {
|
|
name: "contain",
|
|
icon: markRaw(full_screen_default)
|
|
},
|
|
ORIGINAL: {
|
|
name: "original",
|
|
icon: markRaw(scale_to_original_default)
|
|
}
|
|
};
|
|
let stopWheelListener;
|
|
let prevOverflow = "";
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("image-viewer");
|
|
const { nextZIndex } = useZIndex();
|
|
const wrapper = ref();
|
|
const imgRefs = ref([]);
|
|
const scopeEventListener = effectScope();
|
|
const loading = ref(true);
|
|
const activeIndex = ref(props2.initialIndex);
|
|
const mode = shallowRef(modes.CONTAIN);
|
|
const transform2 = ref({
|
|
scale: 1,
|
|
deg: 0,
|
|
offsetX: 0,
|
|
offsetY: 0,
|
|
enableTransition: false
|
|
});
|
|
const zIndex2 = ref((_a2 = props2.zIndex) != null ? _a2 : nextZIndex());
|
|
const isSingle = computed(() => {
|
|
const { urlList } = props2;
|
|
return urlList.length <= 1;
|
|
});
|
|
const isFirst = computed(() => activeIndex.value === 0);
|
|
const isLast = computed(() => activeIndex.value === props2.urlList.length - 1);
|
|
const currentImg = computed(() => props2.urlList[activeIndex.value]);
|
|
const arrowPrevKls = computed(() => [
|
|
ns.e("btn"),
|
|
ns.e("prev"),
|
|
ns.is("disabled", !props2.infinite && isFirst.value)
|
|
]);
|
|
const arrowNextKls = computed(() => [
|
|
ns.e("btn"),
|
|
ns.e("next"),
|
|
ns.is("disabled", !props2.infinite && isLast.value)
|
|
]);
|
|
const imgStyle = computed(() => {
|
|
const { scale, deg, offsetX, offsetY, enableTransition } = transform2.value;
|
|
let translateX = offsetX / scale;
|
|
let translateY = offsetY / scale;
|
|
const radian = deg * Math.PI / 180;
|
|
const cosRadian = Math.cos(radian);
|
|
const sinRadian = Math.sin(radian);
|
|
translateX = translateX * cosRadian + translateY * sinRadian;
|
|
translateY = translateY * cosRadian - offsetX / scale * sinRadian;
|
|
const style = {
|
|
transform: `scale(${scale}) rotate(${deg}deg) translate(${translateX}px, ${translateY}px)`,
|
|
transition: enableTransition ? "transform .3s" : ""
|
|
};
|
|
if (mode.value.name === modes.CONTAIN.name) {
|
|
style.maxWidth = style.maxHeight = "100%";
|
|
}
|
|
return style;
|
|
});
|
|
const progress = computed(() => `${activeIndex.value + 1} / ${props2.urlList.length}`);
|
|
function hide2() {
|
|
unregisterEventListener();
|
|
stopWheelListener == null ? void 0 : stopWheelListener();
|
|
document.body.style.overflow = prevOverflow;
|
|
emit("close");
|
|
}
|
|
function registerEventListener() {
|
|
const keydownHandler = throttle_default((e) => {
|
|
switch (e.code) {
|
|
case EVENT_CODE.esc:
|
|
props2.closeOnPressEscape && hide2();
|
|
break;
|
|
case EVENT_CODE.space:
|
|
toggleMode();
|
|
break;
|
|
case EVENT_CODE.left:
|
|
prev();
|
|
break;
|
|
case EVENT_CODE.up:
|
|
handleActions("zoomIn");
|
|
break;
|
|
case EVENT_CODE.right:
|
|
next();
|
|
break;
|
|
case EVENT_CODE.down:
|
|
handleActions("zoomOut");
|
|
break;
|
|
}
|
|
});
|
|
const mousewheelHandler = throttle_default((e) => {
|
|
const delta = e.deltaY || e.deltaX;
|
|
handleActions(delta < 0 ? "zoomIn" : "zoomOut", {
|
|
zoomRate: props2.zoomRate,
|
|
enableTransition: false
|
|
});
|
|
});
|
|
scopeEventListener.run(() => {
|
|
useEventListener(document, "keydown", keydownHandler);
|
|
useEventListener(document, "wheel", mousewheelHandler);
|
|
});
|
|
}
|
|
function unregisterEventListener() {
|
|
scopeEventListener.stop();
|
|
}
|
|
function handleImgLoad() {
|
|
loading.value = false;
|
|
}
|
|
function handleImgError(e) {
|
|
loading.value = false;
|
|
e.target.alt = t("el.image.error");
|
|
}
|
|
function handleMouseDown(e) {
|
|
if (loading.value || e.button !== 0 || !wrapper.value)
|
|
return;
|
|
transform2.value.enableTransition = false;
|
|
const { offsetX, offsetY } = transform2.value;
|
|
const startX = e.pageX;
|
|
const startY = e.pageY;
|
|
const dragHandler = throttle_default((ev) => {
|
|
transform2.value = {
|
|
...transform2.value,
|
|
offsetX: offsetX + ev.pageX - startX,
|
|
offsetY: offsetY + ev.pageY - startY
|
|
};
|
|
});
|
|
const removeMousemove = useEventListener(document, "mousemove", dragHandler);
|
|
useEventListener(document, "mouseup", () => {
|
|
removeMousemove();
|
|
});
|
|
e.preventDefault();
|
|
}
|
|
function reset() {
|
|
transform2.value = {
|
|
scale: 1,
|
|
deg: 0,
|
|
offsetX: 0,
|
|
offsetY: 0,
|
|
enableTransition: false
|
|
};
|
|
}
|
|
function toggleMode() {
|
|
if (loading.value)
|
|
return;
|
|
const modeNames = keysOf(modes);
|
|
const modeValues = Object.values(modes);
|
|
const currentMode = mode.value.name;
|
|
const index = modeValues.findIndex((i) => i.name === currentMode);
|
|
const nextIndex = (index + 1) % modeNames.length;
|
|
mode.value = modes[modeNames[nextIndex]];
|
|
reset();
|
|
}
|
|
function setActiveItem(index) {
|
|
const len = props2.urlList.length;
|
|
activeIndex.value = (index + len) % len;
|
|
}
|
|
function prev() {
|
|
if (isFirst.value && !props2.infinite)
|
|
return;
|
|
setActiveItem(activeIndex.value - 1);
|
|
}
|
|
function next() {
|
|
if (isLast.value && !props2.infinite)
|
|
return;
|
|
setActiveItem(activeIndex.value + 1);
|
|
}
|
|
function handleActions(action, options = {}) {
|
|
if (loading.value)
|
|
return;
|
|
const { minScale, maxScale } = props2;
|
|
const { zoomRate, rotateDeg, enableTransition } = {
|
|
zoomRate: props2.zoomRate,
|
|
rotateDeg: 90,
|
|
enableTransition: true,
|
|
...options
|
|
};
|
|
switch (action) {
|
|
case "zoomOut":
|
|
if (transform2.value.scale > minScale) {
|
|
transform2.value.scale = Number.parseFloat((transform2.value.scale / zoomRate).toFixed(3));
|
|
}
|
|
break;
|
|
case "zoomIn":
|
|
if (transform2.value.scale < maxScale) {
|
|
transform2.value.scale = Number.parseFloat((transform2.value.scale * zoomRate).toFixed(3));
|
|
}
|
|
break;
|
|
case "clockwise":
|
|
transform2.value.deg += rotateDeg;
|
|
emit("rotate", transform2.value.deg);
|
|
break;
|
|
case "anticlockwise":
|
|
transform2.value.deg -= rotateDeg;
|
|
emit("rotate", transform2.value.deg);
|
|
break;
|
|
}
|
|
transform2.value.enableTransition = enableTransition;
|
|
}
|
|
function onFocusoutPrevented(event) {
|
|
var _a22;
|
|
if (((_a22 = event.detail) == null ? void 0 : _a22.focusReason) === "pointer") {
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
function onCloseRequested() {
|
|
if (props2.closeOnPressEscape) {
|
|
hide2();
|
|
}
|
|
}
|
|
function wheelHandler(e) {
|
|
if (!e.ctrlKey)
|
|
return;
|
|
if (e.deltaY < 0) {
|
|
e.preventDefault();
|
|
return false;
|
|
} else if (e.deltaY > 0) {
|
|
e.preventDefault();
|
|
return false;
|
|
}
|
|
}
|
|
watch(currentImg, () => {
|
|
nextTick(() => {
|
|
const $img = imgRefs.value[0];
|
|
if (!($img == null ? void 0 : $img.complete)) {
|
|
loading.value = true;
|
|
}
|
|
});
|
|
});
|
|
watch(activeIndex, (val) => {
|
|
reset();
|
|
emit("switch", val);
|
|
});
|
|
onMounted(() => {
|
|
registerEventListener();
|
|
stopWheelListener = useEventListener("wheel", wheelHandler, {
|
|
passive: false
|
|
});
|
|
prevOverflow = document.body.style.overflow;
|
|
document.body.style.overflow = "hidden";
|
|
});
|
|
expose({
|
|
setActiveItem
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElTeleport), {
|
|
to: "body",
|
|
disabled: !_ctx.teleported
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(Transition, {
|
|
name: "viewer-fade",
|
|
appear: ""
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
ref_key: "wrapper",
|
|
ref: wrapper,
|
|
tabindex: -1,
|
|
class: normalizeClass(unref(ns).e("wrapper")),
|
|
style: normalizeStyle({ zIndex: zIndex2.value })
|
|
}, [
|
|
createVNode(unref(ElFocusTrap), {
|
|
loop: "",
|
|
trapped: "",
|
|
"focus-trap-el": wrapper.value,
|
|
"focus-start-el": "container",
|
|
onFocusoutPrevented,
|
|
onReleaseRequested: onCloseRequested
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("mask")),
|
|
onClick: withModifiers(($event) => _ctx.hideOnClickModal && hide2(), ["self"])
|
|
}, null, 10, ["onClick"]),
|
|
createCommentVNode(" CLOSE "),
|
|
createBaseVNode("span", {
|
|
class: normalizeClass([unref(ns).e("btn"), unref(ns).e("close")]),
|
|
onClick: hide2
|
|
}, [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(close_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
], 2),
|
|
createCommentVNode(" ARROW "),
|
|
!unref(isSingle) ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(arrowPrevKls)),
|
|
onClick: prev
|
|
}, [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(arrow_left_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
], 2),
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(arrowNextKls)),
|
|
onClick: next
|
|
}, [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(arrow_right_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
], 2)
|
|
], 64)) : createCommentVNode("v-if", true),
|
|
_ctx.$slots.progress || _ctx.showProgress ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass([unref(ns).e("btn"), unref(ns).e("progress")])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "progress", {
|
|
activeIndex: activeIndex.value,
|
|
total: _ctx.urlList.length
|
|
}, () => [
|
|
createTextVNode(toDisplayString(unref(progress)), 1)
|
|
])
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createCommentVNode(" ACTIONS "),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([unref(ns).e("btn"), unref(ns).e("actions")])
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("actions__inner"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "toolbar", {
|
|
actions: handleActions,
|
|
prev,
|
|
next,
|
|
reset: toggleMode,
|
|
activeIndex: activeIndex.value,
|
|
setActiveItem
|
|
}, () => [
|
|
createVNode(unref(ElIcon), {
|
|
onClick: ($event) => handleActions("zoomOut")
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(zoom_out_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["onClick"]),
|
|
createVNode(unref(ElIcon), {
|
|
onClick: ($event) => handleActions("zoomIn")
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(zoom_in_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["onClick"]),
|
|
createBaseVNode("i", {
|
|
class: normalizeClass(unref(ns).e("actions__divider"))
|
|
}, null, 2),
|
|
createVNode(unref(ElIcon), { onClick: toggleMode }, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(unref(mode).icon)))
|
|
]),
|
|
_: 1
|
|
}),
|
|
createBaseVNode("i", {
|
|
class: normalizeClass(unref(ns).e("actions__divider"))
|
|
}, null, 2),
|
|
createVNode(unref(ElIcon), {
|
|
onClick: ($event) => handleActions("anticlockwise")
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(refresh_left_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["onClick"]),
|
|
createVNode(unref(ElIcon), {
|
|
onClick: ($event) => handleActions("clockwise")
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(refresh_right_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["onClick"])
|
|
])
|
|
], 2)
|
|
], 2),
|
|
createCommentVNode(" CANVAS "),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("canvas"))
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.urlList, (url2, i) => {
|
|
return openBlock(), createElementBlock(Fragment, { key: i }, [
|
|
i === activeIndex.value ? (openBlock(), createElementBlock("img", {
|
|
key: 0,
|
|
ref_for: true,
|
|
ref: (el) => imgRefs.value[i] = el,
|
|
src: url2,
|
|
style: normalizeStyle(unref(imgStyle)),
|
|
class: normalizeClass(unref(ns).e("img")),
|
|
crossorigin: _ctx.crossorigin,
|
|
onLoad: handleImgLoad,
|
|
onError: handleImgError,
|
|
onMousedown: handleMouseDown
|
|
}, null, 46, ["src", "crossorigin"])) : createCommentVNode("v-if", true)
|
|
], 64);
|
|
}), 128))
|
|
], 2),
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 8, ["focus-trap-el"])
|
|
], 6)
|
|
]),
|
|
_: 3
|
|
})
|
|
]),
|
|
_: 3
|
|
}, 8, ["disabled"]);
|
|
};
|
|
}
|
|
});
|
|
var ImageViewer = _export_sfc(_sfc_main87, [["__file", "image-viewer.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/image-viewer/index.mjs
|
|
var ElImageViewer = withInstall(ImageViewer);
|
|
|
|
// node_modules/element-plus/es/components/image/src/image.mjs
|
|
var imageProps = buildProps({
|
|
hideOnClickModal: Boolean,
|
|
src: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
fit: {
|
|
type: String,
|
|
values: ["", "contain", "cover", "fill", "none", "scale-down"],
|
|
default: ""
|
|
},
|
|
loading: {
|
|
type: String,
|
|
values: ["eager", "lazy"]
|
|
},
|
|
lazy: Boolean,
|
|
scrollContainer: {
|
|
type: definePropType([String, Object])
|
|
},
|
|
previewSrcList: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([])
|
|
},
|
|
previewTeleported: Boolean,
|
|
zIndex: {
|
|
type: Number
|
|
},
|
|
initialIndex: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
infinite: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
closeOnPressEscape: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
zoomRate: {
|
|
type: Number,
|
|
default: 1.2
|
|
},
|
|
minScale: {
|
|
type: Number,
|
|
default: 0.2
|
|
},
|
|
maxScale: {
|
|
type: Number,
|
|
default: 7
|
|
},
|
|
showProgress: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
crossorigin: {
|
|
type: definePropType(String)
|
|
}
|
|
});
|
|
var imageEmits = {
|
|
load: (evt) => evt instanceof Event,
|
|
error: (evt) => evt instanceof Event,
|
|
switch: (val) => isNumber2(val),
|
|
close: () => true,
|
|
show: () => true
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/image/src/image2.mjs
|
|
var __default__61 = defineComponent({
|
|
name: "ElImage",
|
|
inheritAttrs: false
|
|
});
|
|
var _sfc_main88 = defineComponent({
|
|
...__default__61,
|
|
props: imageProps,
|
|
emits: imageEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("image");
|
|
const rawAttrs = useAttrs();
|
|
const containerAttrs = computed(() => {
|
|
return fromPairs_default(Object.entries(rawAttrs).filter(([key]) => /^(data-|on[A-Z])/i.test(key) || ["id", "style"].includes(key)));
|
|
});
|
|
const imgAttrs = useAttrs2({
|
|
excludeListeners: true,
|
|
excludeKeys: computed(() => {
|
|
return Object.keys(containerAttrs.value);
|
|
})
|
|
});
|
|
const imageSrc = ref();
|
|
const hasLoadError = ref(false);
|
|
const isLoading = ref(true);
|
|
const showViewer = ref(false);
|
|
const container = ref();
|
|
const _scrollContainer = ref();
|
|
const supportLoading = isClient && "loading" in HTMLImageElement.prototype;
|
|
let stopScrollListener;
|
|
const imageKls = computed(() => [
|
|
ns.e("inner"),
|
|
preview.value && ns.e("preview"),
|
|
isLoading.value && ns.is("loading")
|
|
]);
|
|
const imageStyle = computed(() => {
|
|
const { fit } = props2;
|
|
if (isClient && fit) {
|
|
return { objectFit: fit };
|
|
}
|
|
return {};
|
|
});
|
|
const preview = computed(() => {
|
|
const { previewSrcList } = props2;
|
|
return isArray(previewSrcList) && previewSrcList.length > 0;
|
|
});
|
|
const imageIndex = computed(() => {
|
|
const { previewSrcList, initialIndex } = props2;
|
|
let previewIndex = initialIndex;
|
|
if (initialIndex > previewSrcList.length - 1) {
|
|
previewIndex = 0;
|
|
}
|
|
return previewIndex;
|
|
});
|
|
const isManual = computed(() => {
|
|
if (props2.loading === "eager")
|
|
return false;
|
|
return !supportLoading && props2.loading === "lazy" || props2.lazy;
|
|
});
|
|
const loadImage = () => {
|
|
if (!isClient)
|
|
return;
|
|
isLoading.value = true;
|
|
hasLoadError.value = false;
|
|
imageSrc.value = props2.src;
|
|
};
|
|
function handleLoad(event) {
|
|
isLoading.value = false;
|
|
hasLoadError.value = false;
|
|
emit("load", event);
|
|
}
|
|
function handleError(event) {
|
|
isLoading.value = false;
|
|
hasLoadError.value = true;
|
|
emit("error", event);
|
|
}
|
|
function handleLazyLoad() {
|
|
if (isInContainer(container.value, _scrollContainer.value)) {
|
|
loadImage();
|
|
removeLazyLoadListener();
|
|
}
|
|
}
|
|
const lazyLoadHandler = useThrottleFn(handleLazyLoad, 200, true);
|
|
async function addLazyLoadListener() {
|
|
var _a2;
|
|
if (!isClient)
|
|
return;
|
|
await nextTick();
|
|
const { scrollContainer } = props2;
|
|
if (isElement2(scrollContainer)) {
|
|
_scrollContainer.value = scrollContainer;
|
|
} else if (isString(scrollContainer) && scrollContainer !== "") {
|
|
_scrollContainer.value = (_a2 = document.querySelector(scrollContainer)) != null ? _a2 : void 0;
|
|
} else if (container.value) {
|
|
_scrollContainer.value = getScrollContainer(container.value);
|
|
}
|
|
if (_scrollContainer.value) {
|
|
stopScrollListener = useEventListener(_scrollContainer, "scroll", lazyLoadHandler);
|
|
setTimeout(() => handleLazyLoad(), 100);
|
|
}
|
|
}
|
|
function removeLazyLoadListener() {
|
|
if (!isClient || !_scrollContainer.value || !lazyLoadHandler)
|
|
return;
|
|
stopScrollListener == null ? void 0 : stopScrollListener();
|
|
_scrollContainer.value = void 0;
|
|
}
|
|
function clickHandler() {
|
|
if (!preview.value)
|
|
return;
|
|
showViewer.value = true;
|
|
emit("show");
|
|
}
|
|
function closeViewer() {
|
|
showViewer.value = false;
|
|
emit("close");
|
|
}
|
|
function switchViewer(val) {
|
|
emit("switch", val);
|
|
}
|
|
watch(() => props2.src, () => {
|
|
if (isManual.value) {
|
|
isLoading.value = true;
|
|
hasLoadError.value = false;
|
|
removeLazyLoadListener();
|
|
addLazyLoadListener();
|
|
} else {
|
|
loadImage();
|
|
}
|
|
});
|
|
onMounted(() => {
|
|
if (isManual.value) {
|
|
addLazyLoadListener();
|
|
} else {
|
|
loadImage();
|
|
}
|
|
});
|
|
expose({
|
|
showPreview: clickHandler
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", mergeProps({
|
|
ref_key: "container",
|
|
ref: container
|
|
}, unref(containerAttrs), {
|
|
class: [unref(ns).b(), _ctx.$attrs.class]
|
|
}), [
|
|
hasLoadError.value ? renderSlot(_ctx.$slots, "error", { key: 0 }, () => [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("error"))
|
|
}, toDisplayString(unref(t)("el.image.error")), 3)
|
|
]) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
|
|
imageSrc.value !== void 0 ? (openBlock(), createElementBlock("img", mergeProps({ key: 0 }, unref(imgAttrs), {
|
|
src: imageSrc.value,
|
|
loading: _ctx.loading,
|
|
style: unref(imageStyle),
|
|
class: unref(imageKls),
|
|
crossorigin: _ctx.crossorigin,
|
|
onClick: clickHandler,
|
|
onLoad: handleLoad,
|
|
onError: handleError
|
|
}), null, 16, ["src", "loading", "crossorigin"])) : createCommentVNode("v-if", true),
|
|
isLoading.value ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("wrapper"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "placeholder", {}, () => [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("placeholder"))
|
|
}, null, 2)
|
|
])
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 64)),
|
|
unref(preview) ? (openBlock(), createElementBlock(Fragment, { key: 2 }, [
|
|
showViewer.value ? (openBlock(), createBlock(unref(ElImageViewer), {
|
|
key: 0,
|
|
"z-index": _ctx.zIndex,
|
|
"initial-index": unref(imageIndex),
|
|
infinite: _ctx.infinite,
|
|
"zoom-rate": _ctx.zoomRate,
|
|
"min-scale": _ctx.minScale,
|
|
"max-scale": _ctx.maxScale,
|
|
"show-progress": _ctx.showProgress,
|
|
"url-list": _ctx.previewSrcList,
|
|
crossorigin: _ctx.crossorigin,
|
|
"hide-on-click-modal": _ctx.hideOnClickModal,
|
|
teleported: _ctx.previewTeleported,
|
|
"close-on-press-escape": _ctx.closeOnPressEscape,
|
|
onClose: closeViewer,
|
|
onSwitch: switchViewer
|
|
}, createSlots({
|
|
toolbar: withCtx((toolbar) => [
|
|
renderSlot(_ctx.$slots, "toolbar", normalizeProps(guardReactiveProps(toolbar)))
|
|
]),
|
|
default: withCtx(() => [
|
|
_ctx.$slots.viewer ? (openBlock(), createElementBlock("div", { key: 0 }, [
|
|
renderSlot(_ctx.$slots, "viewer")
|
|
])) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 2
|
|
}, [
|
|
_ctx.$slots.progress ? {
|
|
name: "progress",
|
|
fn: withCtx((progress) => [
|
|
renderSlot(_ctx.$slots, "progress", normalizeProps(guardReactiveProps(progress)))
|
|
])
|
|
} : void 0
|
|
]), 1032, ["z-index", "initial-index", "infinite", "zoom-rate", "min-scale", "max-scale", "show-progress", "url-list", "crossorigin", "hide-on-click-modal", "teleported", "close-on-press-escape"])) : createCommentVNode("v-if", true)
|
|
], 64)) : createCommentVNode("v-if", true)
|
|
], 16);
|
|
};
|
|
}
|
|
});
|
|
var Image2 = _export_sfc(_sfc_main88, [["__file", "image.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/image/index.mjs
|
|
var ElImage = withInstall(Image2);
|
|
|
|
// node_modules/element-plus/es/components/input-number/src/input-number.mjs
|
|
var inputNumberProps = buildProps({
|
|
id: {
|
|
type: String,
|
|
default: void 0
|
|
},
|
|
step: {
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
stepStrictly: Boolean,
|
|
max: {
|
|
type: Number,
|
|
default: Number.POSITIVE_INFINITY
|
|
},
|
|
min: {
|
|
type: Number,
|
|
default: Number.NEGATIVE_INFINITY
|
|
},
|
|
modelValue: {
|
|
type: [Number, null]
|
|
},
|
|
readonly: Boolean,
|
|
disabled: Boolean,
|
|
size: useSizeProp,
|
|
controls: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
controlsPosition: {
|
|
type: String,
|
|
default: "",
|
|
values: ["", "right"]
|
|
},
|
|
valueOnClear: {
|
|
type: [String, Number, null],
|
|
validator: (val) => val === null || isNumber2(val) || ["min", "max"].includes(val),
|
|
default: null
|
|
},
|
|
name: String,
|
|
placeholder: String,
|
|
precision: {
|
|
type: Number,
|
|
validator: (val) => val >= 0 && val === Number.parseInt(`${val}`, 10)
|
|
},
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
...useAriaProps(["ariaLabel"])
|
|
});
|
|
var inputNumberEmits = {
|
|
[CHANGE_EVENT]: (cur, prev) => prev !== cur,
|
|
blur: (e) => e instanceof FocusEvent,
|
|
focus: (e) => e instanceof FocusEvent,
|
|
[INPUT_EVENT]: (val) => isNumber2(val) || isNil_default(val),
|
|
[UPDATE_MODEL_EVENT]: (val) => isNumber2(val) || isNil_default(val)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/input-number/src/input-number2.mjs
|
|
var __default__62 = defineComponent({
|
|
name: "ElInputNumber"
|
|
});
|
|
var _sfc_main89 = defineComponent({
|
|
...__default__62,
|
|
props: inputNumberProps,
|
|
emits: inputNumberEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("input-number");
|
|
const input = ref();
|
|
const data = reactive({
|
|
currentValue: props2.modelValue,
|
|
userInput: null
|
|
});
|
|
const { formItem } = useFormItem();
|
|
const minDisabled = computed(() => isNumber2(props2.modelValue) && props2.modelValue <= props2.min);
|
|
const maxDisabled = computed(() => isNumber2(props2.modelValue) && props2.modelValue >= props2.max);
|
|
const numPrecision = computed(() => {
|
|
const stepPrecision = getPrecision(props2.step);
|
|
if (!isUndefined2(props2.precision)) {
|
|
if (stepPrecision > props2.precision) {
|
|
debugWarn("InputNumber", "precision should not be less than the decimal places of step");
|
|
}
|
|
return props2.precision;
|
|
} else {
|
|
return Math.max(getPrecision(props2.modelValue), stepPrecision);
|
|
}
|
|
});
|
|
const controlsAtRight = computed(() => {
|
|
return props2.controls && props2.controlsPosition === "right";
|
|
});
|
|
const inputNumberSize = useFormSize();
|
|
const inputNumberDisabled = useFormDisabled();
|
|
const displayValue = computed(() => {
|
|
if (data.userInput !== null) {
|
|
return data.userInput;
|
|
}
|
|
let currentValue = data.currentValue;
|
|
if (isNil_default(currentValue))
|
|
return "";
|
|
if (isNumber2(currentValue)) {
|
|
if (Number.isNaN(currentValue))
|
|
return "";
|
|
if (!isUndefined2(props2.precision)) {
|
|
currentValue = currentValue.toFixed(props2.precision);
|
|
}
|
|
}
|
|
return currentValue;
|
|
});
|
|
const toPrecision = (num, pre) => {
|
|
if (isUndefined2(pre))
|
|
pre = numPrecision.value;
|
|
if (pre === 0)
|
|
return Math.round(num);
|
|
let snum = String(num);
|
|
const pointPos = snum.indexOf(".");
|
|
if (pointPos === -1)
|
|
return num;
|
|
const nums = snum.replace(".", "").split("");
|
|
const datum = nums[pointPos + pre];
|
|
if (!datum)
|
|
return num;
|
|
const length = snum.length;
|
|
if (snum.charAt(length - 1) === "5") {
|
|
snum = `${snum.slice(0, Math.max(0, length - 1))}6`;
|
|
}
|
|
return Number.parseFloat(Number(snum).toFixed(pre));
|
|
};
|
|
const getPrecision = (value) => {
|
|
if (isNil_default(value))
|
|
return 0;
|
|
const valueString = value.toString();
|
|
const dotPosition = valueString.indexOf(".");
|
|
let precision = 0;
|
|
if (dotPosition !== -1) {
|
|
precision = valueString.length - dotPosition - 1;
|
|
}
|
|
return precision;
|
|
};
|
|
const ensurePrecision = (val, coefficient = 1) => {
|
|
if (!isNumber2(val))
|
|
return data.currentValue;
|
|
return toPrecision(val + props2.step * coefficient);
|
|
};
|
|
const increase = () => {
|
|
if (props2.readonly || inputNumberDisabled.value || maxDisabled.value)
|
|
return;
|
|
const value = Number(displayValue.value) || 0;
|
|
const newVal = ensurePrecision(value);
|
|
setCurrentValue(newVal);
|
|
emit(INPUT_EVENT, data.currentValue);
|
|
setCurrentValueToModelValue();
|
|
};
|
|
const decrease = () => {
|
|
if (props2.readonly || inputNumberDisabled.value || minDisabled.value)
|
|
return;
|
|
const value = Number(displayValue.value) || 0;
|
|
const newVal = ensurePrecision(value, -1);
|
|
setCurrentValue(newVal);
|
|
emit(INPUT_EVENT, data.currentValue);
|
|
setCurrentValueToModelValue();
|
|
};
|
|
const verifyValue = (value, update2) => {
|
|
const { max: max4, min: min4, step, precision, stepStrictly, valueOnClear } = props2;
|
|
if (max4 < min4) {
|
|
throwError("InputNumber", "min should not be greater than max.");
|
|
}
|
|
let newVal = Number(value);
|
|
if (isNil_default(value) || Number.isNaN(newVal)) {
|
|
return null;
|
|
}
|
|
if (value === "") {
|
|
if (valueOnClear === null) {
|
|
return null;
|
|
}
|
|
newVal = isString(valueOnClear) ? { min: min4, max: max4 }[valueOnClear] : valueOnClear;
|
|
}
|
|
if (stepStrictly) {
|
|
newVal = toPrecision(Math.round(newVal / step) * step, precision);
|
|
if (newVal !== value) {
|
|
update2 && emit(UPDATE_MODEL_EVENT, newVal);
|
|
}
|
|
}
|
|
if (!isUndefined2(precision)) {
|
|
newVal = toPrecision(newVal, precision);
|
|
}
|
|
if (newVal > max4 || newVal < min4) {
|
|
newVal = newVal > max4 ? max4 : min4;
|
|
update2 && emit(UPDATE_MODEL_EVENT, newVal);
|
|
}
|
|
return newVal;
|
|
};
|
|
const setCurrentValue = (value, emitChange = true) => {
|
|
var _a2;
|
|
const oldVal = data.currentValue;
|
|
const newVal = verifyValue(value);
|
|
if (!emitChange) {
|
|
emit(UPDATE_MODEL_EVENT, newVal);
|
|
return;
|
|
}
|
|
if (oldVal === newVal && value)
|
|
return;
|
|
data.userInput = null;
|
|
emit(UPDATE_MODEL_EVENT, newVal);
|
|
if (oldVal !== newVal) {
|
|
emit(CHANGE_EVENT, newVal, oldVal);
|
|
}
|
|
if (props2.validateEvent) {
|
|
(_a2 = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a2.call(formItem, "change").catch((err) => debugWarn(err));
|
|
}
|
|
data.currentValue = newVal;
|
|
};
|
|
const handleInput = (value) => {
|
|
data.userInput = value;
|
|
const newVal = value === "" ? null : Number(value);
|
|
emit(INPUT_EVENT, newVal);
|
|
setCurrentValue(newVal, false);
|
|
};
|
|
const handleInputChange = (value) => {
|
|
const newVal = value !== "" ? Number(value) : "";
|
|
if (isNumber2(newVal) && !Number.isNaN(newVal) || value === "") {
|
|
setCurrentValue(newVal);
|
|
}
|
|
setCurrentValueToModelValue();
|
|
data.userInput = null;
|
|
};
|
|
const focus = () => {
|
|
var _a2, _b;
|
|
(_b = (_a2 = input.value) == null ? void 0 : _a2.focus) == null ? void 0 : _b.call(_a2);
|
|
};
|
|
const blur = () => {
|
|
var _a2, _b;
|
|
(_b = (_a2 = input.value) == null ? void 0 : _a2.blur) == null ? void 0 : _b.call(_a2);
|
|
};
|
|
const handleFocus = (event) => {
|
|
emit("focus", event);
|
|
};
|
|
const handleBlur = (event) => {
|
|
var _a2, _b;
|
|
data.userInput = null;
|
|
if (isFirefox() && data.currentValue === null && ((_a2 = input.value) == null ? void 0 : _a2.input)) {
|
|
input.value.input.value = "";
|
|
}
|
|
emit("blur", event);
|
|
if (props2.validateEvent) {
|
|
(_b = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _b.call(formItem, "blur").catch((err) => debugWarn(err));
|
|
}
|
|
};
|
|
const setCurrentValueToModelValue = () => {
|
|
if (data.currentValue !== props2.modelValue) {
|
|
data.currentValue = props2.modelValue;
|
|
}
|
|
};
|
|
const handleWheel = (e) => {
|
|
if (document.activeElement === e.target)
|
|
e.preventDefault();
|
|
};
|
|
watch(() => props2.modelValue, (value, oldValue) => {
|
|
const newValue = verifyValue(value, true);
|
|
if (data.userInput === null && newValue !== oldValue) {
|
|
data.currentValue = newValue;
|
|
}
|
|
}, { immediate: true });
|
|
onMounted(() => {
|
|
var _a2;
|
|
const { min: min4, max: max4, modelValue } = props2;
|
|
const innerInput = (_a2 = input.value) == null ? void 0 : _a2.input;
|
|
innerInput.setAttribute("role", "spinbutton");
|
|
if (Number.isFinite(max4)) {
|
|
innerInput.setAttribute("aria-valuemax", String(max4));
|
|
} else {
|
|
innerInput.removeAttribute("aria-valuemax");
|
|
}
|
|
if (Number.isFinite(min4)) {
|
|
innerInput.setAttribute("aria-valuemin", String(min4));
|
|
} else {
|
|
innerInput.removeAttribute("aria-valuemin");
|
|
}
|
|
innerInput.setAttribute("aria-valuenow", data.currentValue || data.currentValue === 0 ? String(data.currentValue) : "");
|
|
innerInput.setAttribute("aria-disabled", String(inputNumberDisabled.value));
|
|
if (!isNumber2(modelValue) && modelValue != null) {
|
|
let val = Number(modelValue);
|
|
if (Number.isNaN(val)) {
|
|
val = null;
|
|
}
|
|
emit(UPDATE_MODEL_EVENT, val);
|
|
}
|
|
innerInput.addEventListener("wheel", handleWheel, { passive: false });
|
|
});
|
|
onUpdated(() => {
|
|
var _a2, _b;
|
|
const innerInput = (_a2 = input.value) == null ? void 0 : _a2.input;
|
|
innerInput == null ? void 0 : innerInput.setAttribute("aria-valuenow", `${(_b = data.currentValue) != null ? _b : ""}`);
|
|
});
|
|
expose({
|
|
focus,
|
|
blur
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([
|
|
unref(ns).b(),
|
|
unref(ns).m(unref(inputNumberSize)),
|
|
unref(ns).is("disabled", unref(inputNumberDisabled)),
|
|
unref(ns).is("without-controls", !_ctx.controls),
|
|
unref(ns).is("controls-right", unref(controlsAtRight))
|
|
]),
|
|
onDragstart: withModifiers(() => {
|
|
}, ["prevent"])
|
|
}, [
|
|
_ctx.controls ? withDirectives((openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
role: "button",
|
|
"aria-label": unref(t)("el.inputNumber.decrease"),
|
|
class: normalizeClass([unref(ns).e("decrease"), unref(ns).is("disabled", unref(minDisabled))]),
|
|
onKeydown: withKeys(decrease, ["enter"])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "decrease-icon", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
unref(controlsAtRight) ? (openBlock(), createBlock(unref(arrow_down_default), { key: 0 })) : (openBlock(), createBlock(unref(minus_default), { key: 1 }))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 42, ["aria-label", "onKeydown"])), [
|
|
[unref(vRepeatClick), decrease]
|
|
]) : createCommentVNode("v-if", true),
|
|
_ctx.controls ? withDirectives((openBlock(), createElementBlock("span", {
|
|
key: 1,
|
|
role: "button",
|
|
"aria-label": unref(t)("el.inputNumber.increase"),
|
|
class: normalizeClass([unref(ns).e("increase"), unref(ns).is("disabled", unref(maxDisabled))]),
|
|
onKeydown: withKeys(increase, ["enter"])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "increase-icon", {}, () => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
unref(controlsAtRight) ? (openBlock(), createBlock(unref(arrow_up_default), { key: 0 })) : (openBlock(), createBlock(unref(plus_default), { key: 1 }))
|
|
]),
|
|
_: 1
|
|
})
|
|
])
|
|
], 42, ["aria-label", "onKeydown"])), [
|
|
[unref(vRepeatClick), increase]
|
|
]) : createCommentVNode("v-if", true),
|
|
createVNode(unref(ElInput), {
|
|
id: _ctx.id,
|
|
ref_key: "input",
|
|
ref: input,
|
|
type: "number",
|
|
step: _ctx.step,
|
|
"model-value": unref(displayValue),
|
|
placeholder: _ctx.placeholder,
|
|
readonly: _ctx.readonly,
|
|
disabled: unref(inputNumberDisabled),
|
|
size: unref(inputNumberSize),
|
|
max: _ctx.max,
|
|
min: _ctx.min,
|
|
name: _ctx.name,
|
|
"aria-label": _ctx.ariaLabel,
|
|
"validate-event": false,
|
|
onKeydown: [
|
|
withKeys(withModifiers(increase, ["prevent"]), ["up"]),
|
|
withKeys(withModifiers(decrease, ["prevent"]), ["down"])
|
|
],
|
|
onBlur: handleBlur,
|
|
onFocus: handleFocus,
|
|
onInput: handleInput,
|
|
onChange: handleInputChange
|
|
}, createSlots({
|
|
_: 2
|
|
}, [
|
|
_ctx.$slots.prefix ? {
|
|
name: "prefix",
|
|
fn: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "prefix")
|
|
])
|
|
} : void 0,
|
|
_ctx.$slots.suffix ? {
|
|
name: "suffix",
|
|
fn: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "suffix")
|
|
])
|
|
} : void 0
|
|
]), 1032, ["id", "step", "model-value", "placeholder", "readonly", "disabled", "size", "max", "min", "name", "aria-label", "onKeydown"])
|
|
], 42, ["onDragstart"]);
|
|
};
|
|
}
|
|
});
|
|
var InputNumber = _export_sfc(_sfc_main89, [["__file", "input-number.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/input-number/index.mjs
|
|
var ElInputNumber = withInstall(InputNumber);
|
|
|
|
// node_modules/element-plus/es/components/input-tag/src/input-tag.mjs
|
|
var inputTagProps = buildProps({
|
|
modelValue: {
|
|
type: definePropType(Array)
|
|
},
|
|
max: Number,
|
|
tagType: { ...tagProps.type, default: "info" },
|
|
tagEffect: tagProps.effect,
|
|
trigger: {
|
|
type: definePropType(String),
|
|
default: EVENT_CODE.enter
|
|
},
|
|
draggable: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
delimiter: {
|
|
type: [String, RegExp],
|
|
default: ""
|
|
},
|
|
size: useSizeProp,
|
|
clearable: Boolean,
|
|
disabled: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
readonly: Boolean,
|
|
autofocus: Boolean,
|
|
id: {
|
|
type: String,
|
|
default: void 0
|
|
},
|
|
tabindex: {
|
|
type: [String, Number],
|
|
default: 0
|
|
},
|
|
maxlength: {
|
|
type: [String, Number]
|
|
},
|
|
minlength: {
|
|
type: [String, Number]
|
|
},
|
|
placeholder: String,
|
|
autocomplete: {
|
|
type: String,
|
|
default: "off"
|
|
},
|
|
saveOnBlur: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
ariaLabel: String
|
|
});
|
|
var inputTagEmits = {
|
|
[UPDATE_MODEL_EVENT]: (value) => isArray(value) || isUndefined2(value),
|
|
[CHANGE_EVENT]: (value) => isArray(value) || isUndefined2(value),
|
|
[INPUT_EVENT]: (value) => isString(value),
|
|
"add-tag": (value) => isString(value),
|
|
"remove-tag": (value) => isString(value),
|
|
focus: (evt) => evt instanceof FocusEvent,
|
|
blur: (evt) => evt instanceof FocusEvent,
|
|
clear: () => true
|
|
};
|
|
|
|
// node_modules/element-plus/es/hooks/use-calc-input-width/index.mjs
|
|
function useCalcInputWidth() {
|
|
const calculatorRef = shallowRef();
|
|
const calculatorWidth = ref(0);
|
|
const MINIMUM_INPUT_WIDTH = 11;
|
|
const inputStyle = computed(() => ({
|
|
minWidth: `${Math.max(calculatorWidth.value, MINIMUM_INPUT_WIDTH)}px`
|
|
}));
|
|
const resetCalculatorWidth = () => {
|
|
var _a2, _b;
|
|
calculatorWidth.value = (_b = (_a2 = calculatorRef.value) == null ? void 0 : _a2.getBoundingClientRect().width) != null ? _b : 0;
|
|
};
|
|
useResizeObserver(calculatorRef, resetCalculatorWidth);
|
|
return {
|
|
calculatorRef,
|
|
calculatorWidth,
|
|
inputStyle
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/input-tag/src/composables/use-input-tag.mjs
|
|
function useInputTag({ props: props2, emit, formItem }) {
|
|
const disabled = useFormDisabled();
|
|
const size3 = useFormSize();
|
|
const inputRef = shallowRef();
|
|
const inputValue = ref();
|
|
const tagSize = computed(() => {
|
|
return ["small"].includes(size3.value) ? "small" : "default";
|
|
});
|
|
const placeholder = computed(() => {
|
|
var _a2;
|
|
return ((_a2 = props2.modelValue) == null ? void 0 : _a2.length) ? void 0 : props2.placeholder;
|
|
});
|
|
const closable = computed(() => !(props2.readonly || disabled.value));
|
|
const inputLimit = computed(() => {
|
|
var _a2, _b;
|
|
return isUndefined2(props2.max) ? false : ((_b = (_a2 = props2.modelValue) == null ? void 0 : _a2.length) != null ? _b : 0) >= props2.max;
|
|
});
|
|
const handleInput = (event) => {
|
|
var _a2, _b;
|
|
if (inputLimit.value) {
|
|
inputValue.value = void 0;
|
|
return;
|
|
}
|
|
if (isComposing.value)
|
|
return;
|
|
if (props2.delimiter) {
|
|
const replacement = (_a2 = inputValue.value) == null ? void 0 : _a2.replace(props2.delimiter, "");
|
|
if ((replacement == null ? void 0 : replacement.length) !== ((_b = inputValue.value) == null ? void 0 : _b.length)) {
|
|
inputValue.value = replacement;
|
|
handleAddTag();
|
|
}
|
|
}
|
|
emit(INPUT_EVENT, event.target.value);
|
|
};
|
|
const handleKeydown = (event) => {
|
|
var _a2;
|
|
if (isComposing.value)
|
|
return;
|
|
switch (event.code) {
|
|
case props2.trigger:
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
handleAddTag();
|
|
break;
|
|
case EVENT_CODE.numpadEnter:
|
|
if (props2.trigger === EVENT_CODE.enter) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
handleAddTag();
|
|
}
|
|
break;
|
|
case EVENT_CODE.backspace:
|
|
if (!inputValue.value && ((_a2 = props2.modelValue) == null ? void 0 : _a2.length)) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
handleRemoveTag(props2.modelValue.length - 1);
|
|
}
|
|
break;
|
|
}
|
|
};
|
|
const handleAddTag = () => {
|
|
var _a2, _b;
|
|
const value = (_a2 = inputValue.value) == null ? void 0 : _a2.trim();
|
|
if (!value || inputLimit.value)
|
|
return;
|
|
const list = [...(_b = props2.modelValue) != null ? _b : [], value];
|
|
emit(UPDATE_MODEL_EVENT, list);
|
|
emit(CHANGE_EVENT, list);
|
|
emit("add-tag", value);
|
|
inputValue.value = void 0;
|
|
};
|
|
const handleRemoveTag = (index) => {
|
|
var _a2;
|
|
const value = ((_a2 = props2.modelValue) != null ? _a2 : []).slice();
|
|
const [item] = value.splice(index, 1);
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emit(CHANGE_EVENT, value);
|
|
emit("remove-tag", item);
|
|
};
|
|
const handleClear = () => {
|
|
inputValue.value = void 0;
|
|
emit(UPDATE_MODEL_EVENT, void 0);
|
|
emit(CHANGE_EVENT, void 0);
|
|
emit("clear");
|
|
};
|
|
const handleDragged = (draggingIndex, dropIndex, type4) => {
|
|
var _a2;
|
|
const value = ((_a2 = props2.modelValue) != null ? _a2 : []).slice();
|
|
const [draggedItem] = value.splice(draggingIndex, 1);
|
|
const step = dropIndex > draggingIndex && type4 === "before" ? -1 : dropIndex < draggingIndex && type4 === "after" ? 1 : 0;
|
|
value.splice(dropIndex + step, 0, draggedItem);
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emit(CHANGE_EVENT, value);
|
|
};
|
|
const focus = () => {
|
|
var _a2;
|
|
(_a2 = inputRef.value) == null ? void 0 : _a2.focus();
|
|
};
|
|
const blur = () => {
|
|
var _a2;
|
|
(_a2 = inputRef.value) == null ? void 0 : _a2.blur();
|
|
};
|
|
const { wrapperRef, isFocused } = useFocusController(inputRef, {
|
|
beforeFocus() {
|
|
return disabled.value;
|
|
},
|
|
afterBlur() {
|
|
var _a2;
|
|
if (props2.saveOnBlur) {
|
|
handleAddTag();
|
|
} else {
|
|
inputValue.value = void 0;
|
|
}
|
|
if (props2.validateEvent) {
|
|
(_a2 = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a2.call(formItem, "blur").catch((err) => debugWarn(err));
|
|
}
|
|
}
|
|
});
|
|
const {
|
|
isComposing,
|
|
handleCompositionStart,
|
|
handleCompositionUpdate,
|
|
handleCompositionEnd
|
|
} = useComposition({ afterComposition: handleInput });
|
|
watch(() => props2.modelValue, () => {
|
|
var _a2;
|
|
if (props2.validateEvent) {
|
|
(_a2 = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a2.call(formItem, CHANGE_EVENT).catch((err) => debugWarn(err));
|
|
}
|
|
});
|
|
return {
|
|
inputRef,
|
|
wrapperRef,
|
|
isFocused,
|
|
isComposing,
|
|
inputValue,
|
|
size: size3,
|
|
tagSize,
|
|
placeholder,
|
|
closable,
|
|
disabled,
|
|
inputLimit,
|
|
handleDragged,
|
|
handleInput,
|
|
handleKeydown,
|
|
handleAddTag,
|
|
handleRemoveTag,
|
|
handleClear,
|
|
handleCompositionStart,
|
|
handleCompositionUpdate,
|
|
handleCompositionEnd,
|
|
focus,
|
|
blur
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/input-tag/src/composables/use-hovering.mjs
|
|
function useHovering() {
|
|
const hovering = ref(false);
|
|
const handleMouseEnter = () => {
|
|
hovering.value = true;
|
|
};
|
|
const handleMouseLeave = () => {
|
|
hovering.value = false;
|
|
};
|
|
return {
|
|
hovering,
|
|
handleMouseEnter,
|
|
handleMouseLeave
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/input-tag/src/composables/use-drag-tag.mjs
|
|
function useDragTag({
|
|
wrapperRef,
|
|
handleDragged,
|
|
afterDragged
|
|
}) {
|
|
const ns = useNamespace("input-tag");
|
|
const dropIndicatorRef = shallowRef();
|
|
const showDropIndicator = ref(false);
|
|
let draggingIndex;
|
|
let draggingTag;
|
|
let dropIndex;
|
|
let dropType;
|
|
function getTagClassName(index) {
|
|
return `.${ns.e("inner")} .${ns.namespace.value}-tag:nth-child(${index + 1})`;
|
|
}
|
|
function handleDragStart(event, index) {
|
|
draggingIndex = index;
|
|
draggingTag = wrapperRef.value.querySelector(getTagClassName(index));
|
|
if (draggingTag) {
|
|
draggingTag.style.opacity = "0.5";
|
|
}
|
|
event.dataTransfer.effectAllowed = "move";
|
|
}
|
|
function handleDragOver(event, index) {
|
|
dropIndex = index;
|
|
event.preventDefault();
|
|
event.dataTransfer.dropEffect = "move";
|
|
if (isUndefined2(draggingIndex) || draggingIndex === index) {
|
|
showDropIndicator.value = false;
|
|
return;
|
|
}
|
|
const dropPosition = wrapperRef.value.querySelector(getTagClassName(index)).getBoundingClientRect();
|
|
const dropPrev = !(draggingIndex + 1 === index);
|
|
const dropNext = !(draggingIndex - 1 === index);
|
|
const distance = event.clientX - dropPosition.left;
|
|
const prevPercent = dropPrev ? dropNext ? 0.5 : 1 : -1;
|
|
const nextPercent = dropNext ? dropPrev ? 0.5 : 0 : 1;
|
|
if (distance <= dropPosition.width * prevPercent) {
|
|
dropType = "before";
|
|
} else if (distance > dropPosition.width * nextPercent) {
|
|
dropType = "after";
|
|
} else {
|
|
dropType = void 0;
|
|
}
|
|
const innerEl = wrapperRef.value.querySelector(`.${ns.e("inner")}`);
|
|
const innerPosition = innerEl.getBoundingClientRect();
|
|
const gap = Number.parseFloat(getStyle(innerEl, "gap")) / 2;
|
|
const indicatorTop = dropPosition.top - innerPosition.top;
|
|
let indicatorLeft = -9999;
|
|
if (dropType === "before") {
|
|
indicatorLeft = Math.max(dropPosition.left - innerPosition.left - gap, Math.floor(-gap / 2));
|
|
} else if (dropType === "after") {
|
|
const left = dropPosition.right - innerPosition.left;
|
|
indicatorLeft = left + (innerPosition.width === left ? Math.floor(gap / 2) : gap);
|
|
}
|
|
setStyle(dropIndicatorRef.value, {
|
|
top: `${indicatorTop}px`,
|
|
left: `${indicatorLeft}px`
|
|
});
|
|
showDropIndicator.value = !!dropType;
|
|
}
|
|
function handleDragEnd(event) {
|
|
event.preventDefault();
|
|
if (draggingTag) {
|
|
draggingTag.style.opacity = "";
|
|
}
|
|
if (dropType && !isUndefined2(draggingIndex) && !isUndefined2(dropIndex) && draggingIndex !== dropIndex) {
|
|
handleDragged(draggingIndex, dropIndex, dropType);
|
|
}
|
|
showDropIndicator.value = false;
|
|
draggingIndex = void 0;
|
|
draggingTag = null;
|
|
dropIndex = void 0;
|
|
dropType = void 0;
|
|
afterDragged == null ? void 0 : afterDragged();
|
|
}
|
|
return {
|
|
dropIndicatorRef,
|
|
showDropIndicator,
|
|
handleDragStart,
|
|
handleDragOver,
|
|
handleDragEnd
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/input-tag/src/composables/use-input-tag-dom.mjs
|
|
function useInputTagDom({
|
|
props: props2,
|
|
isFocused,
|
|
hovering,
|
|
disabled,
|
|
inputValue,
|
|
size: size3,
|
|
validateState,
|
|
validateIcon,
|
|
needStatusIcon
|
|
}) {
|
|
const attrs = useAttrs();
|
|
const slots = useSlots();
|
|
const ns = useNamespace("input-tag");
|
|
const nsInput = useNamespace("input");
|
|
const containerKls = computed(() => [
|
|
ns.b(),
|
|
ns.is("focused", isFocused.value),
|
|
ns.is("hovering", hovering.value),
|
|
ns.is("disabled", disabled.value),
|
|
ns.m(size3.value),
|
|
ns.e("wrapper"),
|
|
attrs.class
|
|
]);
|
|
const containerStyle = computed(() => [attrs.style]);
|
|
const innerKls = computed(() => {
|
|
var _a2, _b;
|
|
return [
|
|
ns.e("inner"),
|
|
ns.is("draggable", props2.draggable),
|
|
ns.is("left-space", !((_a2 = props2.modelValue) == null ? void 0 : _a2.length) && !slots.prefix),
|
|
ns.is("right-space", !((_b = props2.modelValue) == null ? void 0 : _b.length) && !showSuffix.value)
|
|
];
|
|
});
|
|
const showClear = computed(() => {
|
|
var _a2;
|
|
return props2.clearable && !disabled.value && !props2.readonly && (((_a2 = props2.modelValue) == null ? void 0 : _a2.length) || inputValue.value) && (isFocused.value || hovering.value);
|
|
});
|
|
const showSuffix = computed(() => {
|
|
return slots.suffix || showClear.value || validateState.value && validateIcon.value && needStatusIcon.value;
|
|
});
|
|
return {
|
|
ns,
|
|
nsInput,
|
|
containerKls,
|
|
containerStyle,
|
|
innerKls,
|
|
showClear,
|
|
showSuffix
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/input-tag/src/input-tag2.mjs
|
|
var __default__63 = defineComponent({
|
|
name: "ElInputTag",
|
|
inheritAttrs: false
|
|
});
|
|
var _sfc_main90 = defineComponent({
|
|
...__default__63,
|
|
props: inputTagProps,
|
|
emits: inputTagEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const attrs = useAttrs2();
|
|
const slots = useSlots();
|
|
const { form, formItem } = useFormItem();
|
|
const { inputId } = useFormItemInputId(props2, { formItemContext: formItem });
|
|
const needStatusIcon = computed(() => {
|
|
var _a2;
|
|
return (_a2 = form == null ? void 0 : form.statusIcon) != null ? _a2 : false;
|
|
});
|
|
const validateState = computed(() => (formItem == null ? void 0 : formItem.validateState) || "");
|
|
const validateIcon = computed(() => {
|
|
return validateState.value && ValidateComponentsMap[validateState.value];
|
|
});
|
|
const {
|
|
inputRef,
|
|
wrapperRef,
|
|
isFocused,
|
|
inputValue,
|
|
size: size3,
|
|
tagSize,
|
|
placeholder,
|
|
closable,
|
|
disabled,
|
|
handleDragged,
|
|
handleInput,
|
|
handleKeydown,
|
|
handleRemoveTag,
|
|
handleClear,
|
|
handleCompositionStart,
|
|
handleCompositionUpdate,
|
|
handleCompositionEnd,
|
|
focus,
|
|
blur
|
|
} = useInputTag({ props: props2, emit, formItem });
|
|
const { hovering, handleMouseEnter, handleMouseLeave } = useHovering();
|
|
const { calculatorRef, inputStyle } = useCalcInputWidth();
|
|
const {
|
|
dropIndicatorRef,
|
|
showDropIndicator,
|
|
handleDragStart,
|
|
handleDragOver,
|
|
handleDragEnd
|
|
} = useDragTag({ wrapperRef, handleDragged, afterDragged: focus });
|
|
const {
|
|
ns,
|
|
nsInput,
|
|
containerKls,
|
|
containerStyle,
|
|
innerKls,
|
|
showClear,
|
|
showSuffix
|
|
} = useInputTagDom({
|
|
props: props2,
|
|
hovering,
|
|
isFocused,
|
|
inputValue,
|
|
disabled,
|
|
size: size3,
|
|
validateState,
|
|
validateIcon,
|
|
needStatusIcon
|
|
});
|
|
expose({
|
|
focus,
|
|
blur
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "wrapperRef",
|
|
ref: wrapperRef,
|
|
class: normalizeClass(unref(containerKls)),
|
|
style: normalizeStyle(unref(containerStyle)),
|
|
onMouseenter: unref(handleMouseEnter),
|
|
onMouseleave: unref(handleMouseLeave)
|
|
}, [
|
|
unref(slots).prefix ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("prefix"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "prefix")
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(innerKls))
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.modelValue, (item, index) => {
|
|
return openBlock(), createBlock(unref(ElTag), {
|
|
key: index,
|
|
size: unref(tagSize),
|
|
closable: unref(closable),
|
|
type: _ctx.tagType,
|
|
effect: _ctx.tagEffect,
|
|
draggable: unref(closable) && _ctx.draggable,
|
|
"disable-transitions": "",
|
|
onClose: ($event) => unref(handleRemoveTag)(index),
|
|
onDragstart: (event) => unref(handleDragStart)(event, index),
|
|
onDragover: (event) => unref(handleDragOver)(event, index),
|
|
onDragend: unref(handleDragEnd),
|
|
onDrop: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "tag", {
|
|
value: item,
|
|
index
|
|
}, () => [
|
|
createTextVNode(toDisplayString(item), 1)
|
|
])
|
|
]),
|
|
_: 2
|
|
}, 1032, ["size", "closable", "type", "effect", "draggable", "onClose", "onDragstart", "onDragover", "onDragend", "onDrop"]);
|
|
}), 128)),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("input-wrapper"))
|
|
}, [
|
|
withDirectives(createBaseVNode("input", mergeProps({
|
|
id: unref(inputId),
|
|
ref_key: "inputRef",
|
|
ref: inputRef,
|
|
"onUpdate:modelValue": ($event) => isRef(inputValue) ? inputValue.value = $event : null
|
|
}, unref(attrs), {
|
|
type: "text",
|
|
minlength: _ctx.minlength,
|
|
maxlength: _ctx.maxlength,
|
|
disabled: unref(disabled),
|
|
readonly: _ctx.readonly,
|
|
autocomplete: _ctx.autocomplete,
|
|
tabindex: _ctx.tabindex,
|
|
placeholder: unref(placeholder),
|
|
autofocus: _ctx.autofocus,
|
|
ariaLabel: _ctx.ariaLabel,
|
|
class: unref(ns).e("input"),
|
|
style: unref(inputStyle),
|
|
onCompositionstart: unref(handleCompositionStart),
|
|
onCompositionupdate: unref(handleCompositionUpdate),
|
|
onCompositionend: unref(handleCompositionEnd),
|
|
onInput: unref(handleInput),
|
|
onKeydown: unref(handleKeydown)
|
|
}), null, 16, ["id", "onUpdate:modelValue", "minlength", "maxlength", "disabled", "readonly", "autocomplete", "tabindex", "placeholder", "autofocus", "ariaLabel", "onCompositionstart", "onCompositionupdate", "onCompositionend", "onInput", "onKeydown"]), [
|
|
[vModelText, unref(inputValue)]
|
|
]),
|
|
createBaseVNode("span", {
|
|
ref_key: "calculatorRef",
|
|
ref: calculatorRef,
|
|
"aria-hidden": "true",
|
|
class: normalizeClass(unref(ns).e("input-calculator")),
|
|
textContent: toDisplayString(unref(inputValue))
|
|
}, null, 10, ["textContent"])
|
|
], 2),
|
|
withDirectives(createBaseVNode("div", {
|
|
ref_key: "dropIndicatorRef",
|
|
ref: dropIndicatorRef,
|
|
class: normalizeClass(unref(ns).e("drop-indicator"))
|
|
}, null, 2), [
|
|
[vShow, unref(showDropIndicator)]
|
|
])
|
|
], 2),
|
|
unref(showSuffix) ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("suffix"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "suffix"),
|
|
unref(showClear) ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("icon"), unref(ns).e("clear")]),
|
|
onMousedown: withModifiers(unref(NOOP), ["prevent"]),
|
|
onClick: unref(handleClear)
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(circle_close_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "onMousedown", "onClick"])) : createCommentVNode("v-if", true),
|
|
unref(validateState) && unref(validateIcon) && unref(needStatusIcon) ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 1,
|
|
class: normalizeClass([
|
|
unref(nsInput).e("icon"),
|
|
unref(nsInput).e("validateIcon"),
|
|
unref(nsInput).is("loading", unref(validateState) === "validating")
|
|
])
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(unref(validateIcon))))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true)
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 46, ["onMouseenter", "onMouseleave"]);
|
|
};
|
|
}
|
|
});
|
|
var InputTag = _export_sfc(_sfc_main90, [["__file", "input-tag.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/input-tag/index.mjs
|
|
var ElInputTag = withInstall(InputTag);
|
|
|
|
// node_modules/element-plus/es/components/link/src/link.mjs
|
|
var linkProps = buildProps({
|
|
type: {
|
|
type: String,
|
|
values: ["primary", "success", "warning", "info", "danger", "default"],
|
|
default: void 0
|
|
},
|
|
underline: {
|
|
type: [Boolean, String],
|
|
values: [true, false, "always", "never", "hover"],
|
|
default: void 0
|
|
},
|
|
disabled: Boolean,
|
|
href: { type: String, default: "" },
|
|
target: {
|
|
type: String,
|
|
default: "_self"
|
|
},
|
|
icon: {
|
|
type: iconPropType
|
|
}
|
|
});
|
|
var linkEmits = {
|
|
click: (evt) => evt instanceof MouseEvent
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/link/src/link2.mjs
|
|
var __default__64 = defineComponent({
|
|
name: "ElLink"
|
|
});
|
|
var _sfc_main91 = defineComponent({
|
|
...__default__64,
|
|
props: linkProps,
|
|
emits: linkEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const globalConfig2 = useGlobalConfig("link");
|
|
useDeprecated({
|
|
scope: "el-link",
|
|
from: "The underline option (boolean)",
|
|
replacement: "'always' | 'hover' | 'never'",
|
|
version: "3.0.0",
|
|
ref: "https://element-plus.org/en-US/component/link.html#underline"
|
|
}, computed(() => isBoolean2(props2.underline)));
|
|
const ns = useNamespace("link");
|
|
const linkKls = computed(() => {
|
|
var _a2, _b, _c;
|
|
return [
|
|
ns.b(),
|
|
ns.m((_c = (_b = props2.type) != null ? _b : (_a2 = globalConfig2.value) == null ? void 0 : _a2.type) != null ? _c : "default"),
|
|
ns.is("disabled", props2.disabled),
|
|
ns.is("underline", underline.value === "always"),
|
|
ns.is("hover-underline", underline.value === "hover" && !props2.disabled)
|
|
];
|
|
});
|
|
const underline = computed(() => {
|
|
var _a2, _b, _c;
|
|
if (isBoolean2(props2.underline)) {
|
|
return props2.underline ? "hover" : "never";
|
|
} else
|
|
return (_c = (_b = props2.underline) != null ? _b : (_a2 = globalConfig2.value) == null ? void 0 : _a2.underline) != null ? _c : "hover";
|
|
});
|
|
function handleClick(event) {
|
|
if (!props2.disabled)
|
|
emit("click", event);
|
|
}
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("a", {
|
|
class: normalizeClass(unref(linkKls)),
|
|
href: _ctx.disabled || !_ctx.href ? void 0 : _ctx.href,
|
|
target: _ctx.disabled || !_ctx.href ? void 0 : _ctx.target,
|
|
onClick: handleClick
|
|
}, [
|
|
_ctx.icon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
|
|
]),
|
|
_: 1
|
|
})) : createCommentVNode("v-if", true),
|
|
_ctx.$slots.default ? (openBlock(), createElementBlock("span", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("inner"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
_ctx.$slots.icon ? renderSlot(_ctx.$slots, "icon", { key: 2 }) : createCommentVNode("v-if", true)
|
|
], 10, ["href", "target"]);
|
|
};
|
|
}
|
|
});
|
|
var Link = _export_sfc(_sfc_main91, [["__file", "link.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/link/index.mjs
|
|
var ElLink = withInstall(Link);
|
|
|
|
// node_modules/element-plus/es/components/menu/src/use-menu.mjs
|
|
function useMenu(instance, currentIndex) {
|
|
const indexPath = computed(() => {
|
|
let parent2 = instance.parent;
|
|
const path = [currentIndex.value];
|
|
while (parent2.type.name !== "ElMenu") {
|
|
if (parent2.props.index) {
|
|
path.unshift(parent2.props.index);
|
|
}
|
|
parent2 = parent2.parent;
|
|
}
|
|
return path;
|
|
});
|
|
const parentMenu = computed(() => {
|
|
let parent2 = instance.parent;
|
|
while (parent2 && !["ElMenu", "ElSubMenu"].includes(parent2.type.name)) {
|
|
parent2 = parent2.parent;
|
|
}
|
|
return parent2;
|
|
});
|
|
return {
|
|
parentMenu,
|
|
indexPath
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/menu/src/use-menu-color.mjs
|
|
function useMenuColor(props2) {
|
|
const menuBarColor = computed(() => {
|
|
const color = props2.backgroundColor;
|
|
return color ? new TinyColor(color).shade(20).toString() : "";
|
|
});
|
|
return menuBarColor;
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/menu/src/use-menu-css-var.mjs
|
|
var useMenuCssVar = (props2, level) => {
|
|
const ns = useNamespace("menu");
|
|
return computed(() => ns.cssVarBlock({
|
|
"text-color": props2.textColor || "",
|
|
"hover-text-color": props2.textColor || "",
|
|
"bg-color": props2.backgroundColor || "",
|
|
"hover-bg-color": useMenuColor(props2).value || "",
|
|
"active-color": props2.activeTextColor || "",
|
|
level: `${level}`
|
|
}));
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/menu/src/sub-menu.mjs
|
|
var subMenuProps = buildProps({
|
|
index: {
|
|
type: String,
|
|
required: true
|
|
},
|
|
showTimeout: Number,
|
|
hideTimeout: Number,
|
|
popperClass: String,
|
|
disabled: Boolean,
|
|
teleported: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
popperOffset: Number,
|
|
expandCloseIcon: {
|
|
type: iconPropType
|
|
},
|
|
expandOpenIcon: {
|
|
type: iconPropType
|
|
},
|
|
collapseCloseIcon: {
|
|
type: iconPropType
|
|
},
|
|
collapseOpenIcon: {
|
|
type: iconPropType
|
|
}
|
|
});
|
|
var COMPONENT_NAME14 = "ElSubMenu";
|
|
var SubMenu = defineComponent({
|
|
name: COMPONENT_NAME14,
|
|
props: subMenuProps,
|
|
setup(props2, { slots, expose }) {
|
|
const instance = getCurrentInstance();
|
|
const { indexPath, parentMenu } = useMenu(instance, computed(() => props2.index));
|
|
const nsMenu = useNamespace("menu");
|
|
const nsSubMenu = useNamespace("sub-menu");
|
|
const rootMenu = inject("rootMenu");
|
|
if (!rootMenu)
|
|
throwError(COMPONENT_NAME14, "can not inject root menu");
|
|
const subMenu = inject(`subMenu:${parentMenu.value.uid}`);
|
|
if (!subMenu)
|
|
throwError(COMPONENT_NAME14, "can not inject sub menu");
|
|
const items = ref({});
|
|
const subMenus = ref({});
|
|
let timeout;
|
|
const mouseInChild = ref(false);
|
|
const verticalTitleRef = ref();
|
|
const vPopper = ref();
|
|
const currentPlacement = computed(() => mode.value === "horizontal" && isFirstLevel.value ? "bottom-start" : "right-start");
|
|
const subMenuTitleIcon = computed(() => {
|
|
return mode.value === "horizontal" && isFirstLevel.value || mode.value === "vertical" && !rootMenu.props.collapse ? props2.expandCloseIcon && props2.expandOpenIcon ? opened.value ? props2.expandOpenIcon : props2.expandCloseIcon : arrow_down_default : props2.collapseCloseIcon && props2.collapseOpenIcon ? opened.value ? props2.collapseOpenIcon : props2.collapseCloseIcon : arrow_right_default;
|
|
});
|
|
const isFirstLevel = computed(() => subMenu.level === 0);
|
|
const appendToBody = computed(() => {
|
|
const value = props2.teleported;
|
|
return isUndefined2(value) ? isFirstLevel.value : value;
|
|
});
|
|
const menuTransitionName = computed(() => rootMenu.props.collapse ? `${nsMenu.namespace.value}-zoom-in-left` : `${nsMenu.namespace.value}-zoom-in-top`);
|
|
const fallbackPlacements = computed(() => mode.value === "horizontal" && isFirstLevel.value ? [
|
|
"bottom-start",
|
|
"bottom-end",
|
|
"top-start",
|
|
"top-end",
|
|
"right-start",
|
|
"left-start"
|
|
] : [
|
|
"right-start",
|
|
"right",
|
|
"right-end",
|
|
"left-start",
|
|
"bottom-start",
|
|
"bottom-end",
|
|
"top-start",
|
|
"top-end"
|
|
]);
|
|
const opened = computed(() => rootMenu.openedMenus.includes(props2.index));
|
|
const active = computed(() => [...Object.values(items.value), ...Object.values(subMenus.value)].some(({ active: active2 }) => active2));
|
|
const mode = computed(() => rootMenu.props.mode);
|
|
const persistent = computed(() => rootMenu.props.persistent);
|
|
const item = reactive({
|
|
index: props2.index,
|
|
indexPath,
|
|
active
|
|
});
|
|
const ulStyle = useMenuCssVar(rootMenu.props, subMenu.level + 1);
|
|
const subMenuPopperOffset = computed(() => {
|
|
var _a2;
|
|
return (_a2 = props2.popperOffset) != null ? _a2 : rootMenu.props.popperOffset;
|
|
});
|
|
const subMenuPopperClass = computed(() => {
|
|
var _a2;
|
|
return (_a2 = props2.popperClass) != null ? _a2 : rootMenu.props.popperClass;
|
|
});
|
|
const subMenuShowTimeout = computed(() => {
|
|
var _a2;
|
|
return (_a2 = props2.showTimeout) != null ? _a2 : rootMenu.props.showTimeout;
|
|
});
|
|
const subMenuHideTimeout = computed(() => {
|
|
var _a2;
|
|
return (_a2 = props2.hideTimeout) != null ? _a2 : rootMenu.props.hideTimeout;
|
|
});
|
|
const doDestroy = () => {
|
|
var _a2, _b, _c;
|
|
return (_c = (_b = (_a2 = vPopper.value) == null ? void 0 : _a2.popperRef) == null ? void 0 : _b.popperInstanceRef) == null ? void 0 : _c.destroy();
|
|
};
|
|
const handleCollapseToggle = (value) => {
|
|
if (!value) {
|
|
doDestroy();
|
|
}
|
|
};
|
|
const handleClick = () => {
|
|
if (rootMenu.props.menuTrigger === "hover" && rootMenu.props.mode === "horizontal" || rootMenu.props.collapse && rootMenu.props.mode === "vertical" || props2.disabled)
|
|
return;
|
|
rootMenu.handleSubMenuClick({
|
|
index: props2.index,
|
|
indexPath: indexPath.value,
|
|
active: active.value
|
|
});
|
|
};
|
|
const handleMouseenter = (event, showTimeout = subMenuShowTimeout.value) => {
|
|
var _a2;
|
|
if (event.type === "focus")
|
|
return;
|
|
if (rootMenu.props.menuTrigger === "click" && rootMenu.props.mode === "horizontal" || !rootMenu.props.collapse && rootMenu.props.mode === "vertical" || props2.disabled) {
|
|
subMenu.mouseInChild.value = true;
|
|
return;
|
|
}
|
|
subMenu.mouseInChild.value = true;
|
|
timeout == null ? void 0 : timeout();
|
|
({ stop: timeout } = useTimeoutFn(() => {
|
|
rootMenu.openMenu(props2.index, indexPath.value);
|
|
}, showTimeout));
|
|
if (appendToBody.value) {
|
|
(_a2 = parentMenu.value.vnode.el) == null ? void 0 : _a2.dispatchEvent(new MouseEvent("mouseenter"));
|
|
}
|
|
};
|
|
const handleMouseleave = (deepDispatch = false) => {
|
|
var _a2;
|
|
if (rootMenu.props.menuTrigger === "click" && rootMenu.props.mode === "horizontal" || !rootMenu.props.collapse && rootMenu.props.mode === "vertical") {
|
|
subMenu.mouseInChild.value = false;
|
|
return;
|
|
}
|
|
timeout == null ? void 0 : timeout();
|
|
subMenu.mouseInChild.value = false;
|
|
({ stop: timeout } = useTimeoutFn(() => !mouseInChild.value && rootMenu.closeMenu(props2.index, indexPath.value), subMenuHideTimeout.value));
|
|
if (appendToBody.value && deepDispatch) {
|
|
(_a2 = subMenu.handleMouseleave) == null ? void 0 : _a2.call(subMenu, true);
|
|
}
|
|
};
|
|
watch(() => rootMenu.props.collapse, (value) => handleCollapseToggle(Boolean(value)));
|
|
{
|
|
const addSubMenu = (item2) => {
|
|
subMenus.value[item2.index] = item2;
|
|
};
|
|
const removeSubMenu = (item2) => {
|
|
delete subMenus.value[item2.index];
|
|
};
|
|
provide(`subMenu:${instance.uid}`, {
|
|
addSubMenu,
|
|
removeSubMenu,
|
|
handleMouseleave,
|
|
mouseInChild,
|
|
level: subMenu.level + 1
|
|
});
|
|
}
|
|
expose({
|
|
opened
|
|
});
|
|
onMounted(() => {
|
|
rootMenu.addSubMenu(item);
|
|
subMenu.addSubMenu(item);
|
|
});
|
|
onBeforeUnmount(() => {
|
|
subMenu.removeSubMenu(item);
|
|
rootMenu.removeSubMenu(item);
|
|
});
|
|
return () => {
|
|
var _a2;
|
|
const titleTag = [
|
|
(_a2 = slots.title) == null ? void 0 : _a2.call(slots),
|
|
h(ElIcon, {
|
|
class: nsSubMenu.e("icon-arrow"),
|
|
style: {
|
|
transform: opened.value ? props2.expandCloseIcon && props2.expandOpenIcon || props2.collapseCloseIcon && props2.collapseOpenIcon && rootMenu.props.collapse ? "none" : "rotateZ(180deg)" : "none"
|
|
}
|
|
}, {
|
|
default: () => isString(subMenuTitleIcon.value) ? h(instance.appContext.components[subMenuTitleIcon.value]) : h(subMenuTitleIcon.value)
|
|
})
|
|
];
|
|
const child = rootMenu.isMenuPopup ? h(ElTooltip, {
|
|
ref: vPopper,
|
|
visible: opened.value,
|
|
effect: "light",
|
|
pure: true,
|
|
offset: subMenuPopperOffset.value,
|
|
showArrow: false,
|
|
persistent: persistent.value,
|
|
popperClass: subMenuPopperClass.value,
|
|
placement: currentPlacement.value,
|
|
teleported: appendToBody.value,
|
|
fallbackPlacements: fallbackPlacements.value,
|
|
transition: menuTransitionName.value,
|
|
gpuAcceleration: false
|
|
}, {
|
|
content: () => {
|
|
var _a22;
|
|
return h("div", {
|
|
class: [
|
|
nsMenu.m(mode.value),
|
|
nsMenu.m("popup-container"),
|
|
subMenuPopperClass.value
|
|
],
|
|
onMouseenter: (evt) => handleMouseenter(evt, 100),
|
|
onMouseleave: () => handleMouseleave(true),
|
|
onFocus: (evt) => handleMouseenter(evt, 100)
|
|
}, [
|
|
h("ul", {
|
|
class: [
|
|
nsMenu.b(),
|
|
nsMenu.m("popup"),
|
|
nsMenu.m(`popup-${currentPlacement.value}`)
|
|
],
|
|
style: ulStyle.value
|
|
}, [(_a22 = slots.default) == null ? void 0 : _a22.call(slots)])
|
|
]);
|
|
},
|
|
default: () => h("div", {
|
|
class: nsSubMenu.e("title"),
|
|
onClick: handleClick
|
|
}, titleTag)
|
|
}) : h(Fragment, {}, [
|
|
h("div", {
|
|
class: nsSubMenu.e("title"),
|
|
ref: verticalTitleRef,
|
|
onClick: handleClick
|
|
}, titleTag),
|
|
h(ElCollapseTransition, {}, {
|
|
default: () => {
|
|
var _a22;
|
|
return withDirectives(h("ul", {
|
|
role: "menu",
|
|
class: [nsMenu.b(), nsMenu.m("inline")],
|
|
style: ulStyle.value
|
|
}, [(_a22 = slots.default) == null ? void 0 : _a22.call(slots)]), [[vShow, opened.value]]);
|
|
}
|
|
})
|
|
]);
|
|
return h("li", {
|
|
class: [
|
|
nsSubMenu.b(),
|
|
nsSubMenu.is("active", active.value),
|
|
nsSubMenu.is("opened", opened.value),
|
|
nsSubMenu.is("disabled", props2.disabled)
|
|
],
|
|
role: "menuitem",
|
|
ariaHaspopup: true,
|
|
ariaExpanded: opened.value,
|
|
onMouseenter: handleMouseenter,
|
|
onMouseleave: () => handleMouseleave(),
|
|
onFocus: handleMouseenter
|
|
}, [child]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/menu/src/utils/submenu.mjs
|
|
var SubMenu2 = class {
|
|
constructor(parent2, domNode) {
|
|
this.parent = parent2;
|
|
this.domNode = domNode;
|
|
this.subIndex = 0;
|
|
this.subIndex = 0;
|
|
this.init();
|
|
}
|
|
init() {
|
|
this.subMenuItems = this.domNode.querySelectorAll("li");
|
|
this.addListeners();
|
|
}
|
|
gotoSubIndex(idx) {
|
|
if (idx === this.subMenuItems.length) {
|
|
idx = 0;
|
|
} else if (idx < 0) {
|
|
idx = this.subMenuItems.length - 1;
|
|
}
|
|
this.subMenuItems[idx].focus();
|
|
this.subIndex = idx;
|
|
}
|
|
addListeners() {
|
|
const parentNode = this.parent.domNode;
|
|
Array.prototype.forEach.call(this.subMenuItems, (el) => {
|
|
el.addEventListener("keydown", (event) => {
|
|
let prevDef = false;
|
|
switch (event.code) {
|
|
case EVENT_CODE.down: {
|
|
this.gotoSubIndex(this.subIndex + 1);
|
|
prevDef = true;
|
|
break;
|
|
}
|
|
case EVENT_CODE.up: {
|
|
this.gotoSubIndex(this.subIndex - 1);
|
|
prevDef = true;
|
|
break;
|
|
}
|
|
case EVENT_CODE.tab: {
|
|
triggerEvent(parentNode, "mouseleave");
|
|
break;
|
|
}
|
|
case EVENT_CODE.enter:
|
|
case EVENT_CODE.numpadEnter:
|
|
case EVENT_CODE.space: {
|
|
prevDef = true;
|
|
event.currentTarget.click();
|
|
break;
|
|
}
|
|
}
|
|
if (prevDef) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
}
|
|
return false;
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/menu/src/utils/menu-item.mjs
|
|
var MenuItem = class {
|
|
constructor(domNode, namespace) {
|
|
this.domNode = domNode;
|
|
this.submenu = null;
|
|
this.submenu = null;
|
|
this.init(namespace);
|
|
}
|
|
init(namespace) {
|
|
this.domNode.setAttribute("tabindex", "0");
|
|
const menuChild = this.domNode.querySelector(`.${namespace}-menu`);
|
|
if (menuChild) {
|
|
this.submenu = new SubMenu2(this, menuChild);
|
|
}
|
|
this.addListeners();
|
|
}
|
|
addListeners() {
|
|
this.domNode.addEventListener("keydown", (event) => {
|
|
let prevDef = false;
|
|
switch (event.code) {
|
|
case EVENT_CODE.down: {
|
|
triggerEvent(event.currentTarget, "mouseenter");
|
|
this.submenu && this.submenu.gotoSubIndex(0);
|
|
prevDef = true;
|
|
break;
|
|
}
|
|
case EVENT_CODE.up: {
|
|
triggerEvent(event.currentTarget, "mouseenter");
|
|
this.submenu && this.submenu.gotoSubIndex(this.submenu.subMenuItems.length - 1);
|
|
prevDef = true;
|
|
break;
|
|
}
|
|
case EVENT_CODE.tab: {
|
|
triggerEvent(event.currentTarget, "mouseleave");
|
|
break;
|
|
}
|
|
case EVENT_CODE.enter:
|
|
case EVENT_CODE.numpadEnter:
|
|
case EVENT_CODE.space: {
|
|
prevDef = true;
|
|
event.currentTarget.click();
|
|
break;
|
|
}
|
|
}
|
|
if (prevDef) {
|
|
event.preventDefault();
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/menu/src/utils/menu-bar.mjs
|
|
var Menu = class {
|
|
constructor(domNode, namespace) {
|
|
this.domNode = domNode;
|
|
this.init(namespace);
|
|
}
|
|
init(namespace) {
|
|
const menuChildren = this.domNode.childNodes;
|
|
Array.from(menuChildren).forEach((child) => {
|
|
if (child.nodeType === 1) {
|
|
new MenuItem(child, namespace);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/menu/src/menu-collapse-transition.mjs
|
|
var __default__65 = defineComponent({
|
|
name: "ElMenuCollapseTransition"
|
|
});
|
|
var _sfc_main92 = defineComponent({
|
|
...__default__65,
|
|
setup(__props) {
|
|
const ns = useNamespace("menu");
|
|
const listeners = {
|
|
onBeforeEnter: (el) => el.style.opacity = "0.2",
|
|
onEnter(el, done) {
|
|
addClass(el, `${ns.namespace.value}-opacity-transition`);
|
|
el.style.opacity = "1";
|
|
done();
|
|
},
|
|
onAfterEnter(el) {
|
|
removeClass(el, `${ns.namespace.value}-opacity-transition`);
|
|
el.style.opacity = "";
|
|
},
|
|
onBeforeLeave(el) {
|
|
if (!el.dataset)
|
|
el.dataset = {};
|
|
if (hasClass(el, ns.m("collapse"))) {
|
|
removeClass(el, ns.m("collapse"));
|
|
el.dataset.oldOverflow = el.style.overflow;
|
|
el.dataset.scrollWidth = el.clientWidth.toString();
|
|
addClass(el, ns.m("collapse"));
|
|
} else {
|
|
addClass(el, ns.m("collapse"));
|
|
el.dataset.oldOverflow = el.style.overflow;
|
|
el.dataset.scrollWidth = el.clientWidth.toString();
|
|
removeClass(el, ns.m("collapse"));
|
|
}
|
|
el.style.width = `${el.scrollWidth}px`;
|
|
el.style.overflow = "hidden";
|
|
},
|
|
onLeave(el) {
|
|
addClass(el, "horizontal-collapse-transition");
|
|
el.style.width = `${el.dataset.scrollWidth}px`;
|
|
}
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(Transition, mergeProps({ mode: "out-in" }, unref(listeners)), {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 16);
|
|
};
|
|
}
|
|
});
|
|
var ElMenuCollapseTransition = _export_sfc(_sfc_main92, [["__file", "menu-collapse-transition.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/menu/src/menu.mjs
|
|
var menuProps = buildProps({
|
|
mode: {
|
|
type: String,
|
|
values: ["horizontal", "vertical"],
|
|
default: "vertical"
|
|
},
|
|
defaultActive: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
defaultOpeneds: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([])
|
|
},
|
|
uniqueOpened: Boolean,
|
|
router: Boolean,
|
|
menuTrigger: {
|
|
type: String,
|
|
values: ["hover", "click"],
|
|
default: "hover"
|
|
},
|
|
collapse: Boolean,
|
|
backgroundColor: String,
|
|
textColor: String,
|
|
activeTextColor: String,
|
|
closeOnClickOutside: Boolean,
|
|
collapseTransition: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
ellipsis: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
popperOffset: {
|
|
type: Number,
|
|
default: 6
|
|
},
|
|
ellipsisIcon: {
|
|
type: iconPropType,
|
|
default: () => more_default
|
|
},
|
|
popperEffect: {
|
|
type: definePropType(String),
|
|
default: "dark"
|
|
},
|
|
popperClass: String,
|
|
showTimeout: {
|
|
type: Number,
|
|
default: 300
|
|
},
|
|
hideTimeout: {
|
|
type: Number,
|
|
default: 300
|
|
},
|
|
persistent: {
|
|
type: Boolean,
|
|
default: true
|
|
}
|
|
});
|
|
var checkIndexPath = (indexPath) => isArray(indexPath) && indexPath.every((path) => isString(path));
|
|
var menuEmits = {
|
|
close: (index, indexPath) => isString(index) && checkIndexPath(indexPath),
|
|
open: (index, indexPath) => isString(index) && checkIndexPath(indexPath),
|
|
select: (index, indexPath, item, routerResult) => isString(index) && checkIndexPath(indexPath) && isObject(item) && (isUndefined2(routerResult) || routerResult instanceof Promise)
|
|
};
|
|
var Menu2 = defineComponent({
|
|
name: "ElMenu",
|
|
props: menuProps,
|
|
emits: menuEmits,
|
|
setup(props2, { emit, slots, expose }) {
|
|
const instance = getCurrentInstance();
|
|
const router = instance.appContext.config.globalProperties.$router;
|
|
const menu = ref();
|
|
const nsMenu = useNamespace("menu");
|
|
const nsSubMenu = useNamespace("sub-menu");
|
|
const sliceIndex = ref(-1);
|
|
const openedMenus = ref(props2.defaultOpeneds && !props2.collapse ? props2.defaultOpeneds.slice(0) : []);
|
|
const activeIndex = ref(props2.defaultActive);
|
|
const items = ref({});
|
|
const subMenus = ref({});
|
|
const isMenuPopup = computed(() => props2.mode === "horizontal" || props2.mode === "vertical" && props2.collapse);
|
|
const initMenu = () => {
|
|
const activeItem = activeIndex.value && items.value[activeIndex.value];
|
|
if (!activeItem || props2.mode === "horizontal" || props2.collapse)
|
|
return;
|
|
const indexPath = activeItem.indexPath;
|
|
indexPath.forEach((index) => {
|
|
const subMenu = subMenus.value[index];
|
|
subMenu && openMenu(index, subMenu.indexPath);
|
|
});
|
|
};
|
|
const openMenu = (index, indexPath) => {
|
|
if (openedMenus.value.includes(index))
|
|
return;
|
|
if (props2.uniqueOpened) {
|
|
openedMenus.value = openedMenus.value.filter((index2) => indexPath.includes(index2));
|
|
}
|
|
openedMenus.value.push(index);
|
|
emit("open", index, indexPath);
|
|
};
|
|
const close2 = (index) => {
|
|
const i = openedMenus.value.indexOf(index);
|
|
if (i !== -1) {
|
|
openedMenus.value.splice(i, 1);
|
|
}
|
|
};
|
|
const closeMenu = (index, indexPath) => {
|
|
close2(index);
|
|
emit("close", index, indexPath);
|
|
};
|
|
const handleSubMenuClick = ({
|
|
index,
|
|
indexPath
|
|
}) => {
|
|
const isOpened = openedMenus.value.includes(index);
|
|
isOpened ? closeMenu(index, indexPath) : openMenu(index, indexPath);
|
|
};
|
|
const handleMenuItemClick = (menuItem) => {
|
|
if (props2.mode === "horizontal" || props2.collapse) {
|
|
openedMenus.value = [];
|
|
}
|
|
const { index, indexPath } = menuItem;
|
|
if (isNil_default(index) || isNil_default(indexPath))
|
|
return;
|
|
if (props2.router && router) {
|
|
const route = menuItem.route || index;
|
|
const routerResult = router.push(route).then((res) => {
|
|
if (!res)
|
|
activeIndex.value = index;
|
|
return res;
|
|
});
|
|
emit("select", index, indexPath, { index, indexPath, route }, routerResult);
|
|
} else {
|
|
activeIndex.value = index;
|
|
emit("select", index, indexPath, { index, indexPath });
|
|
}
|
|
};
|
|
const updateActiveIndex = (val) => {
|
|
var _a2;
|
|
const itemsInData = items.value;
|
|
const item = itemsInData[val] || activeIndex.value && itemsInData[activeIndex.value] || itemsInData[props2.defaultActive];
|
|
activeIndex.value = (_a2 = item == null ? void 0 : item.index) != null ? _a2 : val;
|
|
};
|
|
const calcMenuItemWidth = (menuItem) => {
|
|
const computedStyle = getComputedStyle(menuItem);
|
|
const marginLeft = Number.parseInt(computedStyle.marginLeft, 10);
|
|
const marginRight = Number.parseInt(computedStyle.marginRight, 10);
|
|
return menuItem.offsetWidth + marginLeft + marginRight || 0;
|
|
};
|
|
const calcSliceIndex = () => {
|
|
var _a2, _b;
|
|
if (!menu.value)
|
|
return -1;
|
|
const items2 = Array.from((_b = (_a2 = menu.value) == null ? void 0 : _a2.childNodes) != null ? _b : []).filter((item) => item.nodeName !== "#text" || item.nodeValue);
|
|
const moreItemWidth = 64;
|
|
const computedMenuStyle = getComputedStyle(menu.value);
|
|
const paddingLeft = Number.parseInt(computedMenuStyle.paddingLeft, 10);
|
|
const paddingRight = Number.parseInt(computedMenuStyle.paddingRight, 10);
|
|
const menuWidth = menu.value.clientWidth - paddingLeft - paddingRight;
|
|
let calcWidth = 0;
|
|
let sliceIndex2 = 0;
|
|
items2.forEach((item, index) => {
|
|
if (item.nodeName === "#comment")
|
|
return;
|
|
calcWidth += calcMenuItemWidth(item);
|
|
if (calcWidth <= menuWidth - moreItemWidth) {
|
|
sliceIndex2 = index + 1;
|
|
}
|
|
});
|
|
return sliceIndex2 === items2.length ? -1 : sliceIndex2;
|
|
};
|
|
const getIndexPath = (index) => subMenus.value[index].indexPath;
|
|
const debounce2 = (fn2, wait = 33.34) => {
|
|
let timmer;
|
|
return () => {
|
|
timmer && clearTimeout(timmer);
|
|
timmer = setTimeout(() => {
|
|
fn2();
|
|
}, wait);
|
|
};
|
|
};
|
|
let isFirstTimeRender = true;
|
|
const handleResize = () => {
|
|
if (sliceIndex.value === calcSliceIndex())
|
|
return;
|
|
const callback = () => {
|
|
sliceIndex.value = -1;
|
|
nextTick(() => {
|
|
sliceIndex.value = calcSliceIndex();
|
|
});
|
|
};
|
|
isFirstTimeRender ? callback() : debounce2(callback)();
|
|
isFirstTimeRender = false;
|
|
};
|
|
watch(() => props2.defaultActive, (currentActive) => {
|
|
if (!items.value[currentActive]) {
|
|
activeIndex.value = "";
|
|
}
|
|
updateActiveIndex(currentActive);
|
|
});
|
|
watch(() => props2.collapse, (value) => {
|
|
if (value)
|
|
openedMenus.value = [];
|
|
});
|
|
watch(items.value, initMenu);
|
|
let resizeStopper;
|
|
watchEffect(() => {
|
|
if (props2.mode === "horizontal" && props2.ellipsis)
|
|
resizeStopper = useResizeObserver(menu, handleResize).stop;
|
|
else
|
|
resizeStopper == null ? void 0 : resizeStopper();
|
|
});
|
|
const mouseInChild = ref(false);
|
|
{
|
|
const addSubMenu = (item) => {
|
|
subMenus.value[item.index] = item;
|
|
};
|
|
const removeSubMenu = (item) => {
|
|
delete subMenus.value[item.index];
|
|
};
|
|
const addMenuItem = (item) => {
|
|
items.value[item.index] = item;
|
|
};
|
|
const removeMenuItem = (item) => {
|
|
delete items.value[item.index];
|
|
};
|
|
provide("rootMenu", reactive({
|
|
props: props2,
|
|
openedMenus,
|
|
items,
|
|
subMenus,
|
|
activeIndex,
|
|
isMenuPopup,
|
|
addMenuItem,
|
|
removeMenuItem,
|
|
addSubMenu,
|
|
removeSubMenu,
|
|
openMenu,
|
|
closeMenu,
|
|
handleMenuItemClick,
|
|
handleSubMenuClick
|
|
}));
|
|
provide(`subMenu:${instance.uid}`, {
|
|
addSubMenu,
|
|
removeSubMenu,
|
|
mouseInChild,
|
|
level: 0
|
|
});
|
|
}
|
|
onMounted(() => {
|
|
if (props2.mode === "horizontal") {
|
|
new Menu(instance.vnode.el, nsMenu.namespace.value);
|
|
}
|
|
});
|
|
{
|
|
const open = (index) => {
|
|
const { indexPath } = subMenus.value[index];
|
|
indexPath.forEach((i) => openMenu(i, indexPath));
|
|
};
|
|
expose({
|
|
open,
|
|
close: close2,
|
|
updateActiveIndex,
|
|
handleResize
|
|
});
|
|
}
|
|
const ulStyle = useMenuCssVar(props2, 0);
|
|
return () => {
|
|
var _a2, _b;
|
|
let slot = (_b = (_a2 = slots.default) == null ? void 0 : _a2.call(slots)) != null ? _b : [];
|
|
const vShowMore = [];
|
|
if (props2.mode === "horizontal" && menu.value) {
|
|
const originalSlot = flattedChildren(slot);
|
|
const slotDefault = sliceIndex.value === -1 ? originalSlot : originalSlot.slice(0, sliceIndex.value);
|
|
const slotMore = sliceIndex.value === -1 ? [] : originalSlot.slice(sliceIndex.value);
|
|
if ((slotMore == null ? void 0 : slotMore.length) && props2.ellipsis) {
|
|
slot = slotDefault;
|
|
vShowMore.push(h(SubMenu, {
|
|
index: "sub-menu-more",
|
|
class: nsSubMenu.e("hide-arrow"),
|
|
popperOffset: props2.popperOffset
|
|
}, {
|
|
title: () => h(ElIcon, {
|
|
class: nsSubMenu.e("icon-more")
|
|
}, {
|
|
default: () => h(props2.ellipsisIcon)
|
|
}),
|
|
default: () => slotMore
|
|
}));
|
|
}
|
|
}
|
|
const directives = props2.closeOnClickOutside ? [
|
|
[
|
|
ClickOutside,
|
|
() => {
|
|
if (!openedMenus.value.length)
|
|
return;
|
|
if (!mouseInChild.value) {
|
|
openedMenus.value.forEach((openedMenu) => emit("close", openedMenu, getIndexPath(openedMenu)));
|
|
openedMenus.value = [];
|
|
}
|
|
}
|
|
]
|
|
] : [];
|
|
const vMenu = withDirectives(h("ul", {
|
|
key: String(props2.collapse),
|
|
role: "menubar",
|
|
ref: menu,
|
|
style: ulStyle.value,
|
|
class: {
|
|
[nsMenu.b()]: true,
|
|
[nsMenu.m(props2.mode)]: true,
|
|
[nsMenu.m("collapse")]: props2.collapse
|
|
}
|
|
}, [...slot, ...vShowMore]), directives);
|
|
if (props2.collapseTransition && props2.mode === "vertical") {
|
|
return h(ElMenuCollapseTransition, () => vMenu);
|
|
}
|
|
return vMenu;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/menu/src/menu-item.mjs
|
|
var menuItemProps = buildProps({
|
|
index: {
|
|
type: definePropType([String, null]),
|
|
default: null
|
|
},
|
|
route: {
|
|
type: definePropType([String, Object])
|
|
},
|
|
disabled: Boolean
|
|
});
|
|
var menuItemEmits = {
|
|
click: (item) => isString(item.index) && isArray(item.indexPath)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/menu/src/menu-item-group.mjs
|
|
var menuItemGroupProps = {
|
|
title: String
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/menu/src/menu-item2.mjs
|
|
var COMPONENT_NAME15 = "ElMenuItem";
|
|
var __default__66 = defineComponent({
|
|
name: COMPONENT_NAME15
|
|
});
|
|
var _sfc_main93 = defineComponent({
|
|
...__default__66,
|
|
props: menuItemProps,
|
|
emits: menuItemEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const instance = getCurrentInstance();
|
|
const rootMenu = inject("rootMenu");
|
|
const nsMenu = useNamespace("menu");
|
|
const nsMenuItem = useNamespace("menu-item");
|
|
if (!rootMenu)
|
|
throwError(COMPONENT_NAME15, "can not inject root menu");
|
|
const { parentMenu, indexPath } = useMenu(instance, toRef(props2, "index"));
|
|
const subMenu = inject(`subMenu:${parentMenu.value.uid}`);
|
|
if (!subMenu)
|
|
throwError(COMPONENT_NAME15, "can not inject sub menu");
|
|
const active = computed(() => props2.index === rootMenu.activeIndex);
|
|
const item = reactive({
|
|
index: props2.index,
|
|
indexPath,
|
|
active
|
|
});
|
|
const handleClick = () => {
|
|
if (!props2.disabled) {
|
|
rootMenu.handleMenuItemClick({
|
|
index: props2.index,
|
|
indexPath: indexPath.value,
|
|
route: props2.route
|
|
});
|
|
emit("click", item);
|
|
}
|
|
};
|
|
onMounted(() => {
|
|
subMenu.addSubMenu(item);
|
|
rootMenu.addMenuItem(item);
|
|
});
|
|
onBeforeUnmount(() => {
|
|
subMenu.removeSubMenu(item);
|
|
rootMenu.removeMenuItem(item);
|
|
});
|
|
expose({
|
|
parentMenu,
|
|
rootMenu,
|
|
active,
|
|
nsMenu,
|
|
nsMenuItem,
|
|
handleClick
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("li", {
|
|
class: normalizeClass([
|
|
unref(nsMenuItem).b(),
|
|
unref(nsMenuItem).is("active", unref(active)),
|
|
unref(nsMenuItem).is("disabled", _ctx.disabled)
|
|
]),
|
|
role: "menuitem",
|
|
tabindex: "-1",
|
|
onClick: handleClick
|
|
}, [
|
|
unref(parentMenu).type.name === "ElMenu" && unref(rootMenu).props.collapse && _ctx.$slots.title ? (openBlock(), createBlock(unref(ElTooltip), {
|
|
key: 0,
|
|
effect: unref(rootMenu).props.popperEffect,
|
|
placement: "right",
|
|
"fallback-placements": ["left"],
|
|
persistent: unref(rootMenu).props.persistent
|
|
}, {
|
|
content: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "title")
|
|
]),
|
|
default: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(nsMenu).be("tooltip", "trigger"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2)
|
|
]),
|
|
_: 3
|
|
}, 8, ["effect", "persistent"])) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
|
|
renderSlot(_ctx.$slots, "default"),
|
|
renderSlot(_ctx.$slots, "title")
|
|
], 64))
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var MenuItem2 = _export_sfc(_sfc_main93, [["__file", "menu-item.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/menu/src/menu-item-group2.mjs
|
|
var __default__67 = defineComponent({
|
|
name: "ElMenuItemGroup"
|
|
});
|
|
var _sfc_main94 = defineComponent({
|
|
...__default__67,
|
|
props: menuItemGroupProps,
|
|
setup(__props) {
|
|
const ns = useNamespace("menu-item-group");
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("li", {
|
|
class: normalizeClass(unref(ns).b())
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("title"))
|
|
}, [
|
|
!_ctx.$slots.title ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
|
|
createTextVNode(toDisplayString(_ctx.title), 1)
|
|
], 64)) : renderSlot(_ctx.$slots, "title", { key: 1 })
|
|
], 2),
|
|
createBaseVNode("ul", null, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
])
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var MenuItemGroup = _export_sfc(_sfc_main94, [["__file", "menu-item-group.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/menu/index.mjs
|
|
var ElMenu = withInstall(Menu2, {
|
|
MenuItem: MenuItem2,
|
|
MenuItemGroup,
|
|
SubMenu
|
|
});
|
|
var ElMenuItem = withNoopInstall(MenuItem2);
|
|
var ElMenuItemGroup = withNoopInstall(MenuItemGroup);
|
|
var ElSubMenu = withNoopInstall(SubMenu);
|
|
|
|
// node_modules/element-plus/es/components/page-header/src/page-header.mjs
|
|
var pageHeaderProps = buildProps({
|
|
icon: {
|
|
type: iconPropType,
|
|
default: () => back_default
|
|
},
|
|
title: String,
|
|
content: {
|
|
type: String,
|
|
default: ""
|
|
}
|
|
});
|
|
var pageHeaderEmits = {
|
|
back: () => true
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/page-header/src/page-header2.mjs
|
|
var __default__68 = defineComponent({
|
|
name: "ElPageHeader"
|
|
});
|
|
var _sfc_main95 = defineComponent({
|
|
...__default__68,
|
|
props: pageHeaderProps,
|
|
emits: pageHeaderEmits,
|
|
setup(__props, { emit }) {
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("page-header");
|
|
function handleClick() {
|
|
emit("back");
|
|
}
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([
|
|
unref(ns).b(),
|
|
{
|
|
[unref(ns).m("has-breadcrumb")]: !!_ctx.$slots.breadcrumb,
|
|
[unref(ns).m("has-extra")]: !!_ctx.$slots.extra,
|
|
[unref(ns).is("contentful")]: !!_ctx.$slots.default
|
|
}
|
|
])
|
|
}, [
|
|
_ctx.$slots.breadcrumb ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("breadcrumb"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "breadcrumb")
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("header"))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("left"))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("back")),
|
|
role: "button",
|
|
tabindex: "0",
|
|
onClick: handleClick
|
|
}, [
|
|
_ctx.icon || _ctx.$slots.icon ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
"aria-label": _ctx.title || unref(t)("el.pageHeader.title"),
|
|
class: normalizeClass(unref(ns).e("icon"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "icon", {}, () => [
|
|
_ctx.icon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
|
|
]),
|
|
_: 1
|
|
})) : createCommentVNode("v-if", true)
|
|
])
|
|
], 10, ["aria-label"])) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("title"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "title", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.title || unref(t)("el.pageHeader.title")), 1)
|
|
])
|
|
], 2)
|
|
], 2),
|
|
createVNode(unref(ElDivider), { direction: "vertical" }),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("content"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "content", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.content), 1)
|
|
])
|
|
], 2)
|
|
], 2),
|
|
_ctx.$slots.extra ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("extra"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "extra")
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 2),
|
|
_ctx.$slots.default ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("main"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var PageHeader = _export_sfc(_sfc_main95, [["__file", "page-header.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/page-header/index.mjs
|
|
var ElPageHeader = withInstall(PageHeader);
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/constants.mjs
|
|
var elPaginationKey = Symbol("elPaginationKey");
|
|
|
|
// node_modules/element-plus/es/components/select/src/token.mjs
|
|
var selectGroupKey = Symbol("ElSelectGroup");
|
|
var selectKey = Symbol("ElSelect");
|
|
|
|
// node_modules/element-plus/es/components/select/src/select.mjs
|
|
var SelectProps = buildProps({
|
|
name: String,
|
|
id: String,
|
|
modelValue: {
|
|
type: definePropType([
|
|
Array,
|
|
String,
|
|
Number,
|
|
Boolean,
|
|
Object
|
|
]),
|
|
default: void 0
|
|
},
|
|
autocomplete: {
|
|
type: String,
|
|
default: "off"
|
|
},
|
|
automaticDropdown: Boolean,
|
|
size: useSizeProp,
|
|
effect: {
|
|
type: definePropType(String),
|
|
default: "light"
|
|
},
|
|
disabled: Boolean,
|
|
clearable: Boolean,
|
|
filterable: Boolean,
|
|
allowCreate: Boolean,
|
|
loading: Boolean,
|
|
popperClass: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
popperOptions: {
|
|
type: definePropType(Object),
|
|
default: () => ({})
|
|
},
|
|
remote: Boolean,
|
|
loadingText: String,
|
|
noMatchText: String,
|
|
noDataText: String,
|
|
remoteMethod: Function,
|
|
filterMethod: Function,
|
|
multiple: Boolean,
|
|
multipleLimit: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
placeholder: {
|
|
type: String
|
|
},
|
|
defaultFirstOption: Boolean,
|
|
reserveKeyword: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
valueKey: {
|
|
type: String,
|
|
default: "value"
|
|
},
|
|
collapseTags: Boolean,
|
|
collapseTagsTooltip: Boolean,
|
|
maxCollapseTags: {
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
teleported: useTooltipContentProps.teleported,
|
|
persistent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
clearIcon: {
|
|
type: iconPropType,
|
|
default: circle_close_default
|
|
},
|
|
fitInputWidth: Boolean,
|
|
suffixIcon: {
|
|
type: iconPropType,
|
|
default: arrow_down_default
|
|
},
|
|
tagType: { ...tagProps.type, default: "info" },
|
|
tagEffect: { ...tagProps.effect, default: "light" },
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
remoteShowSuffix: Boolean,
|
|
showArrow: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
offset: {
|
|
type: Number,
|
|
default: 12
|
|
},
|
|
placement: {
|
|
type: definePropType(String),
|
|
values: Ee,
|
|
default: "bottom-start"
|
|
},
|
|
fallbackPlacements: {
|
|
type: definePropType(Array),
|
|
default: ["bottom-start", "top-start", "right", "left"]
|
|
},
|
|
tabindex: {
|
|
type: [String, Number],
|
|
default: 0
|
|
},
|
|
appendTo: useTooltipContentProps.appendTo,
|
|
...useEmptyValuesProps,
|
|
...useAriaProps(["ariaLabel"])
|
|
});
|
|
var selectEmits = {
|
|
[UPDATE_MODEL_EVENT]: (val) => true,
|
|
[CHANGE_EVENT]: (val) => true,
|
|
"popup-scroll": scrollbarEmits.scroll,
|
|
"remove-tag": (val) => true,
|
|
"visible-change": (visible) => true,
|
|
focus: (evt) => evt instanceof FocusEvent,
|
|
blur: (evt) => evt instanceof FocusEvent,
|
|
clear: () => true
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/select/src/option.mjs
|
|
var COMPONENT_NAME16 = "ElOption";
|
|
var optionProps = buildProps({
|
|
value: {
|
|
type: [String, Number, Boolean, Object],
|
|
required: true
|
|
},
|
|
label: {
|
|
type: [String, Number]
|
|
},
|
|
created: Boolean,
|
|
disabled: Boolean
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/select/src/useOption.mjs
|
|
function useOption(props2, states) {
|
|
const select = inject(selectKey);
|
|
if (!select) {
|
|
throwError(COMPONENT_NAME16, "usage: <el-select><el-option /></el-select/>");
|
|
}
|
|
const selectGroup = inject(selectGroupKey, { disabled: false });
|
|
const itemSelected = computed(() => {
|
|
return contains(castArray_default(select.props.modelValue), props2.value);
|
|
});
|
|
const limitReached = computed(() => {
|
|
var _a2;
|
|
if (select.props.multiple) {
|
|
const modelValue = castArray_default((_a2 = select.props.modelValue) != null ? _a2 : []);
|
|
return !itemSelected.value && modelValue.length >= select.props.multipleLimit && select.props.multipleLimit > 0;
|
|
} else {
|
|
return false;
|
|
}
|
|
});
|
|
const currentLabel = computed(() => {
|
|
return props2.label || (isObject(props2.value) ? "" : props2.value);
|
|
});
|
|
const currentValue = computed(() => {
|
|
return props2.value || props2.label || "";
|
|
});
|
|
const isDisabled = computed(() => {
|
|
return props2.disabled || states.groupDisabled || limitReached.value;
|
|
});
|
|
const instance = getCurrentInstance();
|
|
const contains = (arr = [], target2) => {
|
|
if (!isObject(props2.value)) {
|
|
return arr && arr.includes(target2);
|
|
} else {
|
|
const valueKey = select.props.valueKey;
|
|
return arr && arr.some((item) => {
|
|
return toRaw(get_default(item, valueKey)) === get_default(target2, valueKey);
|
|
});
|
|
}
|
|
};
|
|
const hoverItem = () => {
|
|
if (!props2.disabled && !selectGroup.disabled) {
|
|
select.states.hoveringIndex = select.optionsArray.indexOf(instance.proxy);
|
|
}
|
|
};
|
|
const updateOption = (query) => {
|
|
const regexp4 = new RegExp(escapeStringRegexp(query), "i");
|
|
states.visible = regexp4.test(String(currentLabel.value)) || props2.created;
|
|
};
|
|
watch(() => currentLabel.value, () => {
|
|
if (!props2.created && !select.props.remote)
|
|
select.setSelected();
|
|
});
|
|
watch(() => props2.value, (val, oldVal) => {
|
|
const { remote, valueKey } = select.props;
|
|
const shouldUpdate = remote ? val !== oldVal : !isEqual_default(val, oldVal);
|
|
if (shouldUpdate) {
|
|
select.onOptionDestroy(oldVal, instance.proxy);
|
|
select.onOptionCreate(instance.proxy);
|
|
}
|
|
if (!props2.created && !remote) {
|
|
if (valueKey && isObject(val) && isObject(oldVal) && val[valueKey] === oldVal[valueKey]) {
|
|
return;
|
|
}
|
|
select.setSelected();
|
|
}
|
|
});
|
|
watch(() => selectGroup.disabled, () => {
|
|
states.groupDisabled = selectGroup.disabled;
|
|
}, { immediate: true });
|
|
return {
|
|
select,
|
|
currentLabel,
|
|
currentValue,
|
|
itemSelected,
|
|
isDisabled,
|
|
hoverItem,
|
|
updateOption
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/select/src/option2.mjs
|
|
var _sfc_main96 = defineComponent({
|
|
name: COMPONENT_NAME16,
|
|
componentName: COMPONENT_NAME16,
|
|
props: optionProps,
|
|
setup(props2) {
|
|
const ns = useNamespace("select");
|
|
const id = useId();
|
|
const containerKls = computed(() => [
|
|
ns.be("dropdown", "item"),
|
|
ns.is("disabled", unref(isDisabled)),
|
|
ns.is("selected", unref(itemSelected)),
|
|
ns.is("hovering", unref(hover))
|
|
]);
|
|
const states = reactive({
|
|
index: -1,
|
|
groupDisabled: false,
|
|
visible: true,
|
|
hover: false
|
|
});
|
|
const {
|
|
currentLabel,
|
|
itemSelected,
|
|
isDisabled,
|
|
select,
|
|
hoverItem,
|
|
updateOption
|
|
} = useOption(props2, states);
|
|
const { visible, hover } = toRefs(states);
|
|
const vm = getCurrentInstance().proxy;
|
|
select.onOptionCreate(vm);
|
|
onBeforeUnmount(() => {
|
|
const key = vm.value;
|
|
const { selected: selectedOptions } = select.states;
|
|
const doesSelected = selectedOptions.some((item) => {
|
|
return item.value === vm.value;
|
|
});
|
|
nextTick(() => {
|
|
if (select.states.cachedOptions.get(key) === vm && !doesSelected) {
|
|
select.states.cachedOptions.delete(key);
|
|
}
|
|
});
|
|
select.onOptionDestroy(key, vm);
|
|
});
|
|
function selectOptionClick() {
|
|
if (!isDisabled.value) {
|
|
select.handleOptionSelect(vm);
|
|
}
|
|
}
|
|
return {
|
|
ns,
|
|
id,
|
|
containerKls,
|
|
currentLabel,
|
|
itemSelected,
|
|
isDisabled,
|
|
select,
|
|
visible,
|
|
hover,
|
|
states,
|
|
hoverItem,
|
|
updateOption,
|
|
selectOptionClick
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render17(_ctx, _cache) {
|
|
return withDirectives((openBlock(), createElementBlock("li", {
|
|
id: _ctx.id,
|
|
class: normalizeClass(_ctx.containerKls),
|
|
role: "option",
|
|
"aria-disabled": _ctx.isDisabled || void 0,
|
|
"aria-selected": _ctx.itemSelected,
|
|
onMousemove: _ctx.hoverItem,
|
|
onClick: withModifiers(_ctx.selectOptionClick, ["stop"])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default", {}, () => [
|
|
createBaseVNode("span", null, toDisplayString(_ctx.currentLabel), 1)
|
|
])
|
|
], 42, ["id", "aria-disabled", "aria-selected", "onMousemove", "onClick"])), [
|
|
[vShow, _ctx.visible]
|
|
]);
|
|
}
|
|
var Option = _export_sfc(_sfc_main96, [["render", _sfc_render17], ["__file", "option.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/select/src/select-dropdown.mjs
|
|
var _sfc_main97 = defineComponent({
|
|
name: "ElSelectDropdown",
|
|
componentName: "ElSelectDropdown",
|
|
setup() {
|
|
const select = inject(selectKey);
|
|
const ns = useNamespace("select");
|
|
const popperClass = computed(() => select.props.popperClass);
|
|
const isMultiple = computed(() => select.props.multiple);
|
|
const isFitInputWidth = computed(() => select.props.fitInputWidth);
|
|
const minWidth = ref("");
|
|
function updateMinWidth() {
|
|
var _a2;
|
|
minWidth.value = `${(_a2 = select.selectRef) == null ? void 0 : _a2.offsetWidth}px`;
|
|
}
|
|
onMounted(() => {
|
|
updateMinWidth();
|
|
useResizeObserver(select.selectRef, updateMinWidth);
|
|
});
|
|
return {
|
|
ns,
|
|
minWidth,
|
|
popperClass,
|
|
isMultiple,
|
|
isFitInputWidth
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render18(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([_ctx.ns.b("dropdown"), _ctx.ns.is("multiple", _ctx.isMultiple), _ctx.popperClass]),
|
|
style: normalizeStyle({ [_ctx.isFitInputWidth ? "width" : "minWidth"]: _ctx.minWidth })
|
|
}, [
|
|
_ctx.$slots.header ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(_ctx.ns.be("dropdown", "header"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "header")
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
renderSlot(_ctx.$slots, "default"),
|
|
_ctx.$slots.footer ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(_ctx.ns.be("dropdown", "footer"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "footer")
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 6);
|
|
}
|
|
var ElSelectMenu = _export_sfc(_sfc_main97, [["render", _sfc_render18], ["__file", "select-dropdown.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/select/src/useSelect.mjs
|
|
var useSelect = (props2, emit) => {
|
|
const { t } = useLocale();
|
|
const contentId = useId();
|
|
const nsSelect = useNamespace("select");
|
|
const nsInput = useNamespace("input");
|
|
const states = reactive({
|
|
inputValue: "",
|
|
options: new Map(),
|
|
cachedOptions: new Map(),
|
|
optionValues: [],
|
|
selected: [],
|
|
selectionWidth: 0,
|
|
collapseItemWidth: 0,
|
|
selectedLabel: "",
|
|
hoveringIndex: -1,
|
|
previousQuery: null,
|
|
inputHovering: false,
|
|
menuVisibleOnFocus: false,
|
|
isBeforeHide: false
|
|
});
|
|
const selectRef = ref();
|
|
const selectionRef = ref();
|
|
const tooltipRef = ref();
|
|
const tagTooltipRef = ref();
|
|
const inputRef = ref();
|
|
const prefixRef = ref();
|
|
const suffixRef = ref();
|
|
const menuRef = ref();
|
|
const tagMenuRef = ref();
|
|
const collapseItemRef = ref();
|
|
const scrollbarRef = ref();
|
|
const {
|
|
isComposing,
|
|
handleCompositionStart,
|
|
handleCompositionUpdate,
|
|
handleCompositionEnd
|
|
} = useComposition({
|
|
afterComposition: (e) => onInput(e)
|
|
});
|
|
const { wrapperRef, isFocused, handleBlur } = useFocusController(inputRef, {
|
|
beforeFocus() {
|
|
return selectDisabled.value;
|
|
},
|
|
afterFocus() {
|
|
if (props2.automaticDropdown && !expanded.value) {
|
|
expanded.value = true;
|
|
states.menuVisibleOnFocus = true;
|
|
}
|
|
},
|
|
beforeBlur(event) {
|
|
var _a2, _b;
|
|
return ((_a2 = tooltipRef.value) == null ? void 0 : _a2.isFocusInsideContent(event)) || ((_b = tagTooltipRef.value) == null ? void 0 : _b.isFocusInsideContent(event));
|
|
},
|
|
afterBlur() {
|
|
var _a2;
|
|
expanded.value = false;
|
|
states.menuVisibleOnFocus = false;
|
|
if (props2.validateEvent) {
|
|
(_a2 = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a2.call(formItem, "blur").catch((err) => debugWarn(err));
|
|
}
|
|
}
|
|
});
|
|
const expanded = ref(false);
|
|
const hoverOption = ref();
|
|
const { form, formItem } = useFormItem();
|
|
const { inputId } = useFormItemInputId(props2, {
|
|
formItemContext: formItem
|
|
});
|
|
const { valueOnClear, isEmptyValue: isEmptyValue2 } = useEmptyValues(props2);
|
|
const selectDisabled = computed(() => props2.disabled || (form == null ? void 0 : form.disabled));
|
|
const hasModelValue = computed(() => {
|
|
return isArray(props2.modelValue) ? props2.modelValue.length > 0 : !isEmptyValue2(props2.modelValue);
|
|
});
|
|
const needStatusIcon = computed(() => {
|
|
var _a2;
|
|
return (_a2 = form == null ? void 0 : form.statusIcon) != null ? _a2 : false;
|
|
});
|
|
const showClose = computed(() => {
|
|
return props2.clearable && !selectDisabled.value && states.inputHovering && hasModelValue.value;
|
|
});
|
|
const iconComponent = computed(() => props2.remote && props2.filterable && !props2.remoteShowSuffix ? "" : props2.suffixIcon);
|
|
const iconReverse = computed(() => nsSelect.is("reverse", !!(iconComponent.value && expanded.value)));
|
|
const validateState = computed(() => (formItem == null ? void 0 : formItem.validateState) || "");
|
|
const validateIcon = computed(() => validateState.value && ValidateComponentsMap[validateState.value]);
|
|
const debounce$1 = computed(() => props2.remote ? 300 : 0);
|
|
const isRemoteSearchEmpty = computed(() => props2.remote && !states.inputValue && states.options.size === 0);
|
|
const emptyText = computed(() => {
|
|
if (props2.loading) {
|
|
return props2.loadingText || t("el.select.loading");
|
|
} else {
|
|
if (props2.filterable && states.inputValue && states.options.size > 0 && filteredOptionsCount.value === 0) {
|
|
return props2.noMatchText || t("el.select.noMatch");
|
|
}
|
|
if (states.options.size === 0) {
|
|
return props2.noDataText || t("el.select.noData");
|
|
}
|
|
}
|
|
return null;
|
|
});
|
|
const filteredOptionsCount = computed(() => optionsArray.value.filter((option) => option.visible).length);
|
|
const optionsArray = computed(() => {
|
|
const list = Array.from(states.options.values());
|
|
const newList = [];
|
|
states.optionValues.forEach((item) => {
|
|
const index = list.findIndex((i) => i.value === item);
|
|
if (index > -1) {
|
|
newList.push(list[index]);
|
|
}
|
|
});
|
|
return newList.length >= list.length ? newList : list;
|
|
});
|
|
const cachedOptionsArray = computed(() => Array.from(states.cachedOptions.values()));
|
|
const showNewOption = computed(() => {
|
|
const hasExistingOption = optionsArray.value.filter((option) => {
|
|
return !option.created;
|
|
}).some((option) => {
|
|
return option.currentLabel === states.inputValue;
|
|
});
|
|
return props2.filterable && props2.allowCreate && states.inputValue !== "" && !hasExistingOption;
|
|
});
|
|
const updateOptions2 = () => {
|
|
if (props2.filterable && isFunction(props2.filterMethod))
|
|
return;
|
|
if (props2.filterable && props2.remote && isFunction(props2.remoteMethod))
|
|
return;
|
|
optionsArray.value.forEach((option) => {
|
|
var _a2;
|
|
(_a2 = option.updateOption) == null ? void 0 : _a2.call(option, states.inputValue);
|
|
});
|
|
};
|
|
const selectSize = useFormSize();
|
|
const collapseTagSize = computed(() => ["small"].includes(selectSize.value) ? "small" : "default");
|
|
const dropdownMenuVisible = computed({
|
|
get() {
|
|
return expanded.value && !isRemoteSearchEmpty.value;
|
|
},
|
|
set(val) {
|
|
expanded.value = val;
|
|
}
|
|
});
|
|
const shouldShowPlaceholder = computed(() => {
|
|
if (props2.multiple && !isUndefined2(props2.modelValue)) {
|
|
return castArray_default(props2.modelValue).length === 0 && !states.inputValue;
|
|
}
|
|
const value = isArray(props2.modelValue) ? props2.modelValue[0] : props2.modelValue;
|
|
return props2.filterable || isUndefined2(value) ? !states.inputValue : true;
|
|
});
|
|
const currentPlaceholder = computed(() => {
|
|
var _a2;
|
|
const _placeholder = (_a2 = props2.placeholder) != null ? _a2 : t("el.select.placeholder");
|
|
return props2.multiple || !hasModelValue.value ? _placeholder : states.selectedLabel;
|
|
});
|
|
const mouseEnterEventName = computed(() => isIOS ? null : "mouseenter");
|
|
watch(() => props2.modelValue, (val, oldVal) => {
|
|
if (props2.multiple) {
|
|
if (props2.filterable && !props2.reserveKeyword) {
|
|
states.inputValue = "";
|
|
handleQueryChange("");
|
|
}
|
|
}
|
|
setSelected();
|
|
if (!isEqual_default(val, oldVal) && props2.validateEvent) {
|
|
formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
|
|
}
|
|
}, {
|
|
flush: "post",
|
|
deep: true
|
|
});
|
|
watch(() => expanded.value, (val) => {
|
|
if (val) {
|
|
handleQueryChange(states.inputValue);
|
|
} else {
|
|
states.inputValue = "";
|
|
states.previousQuery = null;
|
|
states.isBeforeHide = true;
|
|
}
|
|
emit("visible-change", val);
|
|
});
|
|
watch(() => states.options.entries(), () => {
|
|
if (!isClient)
|
|
return;
|
|
setSelected();
|
|
if (props2.defaultFirstOption && (props2.filterable || props2.remote) && filteredOptionsCount.value) {
|
|
checkDefaultFirstOption();
|
|
}
|
|
}, {
|
|
flush: "post"
|
|
});
|
|
watch([() => states.hoveringIndex, optionsArray], ([val]) => {
|
|
if (isNumber2(val) && val > -1) {
|
|
hoverOption.value = optionsArray.value[val] || {};
|
|
} else {
|
|
hoverOption.value = {};
|
|
}
|
|
optionsArray.value.forEach((option) => {
|
|
option.hover = hoverOption.value === option;
|
|
});
|
|
});
|
|
watchEffect(() => {
|
|
if (states.isBeforeHide)
|
|
return;
|
|
updateOptions2();
|
|
});
|
|
const handleQueryChange = (val) => {
|
|
if (states.previousQuery === val || isComposing.value) {
|
|
return;
|
|
}
|
|
states.previousQuery = val;
|
|
if (props2.filterable && isFunction(props2.filterMethod)) {
|
|
props2.filterMethod(val);
|
|
} else if (props2.filterable && props2.remote && isFunction(props2.remoteMethod)) {
|
|
props2.remoteMethod(val);
|
|
}
|
|
if (props2.defaultFirstOption && (props2.filterable || props2.remote) && filteredOptionsCount.value) {
|
|
nextTick(checkDefaultFirstOption);
|
|
} else {
|
|
nextTick(updateHoveringIndex);
|
|
}
|
|
};
|
|
const checkDefaultFirstOption = () => {
|
|
const optionsInDropdown = optionsArray.value.filter((n) => n.visible && !n.disabled && !n.states.groupDisabled);
|
|
const userCreatedOption = optionsInDropdown.find((n) => n.created);
|
|
const firstOriginOption = optionsInDropdown[0];
|
|
const valueList = optionsArray.value.map((item) => item.value);
|
|
states.hoveringIndex = getValueIndex(valueList, userCreatedOption || firstOriginOption);
|
|
};
|
|
const setSelected = () => {
|
|
if (!props2.multiple) {
|
|
const value = isArray(props2.modelValue) ? props2.modelValue[0] : props2.modelValue;
|
|
const option = getOption(value);
|
|
states.selectedLabel = option.currentLabel;
|
|
states.selected = [option];
|
|
return;
|
|
} else {
|
|
states.selectedLabel = "";
|
|
}
|
|
const result2 = [];
|
|
if (!isUndefined2(props2.modelValue)) {
|
|
castArray_default(props2.modelValue).forEach((value) => {
|
|
result2.push(getOption(value));
|
|
});
|
|
}
|
|
states.selected = result2;
|
|
};
|
|
const getOption = (value) => {
|
|
let option;
|
|
const isObjectValue = isPlainObject(value);
|
|
for (let i = states.cachedOptions.size - 1; i >= 0; i--) {
|
|
const cachedOption = cachedOptionsArray.value[i];
|
|
const isEqualValue = isObjectValue ? get_default(cachedOption.value, props2.valueKey) === get_default(value, props2.valueKey) : cachedOption.value === value;
|
|
if (isEqualValue) {
|
|
option = {
|
|
value,
|
|
currentLabel: cachedOption.currentLabel,
|
|
get isDisabled() {
|
|
return cachedOption.isDisabled;
|
|
}
|
|
};
|
|
break;
|
|
}
|
|
}
|
|
if (option)
|
|
return option;
|
|
const label = isObjectValue ? value.label : value != null ? value : "";
|
|
const newOption = {
|
|
value,
|
|
currentLabel: label
|
|
};
|
|
return newOption;
|
|
};
|
|
const updateHoveringIndex = () => {
|
|
states.hoveringIndex = optionsArray.value.findIndex((item) => states.selected.some((selected) => getValueKey(selected) === getValueKey(item)));
|
|
};
|
|
const resetSelectionWidth = () => {
|
|
states.selectionWidth = Number.parseFloat(window.getComputedStyle(selectionRef.value).width);
|
|
};
|
|
const resetCollapseItemWidth = () => {
|
|
states.collapseItemWidth = collapseItemRef.value.getBoundingClientRect().width;
|
|
};
|
|
const updateTooltip = () => {
|
|
var _a2, _b;
|
|
(_b = (_a2 = tooltipRef.value) == null ? void 0 : _a2.updatePopper) == null ? void 0 : _b.call(_a2);
|
|
};
|
|
const updateTagTooltip = () => {
|
|
var _a2, _b;
|
|
(_b = (_a2 = tagTooltipRef.value) == null ? void 0 : _a2.updatePopper) == null ? void 0 : _b.call(_a2);
|
|
};
|
|
const onInputChange = () => {
|
|
if (states.inputValue.length > 0 && !expanded.value) {
|
|
expanded.value = true;
|
|
}
|
|
handleQueryChange(states.inputValue);
|
|
};
|
|
const onInput = (event) => {
|
|
states.inputValue = event.target.value;
|
|
if (props2.remote) {
|
|
debouncedOnInputChange();
|
|
} else {
|
|
return onInputChange();
|
|
}
|
|
};
|
|
const debouncedOnInputChange = debounce_default(() => {
|
|
onInputChange();
|
|
}, debounce$1.value);
|
|
const emitChange = (val) => {
|
|
if (!isEqual_default(props2.modelValue, val)) {
|
|
emit(CHANGE_EVENT, val);
|
|
}
|
|
};
|
|
const getLastNotDisabledIndex = (value) => findLastIndex_default(value, (it2) => {
|
|
const option = states.cachedOptions.get(it2);
|
|
return option && !option.disabled && !option.states.groupDisabled;
|
|
});
|
|
const deletePrevTag = (e) => {
|
|
if (!props2.multiple)
|
|
return;
|
|
if (e.code === EVENT_CODE.delete)
|
|
return;
|
|
if (e.target.value.length <= 0) {
|
|
const value = castArray_default(props2.modelValue).slice();
|
|
const lastNotDisabledIndex = getLastNotDisabledIndex(value);
|
|
if (lastNotDisabledIndex < 0)
|
|
return;
|
|
const removeTagValue = value[lastNotDisabledIndex];
|
|
value.splice(lastNotDisabledIndex, 1);
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emitChange(value);
|
|
emit("remove-tag", removeTagValue);
|
|
}
|
|
};
|
|
const deleteTag = (event, tag) => {
|
|
const index = states.selected.indexOf(tag);
|
|
if (index > -1 && !selectDisabled.value) {
|
|
const value = castArray_default(props2.modelValue).slice();
|
|
value.splice(index, 1);
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emitChange(value);
|
|
emit("remove-tag", tag.value);
|
|
}
|
|
event.stopPropagation();
|
|
focus();
|
|
};
|
|
const deleteSelected = (event) => {
|
|
event.stopPropagation();
|
|
const value = props2.multiple ? [] : valueOnClear.value;
|
|
if (props2.multiple) {
|
|
for (const item of states.selected) {
|
|
if (item.isDisabled)
|
|
value.push(item.value);
|
|
}
|
|
}
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emitChange(value);
|
|
states.hoveringIndex = -1;
|
|
expanded.value = false;
|
|
emit("clear");
|
|
focus();
|
|
};
|
|
const handleOptionSelect = (option) => {
|
|
var _a2;
|
|
if (props2.multiple) {
|
|
const value = castArray_default((_a2 = props2.modelValue) != null ? _a2 : []).slice();
|
|
const optionIndex = getValueIndex(value, option);
|
|
if (optionIndex > -1) {
|
|
value.splice(optionIndex, 1);
|
|
} else if (props2.multipleLimit <= 0 || value.length < props2.multipleLimit) {
|
|
value.push(option.value);
|
|
}
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emitChange(value);
|
|
if (option.created) {
|
|
handleQueryChange("");
|
|
}
|
|
if (props2.filterable && !props2.reserveKeyword) {
|
|
states.inputValue = "";
|
|
}
|
|
} else {
|
|
emit(UPDATE_MODEL_EVENT, option.value);
|
|
emitChange(option.value);
|
|
expanded.value = false;
|
|
}
|
|
focus();
|
|
if (expanded.value)
|
|
return;
|
|
nextTick(() => {
|
|
scrollToOption(option);
|
|
});
|
|
};
|
|
const getValueIndex = (arr, option) => {
|
|
if (isUndefined2(option))
|
|
return -1;
|
|
if (!isObject(option.value))
|
|
return arr.indexOf(option.value);
|
|
return arr.findIndex((item) => {
|
|
return isEqual_default(get_default(item, props2.valueKey), getValueKey(option));
|
|
});
|
|
};
|
|
const scrollToOption = (option) => {
|
|
var _a2, _b, _c, _d, _e;
|
|
const targetOption = isArray(option) ? option[0] : option;
|
|
let target2 = null;
|
|
if (targetOption == null ? void 0 : targetOption.value) {
|
|
const options = optionsArray.value.filter((item) => item.value === targetOption.value);
|
|
if (options.length > 0) {
|
|
target2 = options[0].$el;
|
|
}
|
|
}
|
|
if (tooltipRef.value && target2) {
|
|
const menu = (_d = (_c = (_b = (_a2 = tooltipRef.value) == null ? void 0 : _a2.popperRef) == null ? void 0 : _b.contentRef) == null ? void 0 : _c.querySelector) == null ? void 0 : _d.call(_c, `.${nsSelect.be("dropdown", "wrap")}`);
|
|
if (menu) {
|
|
scrollIntoView(menu, target2);
|
|
}
|
|
}
|
|
(_e = scrollbarRef.value) == null ? void 0 : _e.handleScroll();
|
|
};
|
|
const onOptionCreate = (vm) => {
|
|
states.options.set(vm.value, vm);
|
|
states.cachedOptions.set(vm.value, vm);
|
|
};
|
|
const onOptionDestroy = (key, vm) => {
|
|
if (states.options.get(key) === vm) {
|
|
states.options.delete(key);
|
|
}
|
|
};
|
|
const popperRef = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = tooltipRef.value) == null ? void 0 : _a2.popperRef) == null ? void 0 : _b.contentRef;
|
|
});
|
|
const handleMenuEnter = () => {
|
|
states.isBeforeHide = false;
|
|
nextTick(() => {
|
|
var _a2;
|
|
(_a2 = scrollbarRef.value) == null ? void 0 : _a2.update();
|
|
scrollToOption(states.selected);
|
|
});
|
|
};
|
|
const focus = () => {
|
|
var _a2;
|
|
(_a2 = inputRef.value) == null ? void 0 : _a2.focus();
|
|
};
|
|
const blur = () => {
|
|
var _a2;
|
|
if (expanded.value) {
|
|
expanded.value = false;
|
|
nextTick(() => {
|
|
var _a22;
|
|
return (_a22 = inputRef.value) == null ? void 0 : _a22.blur();
|
|
});
|
|
return;
|
|
}
|
|
(_a2 = inputRef.value) == null ? void 0 : _a2.blur();
|
|
};
|
|
const handleClearClick = (event) => {
|
|
deleteSelected(event);
|
|
};
|
|
const handleClickOutside = (event) => {
|
|
expanded.value = false;
|
|
if (isFocused.value) {
|
|
const _event2 = new FocusEvent("focus", event);
|
|
nextTick(() => handleBlur(_event2));
|
|
}
|
|
};
|
|
const handleEsc = () => {
|
|
if (states.inputValue.length > 0) {
|
|
states.inputValue = "";
|
|
} else {
|
|
expanded.value = false;
|
|
}
|
|
};
|
|
const toggleMenu = () => {
|
|
if (selectDisabled.value)
|
|
return;
|
|
if (isIOS)
|
|
states.inputHovering = true;
|
|
if (states.menuVisibleOnFocus) {
|
|
states.menuVisibleOnFocus = false;
|
|
} else {
|
|
expanded.value = !expanded.value;
|
|
}
|
|
};
|
|
const selectOption = () => {
|
|
if (!expanded.value) {
|
|
toggleMenu();
|
|
} else {
|
|
const option = optionsArray.value[states.hoveringIndex];
|
|
if (option && !option.isDisabled) {
|
|
handleOptionSelect(option);
|
|
}
|
|
}
|
|
};
|
|
const getValueKey = (item) => {
|
|
return isObject(item.value) ? get_default(item.value, props2.valueKey) : item.value;
|
|
};
|
|
const optionsAllDisabled = computed(() => optionsArray.value.filter((option) => option.visible).every((option) => option.isDisabled));
|
|
const showTagList = computed(() => {
|
|
if (!props2.multiple) {
|
|
return [];
|
|
}
|
|
return props2.collapseTags ? states.selected.slice(0, props2.maxCollapseTags) : states.selected;
|
|
});
|
|
const collapseTagList = computed(() => {
|
|
if (!props2.multiple) {
|
|
return [];
|
|
}
|
|
return props2.collapseTags ? states.selected.slice(props2.maxCollapseTags) : [];
|
|
});
|
|
const navigateOptions = (direction2) => {
|
|
if (!expanded.value) {
|
|
expanded.value = true;
|
|
return;
|
|
}
|
|
if (states.options.size === 0 || filteredOptionsCount.value === 0 || isComposing.value)
|
|
return;
|
|
if (!optionsAllDisabled.value) {
|
|
if (direction2 === "next") {
|
|
states.hoveringIndex++;
|
|
if (states.hoveringIndex === states.options.size) {
|
|
states.hoveringIndex = 0;
|
|
}
|
|
} else if (direction2 === "prev") {
|
|
states.hoveringIndex--;
|
|
if (states.hoveringIndex < 0) {
|
|
states.hoveringIndex = states.options.size - 1;
|
|
}
|
|
}
|
|
const option = optionsArray.value[states.hoveringIndex];
|
|
if (option.isDisabled || !option.visible) {
|
|
navigateOptions(direction2);
|
|
}
|
|
nextTick(() => scrollToOption(hoverOption.value));
|
|
}
|
|
};
|
|
const getGapWidth = () => {
|
|
if (!selectionRef.value)
|
|
return 0;
|
|
const style = window.getComputedStyle(selectionRef.value);
|
|
return Number.parseFloat(style.gap || "6px");
|
|
};
|
|
const tagStyle = computed(() => {
|
|
const gapWidth = getGapWidth();
|
|
const maxWidth = collapseItemRef.value && props2.maxCollapseTags === 1 ? states.selectionWidth - states.collapseItemWidth - gapWidth : states.selectionWidth;
|
|
return { maxWidth: `${maxWidth}px` };
|
|
});
|
|
const collapseTagStyle = computed(() => {
|
|
return { maxWidth: `${states.selectionWidth}px` };
|
|
});
|
|
const popupScroll = (data) => {
|
|
emit("popup-scroll", data);
|
|
};
|
|
useResizeObserver(selectionRef, resetSelectionWidth);
|
|
useResizeObserver(menuRef, updateTooltip);
|
|
useResizeObserver(wrapperRef, updateTooltip);
|
|
useResizeObserver(tagMenuRef, updateTagTooltip);
|
|
useResizeObserver(collapseItemRef, resetCollapseItemWidth);
|
|
onMounted(() => {
|
|
setSelected();
|
|
});
|
|
return {
|
|
inputId,
|
|
contentId,
|
|
nsSelect,
|
|
nsInput,
|
|
states,
|
|
isFocused,
|
|
expanded,
|
|
optionsArray,
|
|
hoverOption,
|
|
selectSize,
|
|
filteredOptionsCount,
|
|
updateTooltip,
|
|
updateTagTooltip,
|
|
debouncedOnInputChange,
|
|
onInput,
|
|
deletePrevTag,
|
|
deleteTag,
|
|
deleteSelected,
|
|
handleOptionSelect,
|
|
scrollToOption,
|
|
hasModelValue,
|
|
shouldShowPlaceholder,
|
|
currentPlaceholder,
|
|
mouseEnterEventName,
|
|
needStatusIcon,
|
|
showClose,
|
|
iconComponent,
|
|
iconReverse,
|
|
validateState,
|
|
validateIcon,
|
|
showNewOption,
|
|
updateOptions: updateOptions2,
|
|
collapseTagSize,
|
|
setSelected,
|
|
selectDisabled,
|
|
emptyText,
|
|
handleCompositionStart,
|
|
handleCompositionUpdate,
|
|
handleCompositionEnd,
|
|
onOptionCreate,
|
|
onOptionDestroy,
|
|
handleMenuEnter,
|
|
focus,
|
|
blur,
|
|
handleClearClick,
|
|
handleClickOutside,
|
|
handleEsc,
|
|
toggleMenu,
|
|
selectOption,
|
|
getValueKey,
|
|
navigateOptions,
|
|
dropdownMenuVisible,
|
|
showTagList,
|
|
collapseTagList,
|
|
popupScroll,
|
|
tagStyle,
|
|
collapseTagStyle,
|
|
popperRef,
|
|
inputRef,
|
|
tooltipRef,
|
|
tagTooltipRef,
|
|
prefixRef,
|
|
suffixRef,
|
|
selectRef,
|
|
wrapperRef,
|
|
selectionRef,
|
|
scrollbarRef,
|
|
menuRef,
|
|
tagMenuRef,
|
|
collapseItemRef
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/select/src/options.mjs
|
|
var ElOptions = defineComponent({
|
|
name: "ElOptions",
|
|
setup(_2, { slots }) {
|
|
const select = inject(selectKey);
|
|
let cachedValueList = [];
|
|
return () => {
|
|
var _a2, _b;
|
|
const children = (_a2 = slots.default) == null ? void 0 : _a2.call(slots);
|
|
const valueList = [];
|
|
function filterOptions(children2) {
|
|
if (!isArray(children2))
|
|
return;
|
|
children2.forEach((item) => {
|
|
var _a22, _b2, _c, _d;
|
|
const name = (_a22 = (item == null ? void 0 : item.type) || {}) == null ? void 0 : _a22.name;
|
|
if (name === "ElOptionGroup") {
|
|
filterOptions(!isString(item.children) && !isArray(item.children) && isFunction((_b2 = item.children) == null ? void 0 : _b2.default) ? (_c = item.children) == null ? void 0 : _c.default() : item.children);
|
|
} else if (name === "ElOption") {
|
|
valueList.push((_d = item.props) == null ? void 0 : _d.value);
|
|
} else if (isArray(item.children)) {
|
|
filterOptions(item.children);
|
|
}
|
|
});
|
|
}
|
|
if (children.length) {
|
|
filterOptions((_b = children[0]) == null ? void 0 : _b.children);
|
|
}
|
|
if (!isEqual_default(valueList, cachedValueList)) {
|
|
cachedValueList = valueList;
|
|
if (select) {
|
|
select.states.optionValues = valueList;
|
|
}
|
|
}
|
|
return children;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/select/src/select2.mjs
|
|
var COMPONENT_NAME17 = "ElSelect";
|
|
var _sfc_main98 = defineComponent({
|
|
name: COMPONENT_NAME17,
|
|
componentName: COMPONENT_NAME17,
|
|
components: {
|
|
ElSelectMenu,
|
|
ElOption: Option,
|
|
ElOptions,
|
|
ElTag,
|
|
ElScrollbar,
|
|
ElTooltip,
|
|
ElIcon
|
|
},
|
|
directives: { ClickOutside },
|
|
props: SelectProps,
|
|
emits: [
|
|
UPDATE_MODEL_EVENT,
|
|
CHANGE_EVENT,
|
|
"remove-tag",
|
|
"clear",
|
|
"visible-change",
|
|
"focus",
|
|
"blur",
|
|
"popup-scroll"
|
|
],
|
|
setup(props2, { emit, slots }) {
|
|
const modelValue = computed(() => {
|
|
const { modelValue: rawModelValue, multiple } = props2;
|
|
const fallback = multiple ? [] : void 0;
|
|
if (isArray(rawModelValue)) {
|
|
return multiple ? rawModelValue : fallback;
|
|
}
|
|
return multiple ? fallback : rawModelValue;
|
|
});
|
|
const _props = reactive({
|
|
...toRefs(props2),
|
|
modelValue
|
|
});
|
|
const API = useSelect(_props, emit);
|
|
const { calculatorRef, inputStyle } = useCalcInputWidth();
|
|
const manuallyRenderSlots = (defaultSlots) => {
|
|
if (!props2.persistent && defaultSlots) {
|
|
const children = flattedChildren(defaultSlots);
|
|
children.filter((item) => {
|
|
return isObject(item) && item.type.name === "ElOption";
|
|
}).forEach((item) => {
|
|
const obj = { ...item.props };
|
|
obj.currentLabel = obj.label || (isObject(obj.value) ? "" : obj.value);
|
|
API.onOptionCreate(obj);
|
|
});
|
|
}
|
|
};
|
|
watch(() => {
|
|
var _a2;
|
|
const currentSlot = (_a2 = slots.default) == null ? void 0 : _a2.call(slots);
|
|
return currentSlot;
|
|
}, (newSlot) => {
|
|
manuallyRenderSlots(newSlot);
|
|
}, {
|
|
immediate: true
|
|
});
|
|
provide(selectKey, reactive({
|
|
props: _props,
|
|
states: API.states,
|
|
selectRef: API.selectRef,
|
|
optionsArray: API.optionsArray,
|
|
setSelected: API.setSelected,
|
|
handleOptionSelect: API.handleOptionSelect,
|
|
onOptionCreate: API.onOptionCreate,
|
|
onOptionDestroy: API.onOptionDestroy
|
|
}));
|
|
const selectedLabel = computed(() => {
|
|
if (!props2.multiple) {
|
|
return API.states.selectedLabel;
|
|
}
|
|
return API.states.selected.map((i) => i.currentLabel);
|
|
});
|
|
return {
|
|
...API,
|
|
modelValue,
|
|
selectedLabel,
|
|
calculatorRef,
|
|
inputStyle
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render19(_ctx, _cache) {
|
|
const _component_el_tag = resolveComponent("el-tag");
|
|
const _component_el_tooltip = resolveComponent("el-tooltip");
|
|
const _component_el_icon = resolveComponent("el-icon");
|
|
const _component_el_option = resolveComponent("el-option");
|
|
const _component_el_options = resolveComponent("el-options");
|
|
const _component_el_scrollbar = resolveComponent("el-scrollbar");
|
|
const _component_el_select_menu = resolveComponent("el-select-menu");
|
|
const _directive_click_outside = resolveDirective("click-outside");
|
|
return withDirectives((openBlock(), createElementBlock("div", {
|
|
ref: "selectRef",
|
|
class: normalizeClass([_ctx.nsSelect.b(), _ctx.nsSelect.m(_ctx.selectSize)]),
|
|
[toHandlerKey(_ctx.mouseEnterEventName)]: ($event) => _ctx.states.inputHovering = true,
|
|
onMouseleave: ($event) => _ctx.states.inputHovering = false
|
|
}, [
|
|
createVNode(_component_el_tooltip, {
|
|
ref: "tooltipRef",
|
|
visible: _ctx.dropdownMenuVisible,
|
|
placement: _ctx.placement,
|
|
teleported: _ctx.teleported,
|
|
"popper-class": [_ctx.nsSelect.e("popper"), _ctx.popperClass],
|
|
"popper-options": _ctx.popperOptions,
|
|
"fallback-placements": _ctx.fallbackPlacements,
|
|
effect: _ctx.effect,
|
|
pure: "",
|
|
trigger: "click",
|
|
transition: `${_ctx.nsSelect.namespace.value}-zoom-in-top`,
|
|
"stop-popper-mouse-event": false,
|
|
"gpu-acceleration": false,
|
|
persistent: _ctx.persistent,
|
|
"append-to": _ctx.appendTo,
|
|
"show-arrow": _ctx.showArrow,
|
|
offset: _ctx.offset,
|
|
onBeforeShow: _ctx.handleMenuEnter,
|
|
onHide: ($event) => _ctx.states.isBeforeHide = false
|
|
}, {
|
|
default: withCtx(() => {
|
|
var _a2;
|
|
return [
|
|
createBaseVNode("div", {
|
|
ref: "wrapperRef",
|
|
class: normalizeClass([
|
|
_ctx.nsSelect.e("wrapper"),
|
|
_ctx.nsSelect.is("focused", _ctx.isFocused),
|
|
_ctx.nsSelect.is("hovering", _ctx.states.inputHovering),
|
|
_ctx.nsSelect.is("filterable", _ctx.filterable),
|
|
_ctx.nsSelect.is("disabled", _ctx.selectDisabled)
|
|
]),
|
|
onClick: withModifiers(_ctx.toggleMenu, ["prevent"])
|
|
}, [
|
|
_ctx.$slots.prefix ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
ref: "prefixRef",
|
|
class: normalizeClass(_ctx.nsSelect.e("prefix"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "prefix")
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
ref: "selectionRef",
|
|
class: normalizeClass([
|
|
_ctx.nsSelect.e("selection"),
|
|
_ctx.nsSelect.is("near", _ctx.multiple && !_ctx.$slots.prefix && !!_ctx.states.selected.length)
|
|
])
|
|
}, [
|
|
_ctx.multiple ? renderSlot(_ctx.$slots, "tag", { key: 0 }, () => [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.showTagList, (item) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
key: _ctx.getValueKey(item),
|
|
class: normalizeClass(_ctx.nsSelect.e("selected-item"))
|
|
}, [
|
|
createVNode(_component_el_tag, {
|
|
closable: !_ctx.selectDisabled && !item.isDisabled,
|
|
size: _ctx.collapseTagSize,
|
|
type: _ctx.tagType,
|
|
effect: _ctx.tagEffect,
|
|
"disable-transitions": "",
|
|
style: normalizeStyle(_ctx.tagStyle),
|
|
onClose: ($event) => _ctx.deleteTag($event, item)
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(_ctx.nsSelect.e("tags-text"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "label", {
|
|
label: item.currentLabel,
|
|
value: item.value
|
|
}, () => [
|
|
createTextVNode(toDisplayString(item.currentLabel), 1)
|
|
])
|
|
], 2)
|
|
]),
|
|
_: 2
|
|
}, 1032, ["closable", "size", "type", "effect", "style", "onClose"])
|
|
], 2);
|
|
}), 128)),
|
|
_ctx.collapseTags && _ctx.states.selected.length > _ctx.maxCollapseTags ? (openBlock(), createBlock(_component_el_tooltip, {
|
|
key: 0,
|
|
ref: "tagTooltipRef",
|
|
disabled: _ctx.dropdownMenuVisible || !_ctx.collapseTagsTooltip,
|
|
"fallback-placements": ["bottom", "top", "right", "left"],
|
|
effect: _ctx.effect,
|
|
placement: "bottom",
|
|
teleported: _ctx.teleported
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
ref: "collapseItemRef",
|
|
class: normalizeClass(_ctx.nsSelect.e("selected-item"))
|
|
}, [
|
|
createVNode(_component_el_tag, {
|
|
closable: false,
|
|
size: _ctx.collapseTagSize,
|
|
type: _ctx.tagType,
|
|
effect: _ctx.tagEffect,
|
|
"disable-transitions": "",
|
|
style: normalizeStyle(_ctx.collapseTagStyle)
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(_ctx.nsSelect.e("tags-text"))
|
|
}, " + " + toDisplayString(_ctx.states.selected.length - _ctx.maxCollapseTags), 3)
|
|
]),
|
|
_: 1
|
|
}, 8, ["size", "type", "effect", "style"])
|
|
], 2)
|
|
]),
|
|
content: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
ref: "tagMenuRef",
|
|
class: normalizeClass(_ctx.nsSelect.e("selection"))
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.collapseTagList, (item) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
key: _ctx.getValueKey(item),
|
|
class: normalizeClass(_ctx.nsSelect.e("selected-item"))
|
|
}, [
|
|
createVNode(_component_el_tag, {
|
|
class: "in-tooltip",
|
|
closable: !_ctx.selectDisabled && !item.isDisabled,
|
|
size: _ctx.collapseTagSize,
|
|
type: _ctx.tagType,
|
|
effect: _ctx.tagEffect,
|
|
"disable-transitions": "",
|
|
onClose: ($event) => _ctx.deleteTag($event, item)
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(_ctx.nsSelect.e("tags-text"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "label", {
|
|
label: item.currentLabel,
|
|
value: item.value
|
|
}, () => [
|
|
createTextVNode(toDisplayString(item.currentLabel), 1)
|
|
])
|
|
], 2)
|
|
]),
|
|
_: 2
|
|
}, 1032, ["closable", "size", "type", "effect", "onClose"])
|
|
], 2);
|
|
}), 128))
|
|
], 2)
|
|
]),
|
|
_: 3
|
|
}, 8, ["disabled", "effect", "teleported"])) : createCommentVNode("v-if", true)
|
|
]) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([
|
|
_ctx.nsSelect.e("selected-item"),
|
|
_ctx.nsSelect.e("input-wrapper"),
|
|
_ctx.nsSelect.is("hidden", !_ctx.filterable)
|
|
])
|
|
}, [
|
|
withDirectives(createBaseVNode("input", {
|
|
id: _ctx.inputId,
|
|
ref: "inputRef",
|
|
"onUpdate:modelValue": ($event) => _ctx.states.inputValue = $event,
|
|
type: "text",
|
|
name: _ctx.name,
|
|
class: normalizeClass([_ctx.nsSelect.e("input"), _ctx.nsSelect.is(_ctx.selectSize)]),
|
|
disabled: _ctx.selectDisabled,
|
|
autocomplete: _ctx.autocomplete,
|
|
style: normalizeStyle(_ctx.inputStyle),
|
|
tabindex: _ctx.tabindex,
|
|
role: "combobox",
|
|
readonly: !_ctx.filterable,
|
|
spellcheck: "false",
|
|
"aria-activedescendant": ((_a2 = _ctx.hoverOption) == null ? void 0 : _a2.id) || "",
|
|
"aria-controls": _ctx.contentId,
|
|
"aria-expanded": _ctx.dropdownMenuVisible,
|
|
"aria-label": _ctx.ariaLabel,
|
|
"aria-autocomplete": "none",
|
|
"aria-haspopup": "listbox",
|
|
onKeydown: [
|
|
withKeys(withModifiers(($event) => _ctx.navigateOptions("next"), ["stop", "prevent"]), ["down"]),
|
|
withKeys(withModifiers(($event) => _ctx.navigateOptions("prev"), ["stop", "prevent"]), ["up"]),
|
|
withKeys(withModifiers(_ctx.handleEsc, ["stop", "prevent"]), ["esc"]),
|
|
withKeys(withModifiers(_ctx.selectOption, ["stop", "prevent"]), ["enter"]),
|
|
withKeys(withModifiers(_ctx.deletePrevTag, ["stop"]), ["delete"])
|
|
],
|
|
onCompositionstart: _ctx.handleCompositionStart,
|
|
onCompositionupdate: _ctx.handleCompositionUpdate,
|
|
onCompositionend: _ctx.handleCompositionEnd,
|
|
onInput: _ctx.onInput,
|
|
onClick: withModifiers(_ctx.toggleMenu, ["stop"])
|
|
}, null, 46, ["id", "onUpdate:modelValue", "name", "disabled", "autocomplete", "tabindex", "readonly", "aria-activedescendant", "aria-controls", "aria-expanded", "aria-label", "onKeydown", "onCompositionstart", "onCompositionupdate", "onCompositionend", "onInput", "onClick"]), [
|
|
[vModelText, _ctx.states.inputValue]
|
|
]),
|
|
_ctx.filterable ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
ref: "calculatorRef",
|
|
"aria-hidden": "true",
|
|
class: normalizeClass(_ctx.nsSelect.e("input-calculator")),
|
|
textContent: toDisplayString(_ctx.states.inputValue)
|
|
}, null, 10, ["textContent"])) : createCommentVNode("v-if", true)
|
|
], 2),
|
|
_ctx.shouldShowPlaceholder ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass([
|
|
_ctx.nsSelect.e("selected-item"),
|
|
_ctx.nsSelect.e("placeholder"),
|
|
_ctx.nsSelect.is("transparent", !_ctx.hasModelValue || _ctx.expanded && !_ctx.states.inputValue)
|
|
])
|
|
}, [
|
|
_ctx.hasModelValue ? renderSlot(_ctx.$slots, "label", {
|
|
key: 0,
|
|
label: _ctx.currentPlaceholder,
|
|
value: _ctx.modelValue
|
|
}, () => [
|
|
createBaseVNode("span", null, toDisplayString(_ctx.currentPlaceholder), 1)
|
|
]) : (openBlock(), createElementBlock("span", { key: 1 }, toDisplayString(_ctx.currentPlaceholder), 1))
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 2),
|
|
createBaseVNode("div", {
|
|
ref: "suffixRef",
|
|
class: normalizeClass(_ctx.nsSelect.e("suffix"))
|
|
}, [
|
|
_ctx.iconComponent && !_ctx.showClose ? (openBlock(), createBlock(_component_el_icon, {
|
|
key: 0,
|
|
class: normalizeClass([_ctx.nsSelect.e("caret"), _ctx.nsSelect.e("icon"), _ctx.iconReverse])
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.iconComponent)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true),
|
|
_ctx.showClose && _ctx.clearIcon ? (openBlock(), createBlock(_component_el_icon, {
|
|
key: 1,
|
|
class: normalizeClass([
|
|
_ctx.nsSelect.e("caret"),
|
|
_ctx.nsSelect.e("icon"),
|
|
_ctx.nsSelect.e("clear")
|
|
]),
|
|
onClick: _ctx.handleClearClick
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.clearIcon)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "onClick"])) : createCommentVNode("v-if", true),
|
|
_ctx.validateState && _ctx.validateIcon && _ctx.needStatusIcon ? (openBlock(), createBlock(_component_el_icon, {
|
|
key: 2,
|
|
class: normalizeClass([
|
|
_ctx.nsInput.e("icon"),
|
|
_ctx.nsInput.e("validateIcon"),
|
|
_ctx.nsInput.is("loading", _ctx.validateState === "validating")
|
|
])
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.validateIcon)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true)
|
|
], 2)
|
|
], 10, ["onClick"])
|
|
];
|
|
}),
|
|
content: withCtx(() => [
|
|
createVNode(_component_el_select_menu, { ref: "menuRef" }, {
|
|
default: withCtx(() => [
|
|
_ctx.$slots.header ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(_ctx.nsSelect.be("dropdown", "header")),
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "header")
|
|
], 10, ["onClick"])) : createCommentVNode("v-if", true),
|
|
withDirectives(createVNode(_component_el_scrollbar, {
|
|
id: _ctx.contentId,
|
|
ref: "scrollbarRef",
|
|
tag: "ul",
|
|
"wrap-class": _ctx.nsSelect.be("dropdown", "wrap"),
|
|
"view-class": _ctx.nsSelect.be("dropdown", "list"),
|
|
class: normalizeClass([_ctx.nsSelect.is("empty", _ctx.filteredOptionsCount === 0)]),
|
|
role: "listbox",
|
|
"aria-label": _ctx.ariaLabel,
|
|
"aria-orientation": "vertical",
|
|
onScroll: _ctx.popupScroll
|
|
}, {
|
|
default: withCtx(() => [
|
|
_ctx.showNewOption ? (openBlock(), createBlock(_component_el_option, {
|
|
key: 0,
|
|
value: _ctx.states.inputValue,
|
|
created: true
|
|
}, null, 8, ["value"])) : createCommentVNode("v-if", true),
|
|
createVNode(_component_el_options, null, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
})
|
|
]),
|
|
_: 3
|
|
}, 8, ["id", "wrap-class", "view-class", "class", "aria-label", "onScroll"]), [
|
|
[vShow, _ctx.states.options.size > 0 && !_ctx.loading]
|
|
]),
|
|
_ctx.$slots.loading && _ctx.loading ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(_ctx.nsSelect.be("dropdown", "loading"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "loading")
|
|
], 2)) : _ctx.loading || _ctx.filteredOptionsCount === 0 ? (openBlock(), createElementBlock("div", {
|
|
key: 2,
|
|
class: normalizeClass(_ctx.nsSelect.be("dropdown", "empty"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "empty", {}, () => [
|
|
createBaseVNode("span", null, toDisplayString(_ctx.emptyText), 1)
|
|
])
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
_ctx.$slots.footer ? (openBlock(), createElementBlock("div", {
|
|
key: 3,
|
|
class: normalizeClass(_ctx.nsSelect.be("dropdown", "footer")),
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "footer")
|
|
], 10, ["onClick"])) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 512)
|
|
]),
|
|
_: 3
|
|
}, 8, ["visible", "placement", "teleported", "popper-class", "popper-options", "fallback-placements", "effect", "transition", "persistent", "append-to", "show-arrow", "offset", "onBeforeShow", "onHide"])
|
|
], 16, ["onMouseleave"])), [
|
|
[_directive_click_outside, _ctx.handleClickOutside, _ctx.popperRef]
|
|
]);
|
|
}
|
|
var Select = _export_sfc(_sfc_main98, [["render", _sfc_render19], ["__file", "select.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/select/src/option-group.mjs
|
|
var _sfc_main99 = defineComponent({
|
|
name: "ElOptionGroup",
|
|
componentName: "ElOptionGroup",
|
|
props: {
|
|
label: String,
|
|
disabled: Boolean
|
|
},
|
|
setup(props2) {
|
|
const ns = useNamespace("select");
|
|
const groupRef = ref();
|
|
const instance = getCurrentInstance();
|
|
const children = ref([]);
|
|
provide(selectGroupKey, reactive({
|
|
...toRefs(props2)
|
|
}));
|
|
const visible = computed(() => children.value.some((option) => option.visible === true));
|
|
const isOption = (node) => {
|
|
var _a2;
|
|
return node.type.name === "ElOption" && !!((_a2 = node.component) == null ? void 0 : _a2.proxy);
|
|
};
|
|
const flattedChildren2 = (node) => {
|
|
const nodes = castArray_default(node);
|
|
const children2 = [];
|
|
nodes.forEach((child) => {
|
|
var _a2;
|
|
if (!isVNode(child))
|
|
return;
|
|
if (isOption(child)) {
|
|
children2.push(child.component.proxy);
|
|
} else if (isArray(child.children) && child.children.length) {
|
|
children2.push(...flattedChildren2(child.children));
|
|
} else if ((_a2 = child.component) == null ? void 0 : _a2.subTree) {
|
|
children2.push(...flattedChildren2(child.component.subTree));
|
|
}
|
|
});
|
|
return children2;
|
|
};
|
|
const updateChildren = () => {
|
|
children.value = flattedChildren2(instance.subTree);
|
|
};
|
|
onMounted(() => {
|
|
updateChildren();
|
|
});
|
|
useMutationObserver(groupRef, updateChildren, {
|
|
attributes: true,
|
|
subtree: true,
|
|
childList: true
|
|
});
|
|
return {
|
|
groupRef,
|
|
visible,
|
|
ns
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render20(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return withDirectives((openBlock(), createElementBlock("ul", {
|
|
ref: "groupRef",
|
|
class: normalizeClass(_ctx.ns.be("group", "wrap"))
|
|
}, [
|
|
createBaseVNode("li", {
|
|
class: normalizeClass(_ctx.ns.be("group", "title"))
|
|
}, toDisplayString(_ctx.label), 3),
|
|
createBaseVNode("li", null, [
|
|
createBaseVNode("ul", {
|
|
class: normalizeClass(_ctx.ns.b("group"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2)
|
|
])
|
|
], 2)), [
|
|
[vShow, _ctx.visible]
|
|
]);
|
|
}
|
|
var OptionGroup = _export_sfc(_sfc_main99, [["render", _sfc_render20], ["__file", "option-group.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/select/index.mjs
|
|
var ElSelect = withInstall(Select, {
|
|
Option,
|
|
OptionGroup
|
|
});
|
|
var ElOption = withNoopInstall(Option);
|
|
var ElOptionGroup = withNoopInstall(OptionGroup);
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/prev2.mjs
|
|
var paginationPrevProps = buildProps({
|
|
disabled: Boolean,
|
|
currentPage: {
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
prevText: {
|
|
type: String
|
|
},
|
|
prevIcon: {
|
|
type: iconPropType
|
|
}
|
|
});
|
|
var paginationPrevEmits = {
|
|
click: (evt) => evt instanceof MouseEvent
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/prev.mjs
|
|
var __default__69 = defineComponent({
|
|
name: "ElPaginationPrev"
|
|
});
|
|
var _sfc_main100 = defineComponent({
|
|
...__default__69,
|
|
props: paginationPrevProps,
|
|
emits: paginationPrevEmits,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const { t } = useLocale();
|
|
const internalDisabled = computed(() => props2.disabled || props2.currentPage <= 1);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("button", {
|
|
type: "button",
|
|
class: "btn-prev",
|
|
disabled: unref(internalDisabled),
|
|
"aria-label": _ctx.prevText || unref(t)("el.pagination.prev"),
|
|
"aria-disabled": unref(internalDisabled),
|
|
onClick: ($event) => _ctx.$emit("click", $event)
|
|
}, [
|
|
_ctx.prevText ? (openBlock(), createElementBlock("span", { key: 0 }, toDisplayString(_ctx.prevText), 1)) : (openBlock(), createBlock(unref(ElIcon), { key: 1 }, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.prevIcon)))
|
|
]),
|
|
_: 1
|
|
}))
|
|
], 8, ["disabled", "aria-label", "aria-disabled", "onClick"]);
|
|
};
|
|
}
|
|
});
|
|
var Prev = _export_sfc(_sfc_main100, [["__file", "prev.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/next.mjs
|
|
var paginationNextProps = buildProps({
|
|
disabled: Boolean,
|
|
currentPage: {
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
pageCount: {
|
|
type: Number,
|
|
default: 50
|
|
},
|
|
nextText: {
|
|
type: String
|
|
},
|
|
nextIcon: {
|
|
type: iconPropType
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/next2.mjs
|
|
var __default__70 = defineComponent({
|
|
name: "ElPaginationNext"
|
|
});
|
|
var _sfc_main101 = defineComponent({
|
|
...__default__70,
|
|
props: paginationNextProps,
|
|
emits: ["click"],
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const { t } = useLocale();
|
|
const internalDisabled = computed(() => props2.disabled || props2.currentPage === props2.pageCount || props2.pageCount === 0);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("button", {
|
|
type: "button",
|
|
class: "btn-next",
|
|
disabled: unref(internalDisabled),
|
|
"aria-label": _ctx.nextText || unref(t)("el.pagination.next"),
|
|
"aria-disabled": unref(internalDisabled),
|
|
onClick: ($event) => _ctx.$emit("click", $event)
|
|
}, [
|
|
_ctx.nextText ? (openBlock(), createElementBlock("span", { key: 0 }, toDisplayString(_ctx.nextText), 1)) : (openBlock(), createBlock(unref(ElIcon), { key: 1 }, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.nextIcon)))
|
|
]),
|
|
_: 1
|
|
}))
|
|
], 8, ["disabled", "aria-label", "aria-disabled", "onClick"]);
|
|
};
|
|
}
|
|
});
|
|
var Next = _export_sfc(_sfc_main101, [["__file", "next.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/usePagination.mjs
|
|
var usePagination = () => inject(elPaginationKey, {});
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/sizes.mjs
|
|
var paginationSizesProps = buildProps({
|
|
pageSize: {
|
|
type: Number,
|
|
required: true
|
|
},
|
|
pageSizes: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([10, 20, 30, 40, 50, 100])
|
|
},
|
|
popperClass: {
|
|
type: String
|
|
},
|
|
disabled: Boolean,
|
|
teleported: Boolean,
|
|
size: {
|
|
type: String,
|
|
values: componentSizes
|
|
},
|
|
appendSizeTo: String
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/sizes2.mjs
|
|
var __default__71 = defineComponent({
|
|
name: "ElPaginationSizes"
|
|
});
|
|
var _sfc_main102 = defineComponent({
|
|
...__default__71,
|
|
props: paginationSizesProps,
|
|
emits: ["page-size-change"],
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("pagination");
|
|
const pagination = usePagination();
|
|
const innerPageSize = ref(props2.pageSize);
|
|
watch(() => props2.pageSizes, (newVal, oldVal) => {
|
|
if (isEqual_default(newVal, oldVal))
|
|
return;
|
|
if (isArray(newVal)) {
|
|
const pageSize = newVal.includes(props2.pageSize) ? props2.pageSize : props2.pageSizes[0];
|
|
emit("page-size-change", pageSize);
|
|
}
|
|
});
|
|
watch(() => props2.pageSize, (newVal) => {
|
|
innerPageSize.value = newVal;
|
|
});
|
|
const innerPageSizes = computed(() => props2.pageSizes);
|
|
function handleChange(val) {
|
|
var _a2;
|
|
if (val !== innerPageSize.value) {
|
|
innerPageSize.value = val;
|
|
(_a2 = pagination.handleSizeChange) == null ? void 0 : _a2.call(pagination, Number(val));
|
|
}
|
|
}
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("span", {
|
|
class: normalizeClass(unref(ns).e("sizes"))
|
|
}, [
|
|
createVNode(unref(ElSelect), {
|
|
"model-value": innerPageSize.value,
|
|
disabled: _ctx.disabled,
|
|
"popper-class": _ctx.popperClass,
|
|
size: _ctx.size,
|
|
teleported: _ctx.teleported,
|
|
"validate-event": false,
|
|
"append-to": _ctx.appendSizeTo,
|
|
onChange: handleChange
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(innerPageSizes), (item) => {
|
|
return openBlock(), createBlock(unref(ElOption), {
|
|
key: item,
|
|
value: item,
|
|
label: item + unref(t)("el.pagination.pagesize")
|
|
}, null, 8, ["value", "label"]);
|
|
}), 128))
|
|
]),
|
|
_: 1
|
|
}, 8, ["model-value", "disabled", "popper-class", "size", "teleported", "append-to"])
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Sizes = _export_sfc(_sfc_main102, [["__file", "sizes.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/jumper.mjs
|
|
var paginationJumperProps = buildProps({
|
|
size: {
|
|
type: String,
|
|
values: componentSizes
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/jumper2.mjs
|
|
var __default__72 = defineComponent({
|
|
name: "ElPaginationJumper"
|
|
});
|
|
var _sfc_main103 = defineComponent({
|
|
...__default__72,
|
|
props: paginationJumperProps,
|
|
setup(__props) {
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("pagination");
|
|
const { pageCount, disabled, currentPage, changeEvent } = usePagination();
|
|
const userInput = ref();
|
|
const innerValue = computed(() => {
|
|
var _a2;
|
|
return (_a2 = userInput.value) != null ? _a2 : currentPage == null ? void 0 : currentPage.value;
|
|
});
|
|
function handleInput(val) {
|
|
userInput.value = val ? +val : "";
|
|
}
|
|
function handleChange(val) {
|
|
val = Math.trunc(+val);
|
|
changeEvent == null ? void 0 : changeEvent(val);
|
|
userInput.value = void 0;
|
|
}
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("span", {
|
|
class: normalizeClass(unref(ns).e("jump")),
|
|
disabled: unref(disabled)
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass([unref(ns).e("goto")])
|
|
}, toDisplayString(unref(t)("el.pagination.goto")), 3),
|
|
createVNode(unref(ElInput), {
|
|
size: _ctx.size,
|
|
class: normalizeClass([unref(ns).e("editor"), unref(ns).is("in-pagination")]),
|
|
min: 1,
|
|
max: unref(pageCount),
|
|
disabled: unref(disabled),
|
|
"model-value": unref(innerValue),
|
|
"validate-event": false,
|
|
"aria-label": unref(t)("el.pagination.page"),
|
|
type: "number",
|
|
"onUpdate:modelValue": handleInput,
|
|
onChange: handleChange
|
|
}, null, 8, ["size", "class", "max", "disabled", "model-value", "aria-label"]),
|
|
createBaseVNode("span", {
|
|
class: normalizeClass([unref(ns).e("classifier")])
|
|
}, toDisplayString(unref(t)("el.pagination.pageClassifier")), 3)
|
|
], 10, ["disabled"]);
|
|
};
|
|
}
|
|
});
|
|
var Jumper = _export_sfc(_sfc_main103, [["__file", "jumper.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/total.mjs
|
|
var paginationTotalProps = buildProps({
|
|
total: {
|
|
type: Number,
|
|
default: 1e3
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/total2.mjs
|
|
var __default__73 = defineComponent({
|
|
name: "ElPaginationTotal"
|
|
});
|
|
var _sfc_main104 = defineComponent({
|
|
...__default__73,
|
|
props: paginationTotalProps,
|
|
setup(__props) {
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("pagination");
|
|
const { disabled } = usePagination();
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("span", {
|
|
class: normalizeClass(unref(ns).e("total")),
|
|
disabled: unref(disabled)
|
|
}, toDisplayString(unref(t)("el.pagination.total", {
|
|
total: _ctx.total
|
|
})), 11, ["disabled"]);
|
|
};
|
|
}
|
|
});
|
|
var Total = _export_sfc(_sfc_main104, [["__file", "total.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/pager.mjs
|
|
var paginationPagerProps = buildProps({
|
|
currentPage: {
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
pageCount: {
|
|
type: Number,
|
|
required: true
|
|
},
|
|
pagerCount: {
|
|
type: Number,
|
|
default: 7
|
|
},
|
|
disabled: Boolean
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/pager2.mjs
|
|
var __default__74 = defineComponent({
|
|
name: "ElPaginationPager"
|
|
});
|
|
var _sfc_main105 = defineComponent({
|
|
...__default__74,
|
|
props: paginationPagerProps,
|
|
emits: [CHANGE_EVENT],
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const nsPager = useNamespace("pager");
|
|
const nsIcon = useNamespace("icon");
|
|
const { t } = useLocale();
|
|
const showPrevMore = ref(false);
|
|
const showNextMore = ref(false);
|
|
const quickPrevHover = ref(false);
|
|
const quickNextHover = ref(false);
|
|
const quickPrevFocus = ref(false);
|
|
const quickNextFocus = ref(false);
|
|
const pagers = computed(() => {
|
|
const pagerCount = props2.pagerCount;
|
|
const halfPagerCount = (pagerCount - 1) / 2;
|
|
const currentPage = Number(props2.currentPage);
|
|
const pageCount = Number(props2.pageCount);
|
|
let showPrevMore2 = false;
|
|
let showNextMore2 = false;
|
|
if (pageCount > pagerCount) {
|
|
if (currentPage > pagerCount - halfPagerCount) {
|
|
showPrevMore2 = true;
|
|
}
|
|
if (currentPage < pageCount - halfPagerCount) {
|
|
showNextMore2 = true;
|
|
}
|
|
}
|
|
const array4 = [];
|
|
if (showPrevMore2 && !showNextMore2) {
|
|
const startPage = pageCount - (pagerCount - 2);
|
|
for (let i = startPage; i < pageCount; i++) {
|
|
array4.push(i);
|
|
}
|
|
} else if (!showPrevMore2 && showNextMore2) {
|
|
for (let i = 2; i < pagerCount; i++) {
|
|
array4.push(i);
|
|
}
|
|
} else if (showPrevMore2 && showNextMore2) {
|
|
const offset3 = Math.floor(pagerCount / 2) - 1;
|
|
for (let i = currentPage - offset3; i <= currentPage + offset3; i++) {
|
|
array4.push(i);
|
|
}
|
|
} else {
|
|
for (let i = 2; i < pageCount; i++) {
|
|
array4.push(i);
|
|
}
|
|
}
|
|
return array4;
|
|
});
|
|
const prevMoreKls = computed(() => [
|
|
"more",
|
|
"btn-quickprev",
|
|
nsIcon.b(),
|
|
nsPager.is("disabled", props2.disabled)
|
|
]);
|
|
const nextMoreKls = computed(() => [
|
|
"more",
|
|
"btn-quicknext",
|
|
nsIcon.b(),
|
|
nsPager.is("disabled", props2.disabled)
|
|
]);
|
|
const tabindex = computed(() => props2.disabled ? -1 : 0);
|
|
watchEffect(() => {
|
|
const halfPagerCount = (props2.pagerCount - 1) / 2;
|
|
showPrevMore.value = false;
|
|
showNextMore.value = false;
|
|
if (props2.pageCount > props2.pagerCount) {
|
|
if (props2.currentPage > props2.pagerCount - halfPagerCount) {
|
|
showPrevMore.value = true;
|
|
}
|
|
if (props2.currentPage < props2.pageCount - halfPagerCount) {
|
|
showNextMore.value = true;
|
|
}
|
|
}
|
|
});
|
|
function onMouseEnter(forward = false) {
|
|
if (props2.disabled)
|
|
return;
|
|
if (forward) {
|
|
quickPrevHover.value = true;
|
|
} else {
|
|
quickNextHover.value = true;
|
|
}
|
|
}
|
|
function onFocus(forward = false) {
|
|
if (forward) {
|
|
quickPrevFocus.value = true;
|
|
} else {
|
|
quickNextFocus.value = true;
|
|
}
|
|
}
|
|
function onEnter(e) {
|
|
const target2 = e.target;
|
|
if (target2.tagName.toLowerCase() === "li" && Array.from(target2.classList).includes("number")) {
|
|
const newPage = Number(target2.textContent);
|
|
if (newPage !== props2.currentPage) {
|
|
emit(CHANGE_EVENT, newPage);
|
|
}
|
|
} else if (target2.tagName.toLowerCase() === "li" && Array.from(target2.classList).includes("more")) {
|
|
onPagerClick(e);
|
|
}
|
|
}
|
|
function onPagerClick(event) {
|
|
const target2 = event.target;
|
|
if (target2.tagName.toLowerCase() === "ul" || props2.disabled) {
|
|
return;
|
|
}
|
|
let newPage = Number(target2.textContent);
|
|
const pageCount = props2.pageCount;
|
|
const currentPage = props2.currentPage;
|
|
const pagerCountOffset = props2.pagerCount - 2;
|
|
if (target2.className.includes("more")) {
|
|
if (target2.className.includes("quickprev")) {
|
|
newPage = currentPage - pagerCountOffset;
|
|
} else if (target2.className.includes("quicknext")) {
|
|
newPage = currentPage + pagerCountOffset;
|
|
}
|
|
}
|
|
if (!Number.isNaN(+newPage)) {
|
|
if (newPage < 1) {
|
|
newPage = 1;
|
|
}
|
|
if (newPage > pageCount) {
|
|
newPage = pageCount;
|
|
}
|
|
}
|
|
if (newPage !== currentPage) {
|
|
emit(CHANGE_EVENT, newPage);
|
|
}
|
|
}
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("ul", {
|
|
class: normalizeClass(unref(nsPager).b()),
|
|
onClick: onPagerClick,
|
|
onKeyup: withKeys(onEnter, ["enter"])
|
|
}, [
|
|
_ctx.pageCount > 0 ? (openBlock(), createElementBlock("li", {
|
|
key: 0,
|
|
class: normalizeClass([[
|
|
unref(nsPager).is("active", _ctx.currentPage === 1),
|
|
unref(nsPager).is("disabled", _ctx.disabled)
|
|
], "number"]),
|
|
"aria-current": _ctx.currentPage === 1,
|
|
"aria-label": unref(t)("el.pagination.currentPage", { pager: 1 }),
|
|
tabindex: unref(tabindex)
|
|
}, " 1 ", 10, ["aria-current", "aria-label", "tabindex"])) : createCommentVNode("v-if", true),
|
|
showPrevMore.value ? (openBlock(), createElementBlock("li", {
|
|
key: 1,
|
|
class: normalizeClass(unref(prevMoreKls)),
|
|
tabindex: unref(tabindex),
|
|
"aria-label": unref(t)("el.pagination.prevPages", { pager: _ctx.pagerCount - 2 }),
|
|
onMouseenter: ($event) => onMouseEnter(true),
|
|
onMouseleave: ($event) => quickPrevHover.value = false,
|
|
onFocus: ($event) => onFocus(true),
|
|
onBlur: ($event) => quickPrevFocus.value = false
|
|
}, [
|
|
(quickPrevHover.value || quickPrevFocus.value) && !_ctx.disabled ? (openBlock(), createBlock(unref(d_arrow_left_default), { key: 0 })) : (openBlock(), createBlock(unref(more_filled_default), { key: 1 }))
|
|
], 42, ["tabindex", "aria-label", "onMouseenter", "onMouseleave", "onFocus", "onBlur"])) : createCommentVNode("v-if", true),
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(pagers), (pager) => {
|
|
return openBlock(), createElementBlock("li", {
|
|
key: pager,
|
|
class: normalizeClass([[
|
|
unref(nsPager).is("active", _ctx.currentPage === pager),
|
|
unref(nsPager).is("disabled", _ctx.disabled)
|
|
], "number"]),
|
|
"aria-current": _ctx.currentPage === pager,
|
|
"aria-label": unref(t)("el.pagination.currentPage", { pager }),
|
|
tabindex: unref(tabindex)
|
|
}, toDisplayString(pager), 11, ["aria-current", "aria-label", "tabindex"]);
|
|
}), 128)),
|
|
showNextMore.value ? (openBlock(), createElementBlock("li", {
|
|
key: 2,
|
|
class: normalizeClass(unref(nextMoreKls)),
|
|
tabindex: unref(tabindex),
|
|
"aria-label": unref(t)("el.pagination.nextPages", { pager: _ctx.pagerCount - 2 }),
|
|
onMouseenter: ($event) => onMouseEnter(),
|
|
onMouseleave: ($event) => quickNextHover.value = false,
|
|
onFocus: ($event) => onFocus(),
|
|
onBlur: ($event) => quickNextFocus.value = false
|
|
}, [
|
|
(quickNextHover.value || quickNextFocus.value) && !_ctx.disabled ? (openBlock(), createBlock(unref(d_arrow_right_default), { key: 0 })) : (openBlock(), createBlock(unref(more_filled_default), { key: 1 }))
|
|
], 42, ["tabindex", "aria-label", "onMouseenter", "onMouseleave", "onFocus", "onBlur"])) : createCommentVNode("v-if", true),
|
|
_ctx.pageCount > 1 ? (openBlock(), createElementBlock("li", {
|
|
key: 3,
|
|
class: normalizeClass([[
|
|
unref(nsPager).is("active", _ctx.currentPage === _ctx.pageCount),
|
|
unref(nsPager).is("disabled", _ctx.disabled)
|
|
], "number"]),
|
|
"aria-current": _ctx.currentPage === _ctx.pageCount,
|
|
"aria-label": unref(t)("el.pagination.currentPage", { pager: _ctx.pageCount }),
|
|
tabindex: unref(tabindex)
|
|
}, toDisplayString(_ctx.pageCount), 11, ["aria-current", "aria-label", "tabindex"])) : createCommentVNode("v-if", true)
|
|
], 42, ["onKeyup"]);
|
|
};
|
|
}
|
|
});
|
|
var Pager = _export_sfc(_sfc_main105, [["__file", "pager.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/pagination.mjs
|
|
var isAbsent = (v2) => typeof v2 !== "number";
|
|
var paginationProps = buildProps({
|
|
pageSize: Number,
|
|
defaultPageSize: Number,
|
|
total: Number,
|
|
pageCount: Number,
|
|
pagerCount: {
|
|
type: Number,
|
|
validator: (value) => {
|
|
return isNumber2(value) && Math.trunc(value) === value && value > 4 && value < 22 && value % 2 === 1;
|
|
},
|
|
default: 7
|
|
},
|
|
currentPage: Number,
|
|
defaultCurrentPage: Number,
|
|
layout: {
|
|
type: String,
|
|
default: ["prev", "pager", "next", "jumper", "->", "total"].join(", ")
|
|
},
|
|
pageSizes: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([10, 20, 30, 40, 50, 100])
|
|
},
|
|
popperClass: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
prevText: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
prevIcon: {
|
|
type: iconPropType,
|
|
default: () => arrow_left_default
|
|
},
|
|
nextText: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
nextIcon: {
|
|
type: iconPropType,
|
|
default: () => arrow_right_default
|
|
},
|
|
teleported: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
small: Boolean,
|
|
size: useSizeProp,
|
|
background: Boolean,
|
|
disabled: Boolean,
|
|
hideOnSinglePage: Boolean,
|
|
appendSizeTo: String
|
|
});
|
|
var paginationEmits = {
|
|
"update:current-page": (val) => isNumber2(val),
|
|
"update:page-size": (val) => isNumber2(val),
|
|
"size-change": (val) => isNumber2(val),
|
|
change: (currentPage, pageSize) => isNumber2(currentPage) && isNumber2(pageSize),
|
|
"current-change": (val) => isNumber2(val),
|
|
"prev-click": (val) => isNumber2(val),
|
|
"next-click": (val) => isNumber2(val)
|
|
};
|
|
var componentName = "ElPagination";
|
|
var Pagination = defineComponent({
|
|
name: componentName,
|
|
props: paginationProps,
|
|
emits: paginationEmits,
|
|
setup(props2, { emit, slots }) {
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("pagination");
|
|
const vnodeProps = getCurrentInstance().vnode.props || {};
|
|
const _globalSize = useGlobalSize();
|
|
const _size = computed(() => {
|
|
var _a2;
|
|
return props2.small ? "small" : (_a2 = props2.size) != null ? _a2 : _globalSize.value;
|
|
});
|
|
useDeprecated({
|
|
from: "small",
|
|
replacement: "size",
|
|
version: "3.0.0",
|
|
scope: "el-pagination",
|
|
ref: "https://element-plus.org/zh-CN/component/pagination.html"
|
|
}, computed(() => !!props2.small));
|
|
const hasCurrentPageListener = "onUpdate:currentPage" in vnodeProps || "onUpdate:current-page" in vnodeProps || "onCurrentChange" in vnodeProps;
|
|
const hasPageSizeListener = "onUpdate:pageSize" in vnodeProps || "onUpdate:page-size" in vnodeProps || "onSizeChange" in vnodeProps;
|
|
const assertValidUsage = computed(() => {
|
|
if (isAbsent(props2.total) && isAbsent(props2.pageCount))
|
|
return false;
|
|
if (!isAbsent(props2.currentPage) && !hasCurrentPageListener)
|
|
return false;
|
|
if (props2.layout.includes("sizes")) {
|
|
if (!isAbsent(props2.pageCount)) {
|
|
if (!hasPageSizeListener)
|
|
return false;
|
|
} else if (!isAbsent(props2.total)) {
|
|
if (!isAbsent(props2.pageSize)) {
|
|
if (!hasPageSizeListener) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
});
|
|
const innerPageSize = ref(isAbsent(props2.defaultPageSize) ? 10 : props2.defaultPageSize);
|
|
const innerCurrentPage = ref(isAbsent(props2.defaultCurrentPage) ? 1 : props2.defaultCurrentPage);
|
|
const pageSizeBridge = computed({
|
|
get() {
|
|
return isAbsent(props2.pageSize) ? innerPageSize.value : props2.pageSize;
|
|
},
|
|
set(v2) {
|
|
if (isAbsent(props2.pageSize)) {
|
|
innerPageSize.value = v2;
|
|
}
|
|
if (hasPageSizeListener) {
|
|
emit("update:page-size", v2);
|
|
emit("size-change", v2);
|
|
}
|
|
}
|
|
});
|
|
const pageCountBridge = computed(() => {
|
|
let pageCount = 0;
|
|
if (!isAbsent(props2.pageCount)) {
|
|
pageCount = props2.pageCount;
|
|
} else if (!isAbsent(props2.total)) {
|
|
pageCount = Math.max(1, Math.ceil(props2.total / pageSizeBridge.value));
|
|
}
|
|
return pageCount;
|
|
});
|
|
const currentPageBridge = computed({
|
|
get() {
|
|
return isAbsent(props2.currentPage) ? innerCurrentPage.value : props2.currentPage;
|
|
},
|
|
set(v2) {
|
|
let newCurrentPage = v2;
|
|
if (v2 < 1) {
|
|
newCurrentPage = 1;
|
|
} else if (v2 > pageCountBridge.value) {
|
|
newCurrentPage = pageCountBridge.value;
|
|
}
|
|
if (isAbsent(props2.currentPage)) {
|
|
innerCurrentPage.value = newCurrentPage;
|
|
}
|
|
if (hasCurrentPageListener) {
|
|
emit("update:current-page", newCurrentPage);
|
|
emit("current-change", newCurrentPage);
|
|
}
|
|
}
|
|
});
|
|
watch(pageCountBridge, (val) => {
|
|
if (currentPageBridge.value > val)
|
|
currentPageBridge.value = val;
|
|
});
|
|
watch([currentPageBridge, pageSizeBridge], (value) => {
|
|
emit(CHANGE_EVENT, ...value);
|
|
}, { flush: "post" });
|
|
function handleCurrentChange2(val) {
|
|
currentPageBridge.value = val;
|
|
}
|
|
function handleSizeChange(val) {
|
|
pageSizeBridge.value = val;
|
|
const newPageCount = pageCountBridge.value;
|
|
if (currentPageBridge.value > newPageCount) {
|
|
currentPageBridge.value = newPageCount;
|
|
}
|
|
}
|
|
function prev() {
|
|
if (props2.disabled)
|
|
return;
|
|
currentPageBridge.value -= 1;
|
|
emit("prev-click", currentPageBridge.value);
|
|
}
|
|
function next() {
|
|
if (props2.disabled)
|
|
return;
|
|
currentPageBridge.value += 1;
|
|
emit("next-click", currentPageBridge.value);
|
|
}
|
|
function addClass2(element, cls) {
|
|
if (element) {
|
|
if (!element.props) {
|
|
element.props = {};
|
|
}
|
|
element.props.class = [element.props.class, cls].join(" ");
|
|
}
|
|
}
|
|
provide(elPaginationKey, {
|
|
pageCount: pageCountBridge,
|
|
disabled: computed(() => props2.disabled),
|
|
currentPage: currentPageBridge,
|
|
changeEvent: handleCurrentChange2,
|
|
handleSizeChange
|
|
});
|
|
return () => {
|
|
var _a2, _b;
|
|
if (!assertValidUsage.value) {
|
|
debugWarn(componentName, t("el.pagination.deprecationWarning"));
|
|
return null;
|
|
}
|
|
if (!props2.layout)
|
|
return null;
|
|
if (props2.hideOnSinglePage && pageCountBridge.value <= 1)
|
|
return null;
|
|
const rootChildren = [];
|
|
const rightWrapperChildren = [];
|
|
const rightWrapperRoot = h("div", { class: ns.e("rightwrapper") }, rightWrapperChildren);
|
|
const TEMPLATE_MAP = {
|
|
prev: h(Prev, {
|
|
disabled: props2.disabled,
|
|
currentPage: currentPageBridge.value,
|
|
prevText: props2.prevText,
|
|
prevIcon: props2.prevIcon,
|
|
onClick: prev
|
|
}),
|
|
jumper: h(Jumper, {
|
|
size: _size.value
|
|
}),
|
|
pager: h(Pager, {
|
|
currentPage: currentPageBridge.value,
|
|
pageCount: pageCountBridge.value,
|
|
pagerCount: props2.pagerCount,
|
|
onChange: handleCurrentChange2,
|
|
disabled: props2.disabled
|
|
}),
|
|
next: h(Next, {
|
|
disabled: props2.disabled,
|
|
currentPage: currentPageBridge.value,
|
|
pageCount: pageCountBridge.value,
|
|
nextText: props2.nextText,
|
|
nextIcon: props2.nextIcon,
|
|
onClick: next
|
|
}),
|
|
sizes: h(Sizes, {
|
|
pageSize: pageSizeBridge.value,
|
|
pageSizes: props2.pageSizes,
|
|
popperClass: props2.popperClass,
|
|
disabled: props2.disabled,
|
|
teleported: props2.teleported,
|
|
size: _size.value,
|
|
appendSizeTo: props2.appendSizeTo
|
|
}),
|
|
slot: (_b = (_a2 = slots == null ? void 0 : slots.default) == null ? void 0 : _a2.call(slots)) != null ? _b : null,
|
|
total: h(Total, { total: isAbsent(props2.total) ? 0 : props2.total })
|
|
};
|
|
const components = props2.layout.split(",").map((item) => item.trim());
|
|
let haveRightWrapper = false;
|
|
components.forEach((c2) => {
|
|
if (c2 === "->") {
|
|
haveRightWrapper = true;
|
|
return;
|
|
}
|
|
if (!haveRightWrapper) {
|
|
rootChildren.push(TEMPLATE_MAP[c2]);
|
|
} else {
|
|
rightWrapperChildren.push(TEMPLATE_MAP[c2]);
|
|
}
|
|
});
|
|
addClass2(rootChildren[0], ns.is("first"));
|
|
addClass2(rootChildren[rootChildren.length - 1], ns.is("last"));
|
|
if (haveRightWrapper && rightWrapperChildren.length > 0) {
|
|
addClass2(rightWrapperChildren[0], ns.is("first"));
|
|
addClass2(rightWrapperChildren[rightWrapperChildren.length - 1], ns.is("last"));
|
|
rootChildren.push(rightWrapperRoot);
|
|
}
|
|
return h("div", {
|
|
class: [
|
|
ns.b(),
|
|
ns.is("background", props2.background),
|
|
ns.m(_size.value)
|
|
]
|
|
}, rootChildren);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/pagination/index.mjs
|
|
var ElPagination = withInstall(Pagination);
|
|
|
|
// node_modules/element-plus/es/components/popconfirm/src/popconfirm2.mjs
|
|
var popconfirmProps = buildProps({
|
|
title: String,
|
|
confirmButtonText: String,
|
|
cancelButtonText: String,
|
|
confirmButtonType: {
|
|
type: String,
|
|
values: buttonTypes,
|
|
default: "primary"
|
|
},
|
|
cancelButtonType: {
|
|
type: String,
|
|
values: buttonTypes,
|
|
default: "text"
|
|
},
|
|
icon: {
|
|
type: iconPropType,
|
|
default: () => question_filled_default
|
|
},
|
|
iconColor: {
|
|
type: String,
|
|
default: "#f90"
|
|
},
|
|
hideIcon: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
hideAfter: {
|
|
type: Number,
|
|
default: 200
|
|
},
|
|
teleported: useTooltipContentProps.teleported,
|
|
persistent: useTooltipContentProps.persistent,
|
|
width: {
|
|
type: [String, Number],
|
|
default: 150
|
|
}
|
|
});
|
|
var popconfirmEmits = {
|
|
confirm: (e) => e instanceof MouseEvent,
|
|
cancel: (e) => e instanceof MouseEvent
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/popconfirm/src/popconfirm.mjs
|
|
var __default__75 = defineComponent({
|
|
name: "ElPopconfirm"
|
|
});
|
|
var _sfc_main106 = defineComponent({
|
|
...__default__75,
|
|
props: popconfirmProps,
|
|
emits: popconfirmEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("popconfirm");
|
|
const tooltipRef = ref();
|
|
const hidePopper = () => {
|
|
var _a2, _b;
|
|
(_b = (_a2 = tooltipRef.value) == null ? void 0 : _a2.onClose) == null ? void 0 : _b.call(_a2);
|
|
};
|
|
const style = computed(() => {
|
|
return {
|
|
width: addUnit(props2.width)
|
|
};
|
|
});
|
|
const confirm = (e) => {
|
|
emit("confirm", e);
|
|
hidePopper();
|
|
};
|
|
const cancel = (e) => {
|
|
emit("cancel", e);
|
|
hidePopper();
|
|
};
|
|
const finalConfirmButtonText = computed(() => props2.confirmButtonText || t("el.popconfirm.confirmButtonText"));
|
|
const finalCancelButtonText = computed(() => props2.cancelButtonText || t("el.popconfirm.cancelButtonText"));
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElTooltip), mergeProps({
|
|
ref_key: "tooltipRef",
|
|
ref: tooltipRef,
|
|
trigger: "click",
|
|
effect: "light"
|
|
}, _ctx.$attrs, {
|
|
"popper-class": `${unref(ns).namespace.value}-popover`,
|
|
"popper-style": unref(style),
|
|
teleported: _ctx.teleported,
|
|
"fallback-placements": ["bottom", "top", "right", "left"],
|
|
"hide-after": _ctx.hideAfter,
|
|
persistent: _ctx.persistent
|
|
}), {
|
|
content: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).b())
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("main"))
|
|
}, [
|
|
!_ctx.hideIcon && _ctx.icon ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("icon")),
|
|
style: normalizeStyle({ color: _ctx.iconColor })
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "style"])) : createCommentVNode("v-if", true),
|
|
createTextVNode(" " + toDisplayString(_ctx.title), 1)
|
|
], 2),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("action"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "actions", {
|
|
confirm,
|
|
cancel
|
|
}, () => [
|
|
createVNode(unref(ElButton), {
|
|
size: "small",
|
|
type: _ctx.cancelButtonType === "text" ? "" : _ctx.cancelButtonType,
|
|
text: _ctx.cancelButtonType === "text",
|
|
onClick: cancel
|
|
}, {
|
|
default: withCtx(() => [
|
|
createTextVNode(toDisplayString(unref(finalCancelButtonText)), 1)
|
|
]),
|
|
_: 1
|
|
}, 8, ["type", "text"]),
|
|
createVNode(unref(ElButton), {
|
|
size: "small",
|
|
type: _ctx.confirmButtonType === "text" ? "" : _ctx.confirmButtonType,
|
|
text: _ctx.confirmButtonType === "text",
|
|
onClick: confirm
|
|
}, {
|
|
default: withCtx(() => [
|
|
createTextVNode(toDisplayString(unref(finalConfirmButtonText)), 1)
|
|
]),
|
|
_: 1
|
|
}, 8, ["type", "text"])
|
|
])
|
|
], 2)
|
|
], 2)
|
|
]),
|
|
default: withCtx(() => [
|
|
_ctx.$slots.reference ? renderSlot(_ctx.$slots, "reference", { key: 0 }) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 16, ["popper-class", "popper-style", "teleported", "hide-after", "persistent"]);
|
|
};
|
|
}
|
|
});
|
|
var Popconfirm = _export_sfc(_sfc_main106, [["__file", "popconfirm.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/popconfirm/index.mjs
|
|
var ElPopconfirm = withInstall(Popconfirm);
|
|
|
|
// node_modules/element-plus/es/components/popover/src/popover2.mjs
|
|
var popoverProps = buildProps({
|
|
trigger: useTooltipTriggerProps.trigger,
|
|
triggerKeys: useTooltipTriggerProps.triggerKeys,
|
|
placement: dropdownProps.placement,
|
|
disabled: useTooltipTriggerProps.disabled,
|
|
visible: useTooltipContentProps.visible,
|
|
transition: useTooltipContentProps.transition,
|
|
popperOptions: dropdownProps.popperOptions,
|
|
tabindex: dropdownProps.tabindex,
|
|
content: useTooltipContentProps.content,
|
|
popperStyle: useTooltipContentProps.popperStyle,
|
|
popperClass: useTooltipContentProps.popperClass,
|
|
enterable: {
|
|
...useTooltipContentProps.enterable,
|
|
default: true
|
|
},
|
|
effect: {
|
|
...useTooltipContentProps.effect,
|
|
default: "light"
|
|
},
|
|
teleported: useTooltipContentProps.teleported,
|
|
appendTo: useTooltipContentProps.appendTo,
|
|
title: String,
|
|
width: {
|
|
type: [String, Number],
|
|
default: 150
|
|
},
|
|
offset: {
|
|
type: Number,
|
|
default: void 0
|
|
},
|
|
showAfter: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
hideAfter: {
|
|
type: Number,
|
|
default: 200
|
|
},
|
|
autoClose: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
showArrow: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
persistent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
"onUpdate:visible": {
|
|
type: Function
|
|
}
|
|
});
|
|
var popoverEmits = {
|
|
"update:visible": (value) => isBoolean2(value),
|
|
"before-enter": () => true,
|
|
"before-leave": () => true,
|
|
"after-enter": () => true,
|
|
"after-leave": () => true
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/popover/src/popover.mjs
|
|
var updateEventKeyRaw = `onUpdate:visible`;
|
|
var __default__76 = defineComponent({
|
|
name: "ElPopover"
|
|
});
|
|
var _sfc_main107 = defineComponent({
|
|
...__default__76,
|
|
props: popoverProps,
|
|
emits: popoverEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const onUpdateVisible = computed(() => {
|
|
return props2[updateEventKeyRaw];
|
|
});
|
|
const ns = useNamespace("popover");
|
|
const tooltipRef = ref();
|
|
const popperRef = computed(() => {
|
|
var _a2;
|
|
return (_a2 = unref(tooltipRef)) == null ? void 0 : _a2.popperRef;
|
|
});
|
|
const style = computed(() => {
|
|
return [
|
|
{
|
|
width: addUnit(props2.width)
|
|
},
|
|
props2.popperStyle
|
|
];
|
|
});
|
|
const kls = computed(() => {
|
|
return [ns.b(), props2.popperClass, { [ns.m("plain")]: !!props2.content }];
|
|
});
|
|
const gpuAcceleration = computed(() => {
|
|
return props2.transition === `${ns.namespace.value}-fade-in-linear`;
|
|
});
|
|
const hide2 = () => {
|
|
var _a2;
|
|
(_a2 = tooltipRef.value) == null ? void 0 : _a2.hide();
|
|
};
|
|
const beforeEnter = () => {
|
|
emit("before-enter");
|
|
};
|
|
const beforeLeave = () => {
|
|
emit("before-leave");
|
|
};
|
|
const afterEnter = () => {
|
|
emit("after-enter");
|
|
};
|
|
const afterLeave = () => {
|
|
emit("update:visible", false);
|
|
emit("after-leave");
|
|
};
|
|
expose({
|
|
popperRef,
|
|
hide: hide2
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElTooltip), mergeProps({
|
|
ref_key: "tooltipRef",
|
|
ref: tooltipRef
|
|
}, _ctx.$attrs, {
|
|
trigger: _ctx.trigger,
|
|
"trigger-keys": _ctx.triggerKeys,
|
|
placement: _ctx.placement,
|
|
disabled: _ctx.disabled,
|
|
visible: _ctx.visible,
|
|
transition: _ctx.transition,
|
|
"popper-options": _ctx.popperOptions,
|
|
tabindex: _ctx.tabindex,
|
|
content: _ctx.content,
|
|
offset: _ctx.offset,
|
|
"show-after": _ctx.showAfter,
|
|
"hide-after": _ctx.hideAfter,
|
|
"auto-close": _ctx.autoClose,
|
|
"show-arrow": _ctx.showArrow,
|
|
"aria-label": _ctx.title,
|
|
effect: _ctx.effect,
|
|
enterable: _ctx.enterable,
|
|
"popper-class": unref(kls),
|
|
"popper-style": unref(style),
|
|
teleported: _ctx.teleported,
|
|
"append-to": _ctx.appendTo,
|
|
persistent: _ctx.persistent,
|
|
"gpu-acceleration": unref(gpuAcceleration),
|
|
"onUpdate:visible": unref(onUpdateVisible),
|
|
onBeforeShow: beforeEnter,
|
|
onBeforeHide: beforeLeave,
|
|
onShow: afterEnter,
|
|
onHide: afterLeave
|
|
}), {
|
|
content: withCtx(() => [
|
|
_ctx.title ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("title")),
|
|
role: "title"
|
|
}, toDisplayString(_ctx.title), 3)) : createCommentVNode("v-if", true),
|
|
renderSlot(_ctx.$slots, "default", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.content), 1)
|
|
])
|
|
]),
|
|
default: withCtx(() => [
|
|
_ctx.$slots.reference ? renderSlot(_ctx.$slots, "reference", { key: 0 }) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 16, ["trigger", "trigger-keys", "placement", "disabled", "visible", "transition", "popper-options", "tabindex", "content", "offset", "show-after", "hide-after", "auto-close", "show-arrow", "aria-label", "effect", "enterable", "popper-class", "popper-style", "teleported", "append-to", "persistent", "gpu-acceleration", "onUpdate:visible"]);
|
|
};
|
|
}
|
|
});
|
|
var Popover = _export_sfc(_sfc_main107, [["__file", "popover.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/popover/src/directive.mjs
|
|
var attachEvents = (el, binding) => {
|
|
const popperComponent = binding.arg || binding.value;
|
|
const popover = popperComponent == null ? void 0 : popperComponent.popperRef;
|
|
if (popover) {
|
|
popover.triggerRef = el;
|
|
}
|
|
};
|
|
var PopoverDirective = {
|
|
mounted(el, binding) {
|
|
attachEvents(el, binding);
|
|
},
|
|
updated(el, binding) {
|
|
attachEvents(el, binding);
|
|
}
|
|
};
|
|
var VPopover = "popover";
|
|
|
|
// node_modules/element-plus/es/components/popover/index.mjs
|
|
var ElPopoverDirective = withInstallDirective(PopoverDirective, VPopover);
|
|
var ElPopover = withInstall(Popover, {
|
|
directive: ElPopoverDirective
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/progress/src/progress.mjs
|
|
var progressProps = buildProps({
|
|
type: {
|
|
type: String,
|
|
default: "line",
|
|
values: ["line", "circle", "dashboard"]
|
|
},
|
|
percentage: {
|
|
type: Number,
|
|
default: 0,
|
|
validator: (val) => val >= 0 && val <= 100
|
|
},
|
|
status: {
|
|
type: String,
|
|
default: "",
|
|
values: ["", "success", "exception", "warning"]
|
|
},
|
|
indeterminate: Boolean,
|
|
duration: {
|
|
type: Number,
|
|
default: 3
|
|
},
|
|
strokeWidth: {
|
|
type: Number,
|
|
default: 6
|
|
},
|
|
strokeLinecap: {
|
|
type: definePropType(String),
|
|
default: "round"
|
|
},
|
|
textInside: Boolean,
|
|
width: {
|
|
type: Number,
|
|
default: 126
|
|
},
|
|
showText: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
color: {
|
|
type: definePropType([
|
|
String,
|
|
Array,
|
|
Function
|
|
]),
|
|
default: ""
|
|
},
|
|
striped: Boolean,
|
|
stripedFlow: Boolean,
|
|
format: {
|
|
type: definePropType(Function),
|
|
default: (percentage) => `${percentage}%`
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/progress/src/progress2.mjs
|
|
var __default__77 = defineComponent({
|
|
name: "ElProgress"
|
|
});
|
|
var _sfc_main108 = defineComponent({
|
|
...__default__77,
|
|
props: progressProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const STATUS_COLOR_MAP = {
|
|
success: "#13ce66",
|
|
exception: "#ff4949",
|
|
warning: "#e6a23c",
|
|
default: "#20a0ff"
|
|
};
|
|
const ns = useNamespace("progress");
|
|
const barStyle = computed(() => {
|
|
const barStyle2 = {
|
|
width: `${props2.percentage}%`,
|
|
animationDuration: `${props2.duration}s`
|
|
};
|
|
const color = getCurrentColor(props2.percentage);
|
|
if (color.includes("gradient")) {
|
|
barStyle2.background = color;
|
|
} else {
|
|
barStyle2.backgroundColor = color;
|
|
}
|
|
return barStyle2;
|
|
});
|
|
const relativeStrokeWidth = computed(() => (props2.strokeWidth / props2.width * 100).toFixed(1));
|
|
const radius = computed(() => {
|
|
if (["circle", "dashboard"].includes(props2.type)) {
|
|
return Number.parseInt(`${50 - Number.parseFloat(relativeStrokeWidth.value) / 2}`, 10);
|
|
}
|
|
return 0;
|
|
});
|
|
const trackPath = computed(() => {
|
|
const r = radius.value;
|
|
const isDashboard = props2.type === "dashboard";
|
|
return `
|
|
M 50 50
|
|
m 0 ${isDashboard ? "" : "-"}${r}
|
|
a ${r} ${r} 0 1 1 0 ${isDashboard ? "-" : ""}${r * 2}
|
|
a ${r} ${r} 0 1 1 0 ${isDashboard ? "" : "-"}${r * 2}
|
|
`;
|
|
});
|
|
const perimeter = computed(() => 2 * Math.PI * radius.value);
|
|
const rate = computed(() => props2.type === "dashboard" ? 0.75 : 1);
|
|
const strokeDashoffset = computed(() => {
|
|
const offset3 = -1 * perimeter.value * (1 - rate.value) / 2;
|
|
return `${offset3}px`;
|
|
});
|
|
const trailPathStyle = computed(() => ({
|
|
strokeDasharray: `${perimeter.value * rate.value}px, ${perimeter.value}px`,
|
|
strokeDashoffset: strokeDashoffset.value
|
|
}));
|
|
const circlePathStyle = computed(() => ({
|
|
strokeDasharray: `${perimeter.value * rate.value * (props2.percentage / 100)}px, ${perimeter.value}px`,
|
|
strokeDashoffset: strokeDashoffset.value,
|
|
transition: "stroke-dasharray 0.6s ease 0s, stroke 0.6s ease, opacity ease 0.6s"
|
|
}));
|
|
const stroke = computed(() => {
|
|
let ret;
|
|
if (props2.color) {
|
|
ret = getCurrentColor(props2.percentage);
|
|
} else {
|
|
ret = STATUS_COLOR_MAP[props2.status] || STATUS_COLOR_MAP.default;
|
|
}
|
|
return ret;
|
|
});
|
|
const statusIcon = computed(() => {
|
|
if (props2.status === "warning") {
|
|
return warning_filled_default;
|
|
}
|
|
if (props2.type === "line") {
|
|
return props2.status === "success" ? circle_check_default : circle_close_default;
|
|
} else {
|
|
return props2.status === "success" ? check_default : close_default;
|
|
}
|
|
});
|
|
const progressTextSize = computed(() => {
|
|
return props2.type === "line" ? 12 + props2.strokeWidth * 0.4 : props2.width * 0.111111 + 2;
|
|
});
|
|
const content = computed(() => props2.format(props2.percentage));
|
|
function getColors(color) {
|
|
const span = 100 / color.length;
|
|
const seriesColors = color.map((seriesColor, index) => {
|
|
if (isString(seriesColor)) {
|
|
return {
|
|
color: seriesColor,
|
|
percentage: (index + 1) * span
|
|
};
|
|
}
|
|
return seriesColor;
|
|
});
|
|
return seriesColors.sort((a2, b2) => a2.percentage - b2.percentage);
|
|
}
|
|
const getCurrentColor = (percentage) => {
|
|
var _a2;
|
|
const { color } = props2;
|
|
if (isFunction(color)) {
|
|
return color(percentage);
|
|
} else if (isString(color)) {
|
|
return color;
|
|
} else {
|
|
const colors = getColors(color);
|
|
for (const color2 of colors) {
|
|
if (color2.percentage > percentage)
|
|
return color2.color;
|
|
}
|
|
return (_a2 = colors[colors.length - 1]) == null ? void 0 : _a2.color;
|
|
}
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([
|
|
unref(ns).b(),
|
|
unref(ns).m(_ctx.type),
|
|
unref(ns).is(_ctx.status),
|
|
{
|
|
[unref(ns).m("without-text")]: !_ctx.showText,
|
|
[unref(ns).m("text-inside")]: _ctx.textInside
|
|
}
|
|
]),
|
|
role: "progressbar",
|
|
"aria-valuenow": _ctx.percentage,
|
|
"aria-valuemin": "0",
|
|
"aria-valuemax": "100"
|
|
}, [
|
|
_ctx.type === "line" ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).b("bar"))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).be("bar", "outer")),
|
|
style: normalizeStyle({ height: `${_ctx.strokeWidth}px` })
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([
|
|
unref(ns).be("bar", "inner"),
|
|
{ [unref(ns).bem("bar", "inner", "indeterminate")]: _ctx.indeterminate },
|
|
{ [unref(ns).bem("bar", "inner", "striped")]: _ctx.striped },
|
|
{ [unref(ns).bem("bar", "inner", "striped-flow")]: _ctx.stripedFlow }
|
|
]),
|
|
style: normalizeStyle(unref(barStyle))
|
|
}, [
|
|
(_ctx.showText || _ctx.$slots.default) && _ctx.textInside ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).be("bar", "innerText"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default", { percentage: _ctx.percentage }, () => [
|
|
createBaseVNode("span", null, toDisplayString(unref(content)), 1)
|
|
])
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 6)
|
|
], 6)
|
|
], 2)) : (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).b("circle")),
|
|
style: normalizeStyle({ height: `${_ctx.width}px`, width: `${_ctx.width}px` })
|
|
}, [
|
|
(openBlock(), createElementBlock("svg", { viewBox: "0 0 100 100" }, [
|
|
createBaseVNode("path", {
|
|
class: normalizeClass(unref(ns).be("circle", "track")),
|
|
d: unref(trackPath),
|
|
stroke: `var(${unref(ns).cssVarName("fill-color-light")}, #e5e9f2)`,
|
|
"stroke-linecap": _ctx.strokeLinecap,
|
|
"stroke-width": unref(relativeStrokeWidth),
|
|
fill: "none",
|
|
style: normalizeStyle(unref(trailPathStyle))
|
|
}, null, 14, ["d", "stroke", "stroke-linecap", "stroke-width"]),
|
|
createBaseVNode("path", {
|
|
class: normalizeClass(unref(ns).be("circle", "path")),
|
|
d: unref(trackPath),
|
|
stroke: unref(stroke),
|
|
fill: "none",
|
|
opacity: _ctx.percentage ? 1 : 0,
|
|
"stroke-linecap": _ctx.strokeLinecap,
|
|
"stroke-width": unref(relativeStrokeWidth),
|
|
style: normalizeStyle(unref(circlePathStyle))
|
|
}, null, 14, ["d", "stroke", "opacity", "stroke-linecap", "stroke-width"])
|
|
]))
|
|
], 6)),
|
|
(_ctx.showText || _ctx.$slots.default) && !_ctx.textInside ? (openBlock(), createElementBlock("div", {
|
|
key: 2,
|
|
class: normalizeClass(unref(ns).e("text")),
|
|
style: normalizeStyle({ fontSize: `${unref(progressTextSize)}px` })
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default", { percentage: _ctx.percentage }, () => [
|
|
!_ctx.status ? (openBlock(), createElementBlock("span", { key: 0 }, toDisplayString(unref(content)), 1)) : (openBlock(), createBlock(unref(ElIcon), { key: 1 }, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(unref(statusIcon))))
|
|
]),
|
|
_: 1
|
|
}))
|
|
])
|
|
], 6)) : createCommentVNode("v-if", true)
|
|
], 10, ["aria-valuenow"]);
|
|
};
|
|
}
|
|
});
|
|
var Progress = _export_sfc(_sfc_main108, [["__file", "progress.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/progress/index.mjs
|
|
var ElProgress = withInstall(Progress);
|
|
|
|
// node_modules/element-plus/es/components/rate/src/rate.mjs
|
|
var rateProps = buildProps({
|
|
modelValue: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
id: {
|
|
type: String,
|
|
default: void 0
|
|
},
|
|
lowThreshold: {
|
|
type: Number,
|
|
default: 2
|
|
},
|
|
highThreshold: {
|
|
type: Number,
|
|
default: 4
|
|
},
|
|
max: {
|
|
type: Number,
|
|
default: 5
|
|
},
|
|
colors: {
|
|
type: definePropType([Array, Object]),
|
|
default: () => mutable(["", "", ""])
|
|
},
|
|
voidColor: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
disabledVoidColor: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
icons: {
|
|
type: definePropType([Array, Object]),
|
|
default: () => [star_filled_default, star_filled_default, star_filled_default]
|
|
},
|
|
voidIcon: {
|
|
type: iconPropType,
|
|
default: () => star_default
|
|
},
|
|
disabledVoidIcon: {
|
|
type: iconPropType,
|
|
default: () => star_filled_default
|
|
},
|
|
disabled: Boolean,
|
|
allowHalf: Boolean,
|
|
showText: Boolean,
|
|
showScore: Boolean,
|
|
textColor: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
texts: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([
|
|
"Extremely bad",
|
|
"Disappointed",
|
|
"Fair",
|
|
"Satisfied",
|
|
"Surprise"
|
|
])
|
|
},
|
|
scoreTemplate: {
|
|
type: String,
|
|
default: "{value}"
|
|
},
|
|
size: useSizeProp,
|
|
clearable: Boolean,
|
|
...useAriaProps(["ariaLabel"])
|
|
});
|
|
var rateEmits = {
|
|
[CHANGE_EVENT]: (value) => isNumber2(value),
|
|
[UPDATE_MODEL_EVENT]: (value) => isNumber2(value)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/rate/src/rate2.mjs
|
|
var __default__78 = defineComponent({
|
|
name: "ElRate"
|
|
});
|
|
var _sfc_main109 = defineComponent({
|
|
...__default__78,
|
|
props: rateProps,
|
|
emits: rateEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
function getValueFromMap(value, map2) {
|
|
const isExcludedObject = (val) => isObject(val);
|
|
const matchedKeys = Object.keys(map2).map((key) => +key).filter((key) => {
|
|
const val = map2[key];
|
|
const excluded = isExcludedObject(val) ? val.excluded : false;
|
|
return excluded ? value < key : value <= key;
|
|
}).sort((a2, b2) => a2 - b2);
|
|
const matchedValue = map2[matchedKeys[0]];
|
|
return isExcludedObject(matchedValue) && matchedValue.value || matchedValue;
|
|
}
|
|
const formContext = inject(formContextKey, void 0);
|
|
const formItemContext = inject(formItemContextKey, void 0);
|
|
const rateSize = useFormSize();
|
|
const ns = useNamespace("rate");
|
|
const { inputId, isLabeledByFormItem } = useFormItemInputId(props2, {
|
|
formItemContext
|
|
});
|
|
const currentValue = ref(props2.modelValue);
|
|
const hoverIndex = ref(-1);
|
|
const pointerAtLeftHalf = ref(true);
|
|
const rateClasses = computed(() => [ns.b(), ns.m(rateSize.value)]);
|
|
const rateDisabled = computed(() => props2.disabled || (formContext == null ? void 0 : formContext.disabled));
|
|
const rateStyles = computed(() => {
|
|
return ns.cssVarBlock({
|
|
"void-color": props2.voidColor,
|
|
"disabled-void-color": props2.disabledVoidColor,
|
|
"fill-color": activeColor.value
|
|
});
|
|
});
|
|
const text = computed(() => {
|
|
let result2 = "";
|
|
if (props2.showScore) {
|
|
result2 = props2.scoreTemplate.replace(/\{\s*value\s*\}/, rateDisabled.value ? `${props2.modelValue}` : `${currentValue.value}`);
|
|
} else if (props2.showText) {
|
|
result2 = props2.texts[Math.ceil(currentValue.value) - 1];
|
|
}
|
|
return result2;
|
|
});
|
|
const valueDecimal = computed(() => props2.modelValue * 100 - Math.floor(props2.modelValue) * 100);
|
|
const colorMap = computed(() => isArray(props2.colors) ? {
|
|
[props2.lowThreshold]: props2.colors[0],
|
|
[props2.highThreshold]: { value: props2.colors[1], excluded: true },
|
|
[props2.max]: props2.colors[2]
|
|
} : props2.colors);
|
|
const activeColor = computed(() => {
|
|
const color = getValueFromMap(currentValue.value, colorMap.value);
|
|
return isObject(color) ? "" : color;
|
|
});
|
|
const decimalStyle = computed(() => {
|
|
let width = "";
|
|
if (rateDisabled.value) {
|
|
width = `${valueDecimal.value}%`;
|
|
} else if (props2.allowHalf) {
|
|
width = "50%";
|
|
}
|
|
return {
|
|
color: activeColor.value,
|
|
width
|
|
};
|
|
});
|
|
const componentMap = computed(() => {
|
|
let icons = isArray(props2.icons) ? [...props2.icons] : { ...props2.icons };
|
|
icons = markRaw(icons);
|
|
return isArray(icons) ? {
|
|
[props2.lowThreshold]: icons[0],
|
|
[props2.highThreshold]: {
|
|
value: icons[1],
|
|
excluded: true
|
|
},
|
|
[props2.max]: icons[2]
|
|
} : icons;
|
|
});
|
|
const decimalIconComponent = computed(() => getValueFromMap(props2.modelValue, componentMap.value));
|
|
const voidComponent = computed(() => rateDisabled.value ? isString(props2.disabledVoidIcon) ? props2.disabledVoidIcon : markRaw(props2.disabledVoidIcon) : isString(props2.voidIcon) ? props2.voidIcon : markRaw(props2.voidIcon));
|
|
const activeComponent = computed(() => getValueFromMap(currentValue.value, componentMap.value));
|
|
function showDecimalIcon(item) {
|
|
const showWhenDisabled = rateDisabled.value && valueDecimal.value > 0 && item - 1 < props2.modelValue && item > props2.modelValue;
|
|
const showWhenAllowHalf = props2.allowHalf && pointerAtLeftHalf.value && item - 0.5 <= currentValue.value && item > currentValue.value;
|
|
return showWhenDisabled || showWhenAllowHalf;
|
|
}
|
|
function emitValue(value) {
|
|
if (props2.clearable && value === props2.modelValue) {
|
|
value = 0;
|
|
}
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
if (props2.modelValue !== value) {
|
|
emit(CHANGE_EVENT, value);
|
|
}
|
|
}
|
|
function selectValue(value) {
|
|
if (rateDisabled.value) {
|
|
return;
|
|
}
|
|
if (props2.allowHalf && pointerAtLeftHalf.value) {
|
|
emitValue(currentValue.value);
|
|
} else {
|
|
emitValue(value);
|
|
}
|
|
}
|
|
function handleKey(e) {
|
|
if (rateDisabled.value) {
|
|
return;
|
|
}
|
|
let _currentValue = currentValue.value;
|
|
const code = e.code;
|
|
if (code === EVENT_CODE.up || code === EVENT_CODE.right) {
|
|
if (props2.allowHalf) {
|
|
_currentValue += 0.5;
|
|
} else {
|
|
_currentValue += 1;
|
|
}
|
|
e.stopPropagation();
|
|
e.preventDefault();
|
|
} else if (code === EVENT_CODE.left || code === EVENT_CODE.down) {
|
|
if (props2.allowHalf) {
|
|
_currentValue -= 0.5;
|
|
} else {
|
|
_currentValue -= 1;
|
|
}
|
|
e.stopPropagation();
|
|
e.preventDefault();
|
|
}
|
|
_currentValue = _currentValue < 0 ? 0 : _currentValue;
|
|
_currentValue = _currentValue > props2.max ? props2.max : _currentValue;
|
|
emit(UPDATE_MODEL_EVENT, _currentValue);
|
|
emit(CHANGE_EVENT, _currentValue);
|
|
return _currentValue;
|
|
}
|
|
function setCurrentValue(value, event) {
|
|
if (rateDisabled.value) {
|
|
return;
|
|
}
|
|
if (props2.allowHalf && event) {
|
|
let target2 = event.target;
|
|
if (hasClass(target2, ns.e("item"))) {
|
|
target2 = target2.querySelector(`.${ns.e("icon")}`);
|
|
}
|
|
if (target2.clientWidth === 0 || hasClass(target2, ns.e("decimal"))) {
|
|
target2 = target2.parentNode;
|
|
}
|
|
pointerAtLeftHalf.value = event.offsetX * 2 <= target2.clientWidth;
|
|
currentValue.value = pointerAtLeftHalf.value ? value - 0.5 : value;
|
|
} else {
|
|
currentValue.value = value;
|
|
}
|
|
hoverIndex.value = value;
|
|
}
|
|
function resetCurrentValue() {
|
|
if (rateDisabled.value) {
|
|
return;
|
|
}
|
|
if (props2.allowHalf) {
|
|
pointerAtLeftHalf.value = props2.modelValue !== Math.floor(props2.modelValue);
|
|
}
|
|
currentValue.value = props2.modelValue;
|
|
hoverIndex.value = -1;
|
|
}
|
|
watch(() => props2.modelValue, (val) => {
|
|
currentValue.value = val;
|
|
pointerAtLeftHalf.value = props2.modelValue !== Math.floor(props2.modelValue);
|
|
});
|
|
if (!props2.modelValue) {
|
|
emit(UPDATE_MODEL_EVENT, 0);
|
|
}
|
|
expose({
|
|
setCurrentValue,
|
|
resetCurrentValue
|
|
});
|
|
return (_ctx, _cache) => {
|
|
var _a2;
|
|
return openBlock(), createElementBlock("div", {
|
|
id: unref(inputId),
|
|
class: normalizeClass([unref(rateClasses), unref(ns).is("disabled", unref(rateDisabled))]),
|
|
role: "slider",
|
|
"aria-label": !unref(isLabeledByFormItem) ? _ctx.ariaLabel || "rating" : void 0,
|
|
"aria-labelledby": unref(isLabeledByFormItem) ? (_a2 = unref(formItemContext)) == null ? void 0 : _a2.labelId : void 0,
|
|
"aria-valuenow": currentValue.value,
|
|
"aria-valuetext": unref(text) || void 0,
|
|
"aria-valuemin": "0",
|
|
"aria-valuemax": _ctx.max,
|
|
tabindex: "0",
|
|
style: normalizeStyle(unref(rateStyles)),
|
|
onKeydown: handleKey
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.max, (item, key) => {
|
|
return openBlock(), createElementBlock("span", {
|
|
key,
|
|
class: normalizeClass(unref(ns).e("item")),
|
|
onMousemove: ($event) => setCurrentValue(item, $event),
|
|
onMouseleave: resetCurrentValue,
|
|
onClick: ($event) => selectValue(item)
|
|
}, [
|
|
createVNode(unref(ElIcon), {
|
|
class: normalizeClass([
|
|
unref(ns).e("icon"),
|
|
{ hover: hoverIndex.value === item },
|
|
unref(ns).is("active", item <= currentValue.value)
|
|
])
|
|
}, {
|
|
default: withCtx(() => [
|
|
!showDecimalIcon(item) ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
|
|
withDirectives((openBlock(), createBlock(resolveDynamicComponent(unref(activeComponent)), null, null, 512)), [
|
|
[vShow, item <= currentValue.value]
|
|
]),
|
|
withDirectives((openBlock(), createBlock(resolveDynamicComponent(unref(voidComponent)), null, null, 512)), [
|
|
[vShow, !(item <= currentValue.value)]
|
|
])
|
|
], 64)) : createCommentVNode("v-if", true),
|
|
showDecimalIcon(item) ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [
|
|
(openBlock(), createBlock(resolveDynamicComponent(unref(voidComponent)), {
|
|
class: normalizeClass([unref(ns).em("decimal", "box")])
|
|
}, null, 8, ["class"])),
|
|
createVNode(unref(ElIcon), {
|
|
style: normalizeStyle(unref(decimalStyle)),
|
|
class: normalizeClass([unref(ns).e("icon"), unref(ns).e("decimal")])
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(unref(decimalIconComponent))))
|
|
]),
|
|
_: 1
|
|
}, 8, ["style", "class"])
|
|
], 64)) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 2
|
|
}, 1032, ["class"])
|
|
], 42, ["onMousemove", "onClick"]);
|
|
}), 128)),
|
|
_ctx.showText || _ctx.showScore ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("text")),
|
|
style: normalizeStyle({ color: _ctx.textColor })
|
|
}, toDisplayString(unref(text)), 7)) : createCommentVNode("v-if", true)
|
|
], 46, ["id", "aria-label", "aria-labelledby", "aria-valuenow", "aria-valuetext", "aria-valuemax"]);
|
|
};
|
|
}
|
|
});
|
|
var Rate = _export_sfc(_sfc_main109, [["__file", "rate.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/rate/index.mjs
|
|
var ElRate = withInstall(Rate);
|
|
|
|
// node_modules/element-plus/es/components/result/src/result.mjs
|
|
var IconMap = {
|
|
primary: "icon-primary",
|
|
success: "icon-success",
|
|
warning: "icon-warning",
|
|
error: "icon-error",
|
|
info: "icon-info"
|
|
};
|
|
var IconComponentMap = {
|
|
[IconMap.primary]: info_filled_default,
|
|
[IconMap.success]: circle_check_filled_default,
|
|
[IconMap.warning]: warning_filled_default,
|
|
[IconMap.error]: circle_close_filled_default,
|
|
[IconMap.info]: info_filled_default
|
|
};
|
|
var resultProps = buildProps({
|
|
title: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
subTitle: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
icon: {
|
|
type: String,
|
|
values: ["primary", "success", "warning", "info", "error"],
|
|
default: "info"
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/result/src/result2.mjs
|
|
var __default__79 = defineComponent({
|
|
name: "ElResult"
|
|
});
|
|
var _sfc_main110 = defineComponent({
|
|
...__default__79,
|
|
props: resultProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("result");
|
|
const resultIcon = computed(() => {
|
|
const icon = props2.icon;
|
|
const iconClass = icon && IconMap[icon] ? IconMap[icon] : "icon-info";
|
|
const iconComponent = IconComponentMap[iconClass] || IconComponentMap["icon-info"];
|
|
return {
|
|
class: iconClass,
|
|
component: iconComponent
|
|
};
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(unref(ns).b())
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("icon"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "icon", {}, () => [
|
|
unref(resultIcon).component ? (openBlock(), createBlock(resolveDynamicComponent(unref(resultIcon).component), {
|
|
key: 0,
|
|
class: normalizeClass(unref(resultIcon).class)
|
|
}, null, 8, ["class"])) : createCommentVNode("v-if", true)
|
|
])
|
|
], 2),
|
|
_ctx.title || _ctx.$slots.title ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("title"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "title", {}, () => [
|
|
createBaseVNode("p", null, toDisplayString(_ctx.title), 1)
|
|
])
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
_ctx.subTitle || _ctx.$slots["sub-title"] ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("subtitle"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "sub-title", {}, () => [
|
|
createBaseVNode("p", null, toDisplayString(_ctx.subTitle), 1)
|
|
])
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
_ctx.$slots.extra ? (openBlock(), createElementBlock("div", {
|
|
key: 2,
|
|
class: normalizeClass(unref(ns).e("extra"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "extra")
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Result = _export_sfc(_sfc_main110, [["__file", "result.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/result/index.mjs
|
|
var ElResult = withInstall(Result);
|
|
|
|
// node_modules/element-plus/es/components/row/src/row.mjs
|
|
var RowJustify = [
|
|
"start",
|
|
"center",
|
|
"end",
|
|
"space-around",
|
|
"space-between",
|
|
"space-evenly"
|
|
];
|
|
var RowAlign = ["top", "middle", "bottom"];
|
|
var rowProps = buildProps({
|
|
tag: {
|
|
type: String,
|
|
default: "div"
|
|
},
|
|
gutter: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
justify: {
|
|
type: String,
|
|
values: RowJustify,
|
|
default: "start"
|
|
},
|
|
align: {
|
|
type: String,
|
|
values: RowAlign
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/row/src/row2.mjs
|
|
var __default__80 = defineComponent({
|
|
name: "ElRow"
|
|
});
|
|
var _sfc_main111 = defineComponent({
|
|
...__default__80,
|
|
props: rowProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("row");
|
|
const gutter = computed(() => props2.gutter);
|
|
provide(rowContextKey, {
|
|
gutter
|
|
});
|
|
const style = computed(() => {
|
|
const styles = {};
|
|
if (!props2.gutter) {
|
|
return styles;
|
|
}
|
|
styles.marginRight = styles.marginLeft = `-${props2.gutter / 2}px`;
|
|
return styles;
|
|
});
|
|
const rowKls = computed(() => [
|
|
ns.b(),
|
|
ns.is(`justify-${props2.justify}`, props2.justify !== "start"),
|
|
ns.is(`align-${props2.align}`, !!props2.align)
|
|
]);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(resolveDynamicComponent(_ctx.tag), {
|
|
class: normalizeClass(unref(rowKls)),
|
|
style: normalizeStyle(unref(style))
|
|
}, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 8, ["class", "style"]);
|
|
};
|
|
}
|
|
});
|
|
var Row = _export_sfc(_sfc_main111, [["__file", "row.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/row/index.mjs
|
|
var ElRow = withInstall(Row);
|
|
|
|
// node_modules/element-plus/es/components/select-v2/src/token.mjs
|
|
var selectV2InjectionKey = Symbol("ElSelectV2Injection");
|
|
|
|
// node_modules/element-plus/es/components/virtual-list/src/defaults.mjs
|
|
var DEFAULT_DYNAMIC_LIST_ITEM_SIZE = 50;
|
|
var ITEM_RENDER_EVT = "itemRendered";
|
|
var SCROLL_EVT = "scroll";
|
|
var FORWARD = "forward";
|
|
var BACKWARD = "backward";
|
|
var AUTO_ALIGNMENT = "auto";
|
|
var SMART_ALIGNMENT = "smart";
|
|
var START_ALIGNMENT = "start";
|
|
var CENTERED_ALIGNMENT = "center";
|
|
var END_ALIGNMENT = "end";
|
|
var HORIZONTAL = "horizontal";
|
|
var VERTICAL = "vertical";
|
|
var LTR = "ltr";
|
|
var RTL = "rtl";
|
|
var RTL_OFFSET_NAG = "negative";
|
|
var RTL_OFFSET_POS_ASC = "positive-ascending";
|
|
var RTL_OFFSET_POS_DESC = "positive-descending";
|
|
var ScrollbarSizeKey = {
|
|
[HORIZONTAL]: "height",
|
|
[VERTICAL]: "width"
|
|
};
|
|
var ScrollbarDirKey = {
|
|
[HORIZONTAL]: "left",
|
|
[VERTICAL]: "top"
|
|
};
|
|
var SCROLLBAR_MIN_SIZE = 20;
|
|
|
|
// node_modules/element-plus/es/components/virtual-list/src/props.mjs
|
|
var itemSize = buildProp({
|
|
type: definePropType([Number, Function]),
|
|
required: true
|
|
});
|
|
var estimatedItemSize = buildProp({
|
|
type: Number
|
|
});
|
|
var cache = buildProp({
|
|
type: Number,
|
|
default: 2
|
|
});
|
|
var direction = buildProp({
|
|
type: String,
|
|
values: ["ltr", "rtl"],
|
|
default: "ltr"
|
|
});
|
|
var initScrollOffset = buildProp({
|
|
type: Number,
|
|
default: 0
|
|
});
|
|
var total = buildProp({
|
|
type: Number,
|
|
required: true
|
|
});
|
|
var layout = buildProp({
|
|
type: String,
|
|
values: ["horizontal", "vertical"],
|
|
default: VERTICAL
|
|
});
|
|
var virtualizedProps = buildProps({
|
|
className: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
containerElement: {
|
|
type: definePropType([String, Object]),
|
|
default: "div"
|
|
},
|
|
data: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([])
|
|
},
|
|
direction,
|
|
height: {
|
|
type: [String, Number],
|
|
required: true
|
|
},
|
|
innerElement: {
|
|
type: [String, Object],
|
|
default: "div"
|
|
},
|
|
style: {
|
|
type: definePropType([Object, String, Array])
|
|
},
|
|
useIsScrolling: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
width: {
|
|
type: [Number, String],
|
|
required: false
|
|
},
|
|
perfMode: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
scrollbarAlwaysOn: {
|
|
type: Boolean,
|
|
default: false
|
|
}
|
|
});
|
|
var virtualizedListProps = buildProps({
|
|
cache,
|
|
estimatedItemSize,
|
|
layout,
|
|
initScrollOffset,
|
|
total,
|
|
itemSize,
|
|
...virtualizedProps
|
|
});
|
|
var scrollbarSize = {
|
|
type: Number,
|
|
default: 6
|
|
};
|
|
var startGap = { type: Number, default: 0 };
|
|
var endGap = { type: Number, default: 2 };
|
|
var virtualizedGridProps = buildProps({
|
|
columnCache: cache,
|
|
columnWidth: itemSize,
|
|
estimatedColumnWidth: estimatedItemSize,
|
|
estimatedRowHeight: estimatedItemSize,
|
|
initScrollLeft: initScrollOffset,
|
|
initScrollTop: initScrollOffset,
|
|
itemKey: {
|
|
type: definePropType(Function),
|
|
default: ({
|
|
columnIndex,
|
|
rowIndex
|
|
}) => `${rowIndex}:${columnIndex}`
|
|
},
|
|
rowCache: cache,
|
|
rowHeight: itemSize,
|
|
totalColumn: total,
|
|
totalRow: total,
|
|
hScrollbarSize: scrollbarSize,
|
|
vScrollbarSize: scrollbarSize,
|
|
scrollbarStartGap: startGap,
|
|
scrollbarEndGap: endGap,
|
|
role: String,
|
|
...virtualizedProps
|
|
});
|
|
var virtualizedScrollbarProps = buildProps({
|
|
alwaysOn: Boolean,
|
|
class: String,
|
|
layout,
|
|
total,
|
|
ratio: {
|
|
type: Number,
|
|
required: true
|
|
},
|
|
clientSize: {
|
|
type: Number,
|
|
required: true
|
|
},
|
|
scrollFrom: {
|
|
type: Number,
|
|
required: true
|
|
},
|
|
scrollbarSize,
|
|
startGap,
|
|
endGap,
|
|
visible: Boolean
|
|
});
|
|
|
|
// node_modules/memoize-one/dist/memoize-one.esm.js
|
|
var safeIsNaN = Number.isNaN || function ponyfill(value) {
|
|
return typeof value === "number" && value !== value;
|
|
};
|
|
function isEqual2(first, second) {
|
|
if (first === second) {
|
|
return true;
|
|
}
|
|
if (safeIsNaN(first) && safeIsNaN(second)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function areInputsEqual(newInputs, lastInputs) {
|
|
if (newInputs.length !== lastInputs.length) {
|
|
return false;
|
|
}
|
|
for (var i = 0; i < newInputs.length; i++) {
|
|
if (!isEqual2(newInputs[i], lastInputs[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function memoizeOne(resultFn, isEqual3) {
|
|
if (isEqual3 === void 0) {
|
|
isEqual3 = areInputsEqual;
|
|
}
|
|
var cache2 = null;
|
|
function memoized() {
|
|
var newArgs = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
newArgs[_i] = arguments[_i];
|
|
}
|
|
if (cache2 && cache2.lastThis === this && isEqual3(newArgs, cache2.lastArgs)) {
|
|
return cache2.lastResult;
|
|
}
|
|
var lastResult = resultFn.apply(this, newArgs);
|
|
cache2 = {
|
|
lastResult,
|
|
lastArgs: newArgs,
|
|
lastThis: this
|
|
};
|
|
return lastResult;
|
|
}
|
|
memoized.clear = function clear() {
|
|
cache2 = null;
|
|
};
|
|
return memoized;
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/virtual-list/src/hooks/use-cache.mjs
|
|
var useCache = () => {
|
|
const vm = getCurrentInstance();
|
|
const props2 = vm.proxy.$props;
|
|
return computed(() => {
|
|
const _getItemStyleCache = (_2, __, ___) => ({});
|
|
return props2.perfMode ? memoize_default(_getItemStyleCache) : memoizeOne(_getItemStyleCache);
|
|
});
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/virtual-list/src/hooks/use-wheel.mjs
|
|
var LayoutKeys = {
|
|
[HORIZONTAL]: "deltaX",
|
|
[VERTICAL]: "deltaY"
|
|
};
|
|
var useWheel = ({ atEndEdge, atStartEdge, layout: layout2 }, onWheelDelta) => {
|
|
let frameHandle;
|
|
let offset3 = 0;
|
|
const hasReachedEdge = (offset22) => {
|
|
const edgeReached = offset22 < 0 && atStartEdge.value || offset22 > 0 && atEndEdge.value;
|
|
return edgeReached;
|
|
};
|
|
const onWheel = (e) => {
|
|
cAF(frameHandle);
|
|
const newOffset = e[LayoutKeys[layout2.value]];
|
|
if (hasReachedEdge(offset3) && hasReachedEdge(offset3 + newOffset))
|
|
return;
|
|
offset3 += newOffset;
|
|
if (!isFirefox()) {
|
|
e.preventDefault();
|
|
}
|
|
frameHandle = rAF(() => {
|
|
onWheelDelta(offset3);
|
|
offset3 = 0;
|
|
});
|
|
};
|
|
return {
|
|
hasReachedEdge,
|
|
onWheel
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/virtual-list/src/utils.mjs
|
|
var getScrollDir = (prev, cur) => prev < cur ? FORWARD : BACKWARD;
|
|
var isHorizontal = (dir) => dir === LTR || dir === RTL || dir === HORIZONTAL;
|
|
var isRTL = (dir) => dir === RTL;
|
|
var cachedRTLResult = null;
|
|
function getRTLOffsetType(recalculate = false) {
|
|
if (cachedRTLResult === null || recalculate) {
|
|
const outerDiv = document.createElement("div");
|
|
const outerStyle = outerDiv.style;
|
|
outerStyle.width = "50px";
|
|
outerStyle.height = "50px";
|
|
outerStyle.overflow = "scroll";
|
|
outerStyle.direction = "rtl";
|
|
const innerDiv = document.createElement("div");
|
|
const innerStyle = innerDiv.style;
|
|
innerStyle.width = "100px";
|
|
innerStyle.height = "100px";
|
|
outerDiv.appendChild(innerDiv);
|
|
document.body.appendChild(outerDiv);
|
|
if (outerDiv.scrollLeft > 0) {
|
|
cachedRTLResult = RTL_OFFSET_POS_DESC;
|
|
} else {
|
|
outerDiv.scrollLeft = 1;
|
|
if (outerDiv.scrollLeft === 0) {
|
|
cachedRTLResult = RTL_OFFSET_NAG;
|
|
} else {
|
|
cachedRTLResult = RTL_OFFSET_POS_ASC;
|
|
}
|
|
}
|
|
document.body.removeChild(outerDiv);
|
|
return cachedRTLResult;
|
|
}
|
|
return cachedRTLResult;
|
|
}
|
|
function renderThumbStyle2({ move, size: size3, bar }, layout2) {
|
|
const style = {};
|
|
const translate2 = `translate${bar.axis}(${move}px)`;
|
|
style[bar.size] = size3;
|
|
style.transform = translate2;
|
|
if (layout2 === "horizontal") {
|
|
style.height = "100%";
|
|
} else {
|
|
style.width = "100%";
|
|
}
|
|
return style;
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/virtual-list/src/components/scrollbar.mjs
|
|
var ScrollBar = defineComponent({
|
|
name: "ElVirtualScrollBar",
|
|
props: virtualizedScrollbarProps,
|
|
emits: ["scroll", "start-move", "stop-move"],
|
|
setup(props2, { emit }) {
|
|
const GAP2 = computed(() => props2.startGap + props2.endGap);
|
|
const nsVirtualScrollbar = useNamespace("virtual-scrollbar");
|
|
const nsScrollbar = useNamespace("scrollbar");
|
|
const trackRef = ref();
|
|
const thumbRef = ref();
|
|
let frameHandle = null;
|
|
let onselectstartStore = null;
|
|
const state = reactive({
|
|
isDragging: false,
|
|
traveled: 0
|
|
});
|
|
const bar = computed(() => BAR_MAP[props2.layout]);
|
|
const trackSize = computed(() => props2.clientSize - unref(GAP2));
|
|
const trackStyle = computed(() => ({
|
|
position: "absolute",
|
|
width: `${HORIZONTAL === props2.layout ? trackSize.value : props2.scrollbarSize}px`,
|
|
height: `${HORIZONTAL === props2.layout ? props2.scrollbarSize : trackSize.value}px`,
|
|
[ScrollbarDirKey[props2.layout]]: "2px",
|
|
right: "2px",
|
|
bottom: "2px",
|
|
borderRadius: "4px"
|
|
}));
|
|
const thumbSize = computed(() => {
|
|
const ratio = props2.ratio;
|
|
if (ratio >= 100) {
|
|
return Number.POSITIVE_INFINITY;
|
|
}
|
|
if (ratio >= 50) {
|
|
return ratio * trackSize.value / 100;
|
|
}
|
|
const SCROLLBAR_MAX_SIZE = trackSize.value / 3;
|
|
return Math.floor(Math.min(Math.max(ratio * trackSize.value, SCROLLBAR_MIN_SIZE), SCROLLBAR_MAX_SIZE));
|
|
});
|
|
const thumbStyle = computed(() => {
|
|
if (!Number.isFinite(thumbSize.value)) {
|
|
return {
|
|
display: "none"
|
|
};
|
|
}
|
|
const thumb = `${thumbSize.value}px`;
|
|
const style = renderThumbStyle2({
|
|
bar: bar.value,
|
|
size: thumb,
|
|
move: state.traveled
|
|
}, props2.layout);
|
|
return style;
|
|
});
|
|
const totalSteps = computed(() => Math.ceil(props2.clientSize - thumbSize.value - unref(GAP2)));
|
|
const attachEvents2 = () => {
|
|
window.addEventListener("mousemove", onMouseMove);
|
|
window.addEventListener("mouseup", onMouseUp);
|
|
const thumbEl = unref(thumbRef);
|
|
if (!thumbEl)
|
|
return;
|
|
onselectstartStore = document.onselectstart;
|
|
document.onselectstart = () => false;
|
|
thumbEl.addEventListener("touchmove", onMouseMove, { passive: true });
|
|
thumbEl.addEventListener("touchend", onMouseUp);
|
|
};
|
|
const detachEvents = () => {
|
|
window.removeEventListener("mousemove", onMouseMove);
|
|
window.removeEventListener("mouseup", onMouseUp);
|
|
document.onselectstart = onselectstartStore;
|
|
onselectstartStore = null;
|
|
const thumbEl = unref(thumbRef);
|
|
if (!thumbEl)
|
|
return;
|
|
thumbEl.removeEventListener("touchmove", onMouseMove);
|
|
thumbEl.removeEventListener("touchend", onMouseUp);
|
|
};
|
|
const onThumbMouseDown = (e) => {
|
|
e.stopImmediatePropagation();
|
|
if (e.ctrlKey || [1, 2].includes(e.button)) {
|
|
return;
|
|
}
|
|
state.isDragging = true;
|
|
state[bar.value.axis] = e.currentTarget[bar.value.offset] - (e[bar.value.client] - e.currentTarget.getBoundingClientRect()[bar.value.direction]);
|
|
emit("start-move");
|
|
attachEvents2();
|
|
};
|
|
const onMouseUp = () => {
|
|
state.isDragging = false;
|
|
state[bar.value.axis] = 0;
|
|
emit("stop-move");
|
|
detachEvents();
|
|
};
|
|
const onMouseMove = (e) => {
|
|
const { isDragging: isDragging2 } = state;
|
|
if (!isDragging2)
|
|
return;
|
|
if (!thumbRef.value || !trackRef.value)
|
|
return;
|
|
const prevPage = state[bar.value.axis];
|
|
if (!prevPage)
|
|
return;
|
|
cAF(frameHandle);
|
|
const offset3 = (trackRef.value.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) * -1;
|
|
const thumbClickPosition = thumbRef.value[bar.value.offset] - prevPage;
|
|
const distance = offset3 - thumbClickPosition;
|
|
frameHandle = rAF(() => {
|
|
state.traveled = Math.max(0, Math.min(distance, totalSteps.value));
|
|
emit("scroll", distance, totalSteps.value);
|
|
});
|
|
};
|
|
const clickTrackHandler = (e) => {
|
|
const offset3 = Math.abs(e.target.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]);
|
|
const thumbHalf = thumbRef.value[bar.value.offset] / 2;
|
|
const distance = offset3 - thumbHalf;
|
|
state.traveled = Math.max(0, Math.min(distance, totalSteps.value));
|
|
emit("scroll", distance, totalSteps.value);
|
|
};
|
|
watch(() => props2.scrollFrom, (v2) => {
|
|
if (state.isDragging)
|
|
return;
|
|
state.traveled = Math.ceil(v2 * totalSteps.value);
|
|
});
|
|
onBeforeUnmount(() => {
|
|
detachEvents();
|
|
});
|
|
return () => {
|
|
return h("div", {
|
|
role: "presentation",
|
|
ref: trackRef,
|
|
class: [
|
|
nsVirtualScrollbar.b(),
|
|
props2.class,
|
|
(props2.alwaysOn || state.isDragging) && "always-on"
|
|
],
|
|
style: trackStyle.value,
|
|
onMousedown: withModifiers(clickTrackHandler, ["stop", "prevent"]),
|
|
onTouchstartPrevent: onThumbMouseDown
|
|
}, h("div", {
|
|
ref: thumbRef,
|
|
class: nsScrollbar.e("thumb"),
|
|
style: thumbStyle.value,
|
|
onMousedown: onThumbMouseDown
|
|
}, []));
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/virtual-list/src/builders/build-list.mjs
|
|
var createList = ({
|
|
name,
|
|
getOffset: getOffset3,
|
|
getItemSize,
|
|
getItemOffset,
|
|
getEstimatedTotalSize: getEstimatedTotalSize2,
|
|
getStartIndexForOffset,
|
|
getStopIndexForStartIndex,
|
|
initCache,
|
|
clearCache,
|
|
validateProps
|
|
}) => {
|
|
return defineComponent({
|
|
name: name != null ? name : "ElVirtualList",
|
|
props: virtualizedListProps,
|
|
emits: [ITEM_RENDER_EVT, SCROLL_EVT],
|
|
setup(props2, { emit, expose }) {
|
|
validateProps(props2);
|
|
const instance = getCurrentInstance();
|
|
const ns = useNamespace("vl");
|
|
const dynamicSizeCache = ref(initCache(props2, instance));
|
|
const getItemStyleCache = useCache();
|
|
const windowRef = ref();
|
|
const innerRef = ref();
|
|
const scrollbarRef = ref();
|
|
const states = ref({
|
|
isScrolling: false,
|
|
scrollDir: "forward",
|
|
scrollOffset: isNumber2(props2.initScrollOffset) ? props2.initScrollOffset : 0,
|
|
updateRequested: false,
|
|
isScrollbarDragging: false,
|
|
scrollbarAlwaysOn: props2.scrollbarAlwaysOn
|
|
});
|
|
const itemsToRender = computed(() => {
|
|
const { total: total2, cache: cache2 } = props2;
|
|
const { isScrolling, scrollDir, scrollOffset } = unref(states);
|
|
if (total2 === 0) {
|
|
return [0, 0, 0, 0];
|
|
}
|
|
const startIndex = getStartIndexForOffset(props2, scrollOffset, unref(dynamicSizeCache));
|
|
const stopIndex = getStopIndexForStartIndex(props2, startIndex, scrollOffset, unref(dynamicSizeCache));
|
|
const cacheBackward = !isScrolling || scrollDir === BACKWARD ? Math.max(1, cache2) : 1;
|
|
const cacheForward = !isScrolling || scrollDir === FORWARD ? Math.max(1, cache2) : 1;
|
|
return [
|
|
Math.max(0, startIndex - cacheBackward),
|
|
Math.max(0, Math.min(total2 - 1, stopIndex + cacheForward)),
|
|
startIndex,
|
|
stopIndex
|
|
];
|
|
});
|
|
const estimatedTotalSize = computed(() => getEstimatedTotalSize2(props2, unref(dynamicSizeCache)));
|
|
const _isHorizontal = computed(() => isHorizontal(props2.layout));
|
|
const windowStyle = computed(() => [
|
|
{
|
|
position: "relative",
|
|
[`overflow-${_isHorizontal.value ? "x" : "y"}`]: "scroll",
|
|
WebkitOverflowScrolling: "touch",
|
|
willChange: "transform"
|
|
},
|
|
{
|
|
direction: props2.direction,
|
|
height: isNumber2(props2.height) ? `${props2.height}px` : props2.height,
|
|
width: isNumber2(props2.width) ? `${props2.width}px` : props2.width
|
|
},
|
|
props2.style
|
|
]);
|
|
const innerStyle = computed(() => {
|
|
const size3 = unref(estimatedTotalSize);
|
|
const horizontal = unref(_isHorizontal);
|
|
return {
|
|
height: horizontal ? "100%" : `${size3}px`,
|
|
pointerEvents: unref(states).isScrolling ? "none" : void 0,
|
|
width: horizontal ? `${size3}px` : "100%"
|
|
};
|
|
});
|
|
const clientSize = computed(() => _isHorizontal.value ? props2.width : props2.height);
|
|
const { onWheel } = useWheel({
|
|
atStartEdge: computed(() => states.value.scrollOffset <= 0),
|
|
atEndEdge: computed(() => states.value.scrollOffset >= estimatedTotalSize.value),
|
|
layout: computed(() => props2.layout)
|
|
}, (offset3) => {
|
|
var _a2, _b;
|
|
(_b = (_a2 = scrollbarRef.value).onMouseUp) == null ? void 0 : _b.call(_a2);
|
|
scrollTo(Math.min(states.value.scrollOffset + offset3, estimatedTotalSize.value - clientSize.value));
|
|
});
|
|
useEventListener(windowRef, "wheel", onWheel, {
|
|
passive: false
|
|
});
|
|
const emitEvents = () => {
|
|
const { total: total2 } = props2;
|
|
if (total2 > 0) {
|
|
const [cacheStart, cacheEnd, visibleStart, visibleEnd] = unref(itemsToRender);
|
|
emit(ITEM_RENDER_EVT, cacheStart, cacheEnd, visibleStart, visibleEnd);
|
|
}
|
|
const { scrollDir, scrollOffset, updateRequested } = unref(states);
|
|
emit(SCROLL_EVT, scrollDir, scrollOffset, updateRequested);
|
|
};
|
|
const scrollVertically = (e) => {
|
|
const { clientHeight, scrollHeight, scrollTop } = e.currentTarget;
|
|
const _states = unref(states);
|
|
if (_states.scrollOffset === scrollTop) {
|
|
return;
|
|
}
|
|
const scrollOffset = Math.max(0, Math.min(scrollTop, scrollHeight - clientHeight));
|
|
states.value = {
|
|
..._states,
|
|
isScrolling: true,
|
|
scrollDir: getScrollDir(_states.scrollOffset, scrollOffset),
|
|
scrollOffset,
|
|
updateRequested: false
|
|
};
|
|
nextTick(resetIsScrolling);
|
|
};
|
|
const scrollHorizontally = (e) => {
|
|
const { clientWidth, scrollLeft, scrollWidth } = e.currentTarget;
|
|
const _states = unref(states);
|
|
if (_states.scrollOffset === scrollLeft) {
|
|
return;
|
|
}
|
|
const { direction: direction2 } = props2;
|
|
let scrollOffset = scrollLeft;
|
|
if (direction2 === RTL) {
|
|
switch (getRTLOffsetType()) {
|
|
case RTL_OFFSET_NAG: {
|
|
scrollOffset = -scrollLeft;
|
|
break;
|
|
}
|
|
case RTL_OFFSET_POS_DESC: {
|
|
scrollOffset = scrollWidth - clientWidth - scrollLeft;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
scrollOffset = Math.max(0, Math.min(scrollOffset, scrollWidth - clientWidth));
|
|
states.value = {
|
|
..._states,
|
|
isScrolling: true,
|
|
scrollDir: getScrollDir(_states.scrollOffset, scrollOffset),
|
|
scrollOffset,
|
|
updateRequested: false
|
|
};
|
|
nextTick(resetIsScrolling);
|
|
};
|
|
const onScroll = (e) => {
|
|
unref(_isHorizontal) ? scrollHorizontally(e) : scrollVertically(e);
|
|
emitEvents();
|
|
};
|
|
const onScrollbarScroll = (distanceToGo, totalSteps) => {
|
|
const offset3 = (estimatedTotalSize.value - clientSize.value) / totalSteps * distanceToGo;
|
|
scrollTo(Math.min(estimatedTotalSize.value - clientSize.value, offset3));
|
|
};
|
|
const scrollTo = (offset3) => {
|
|
offset3 = Math.max(offset3, 0);
|
|
if (offset3 === unref(states).scrollOffset) {
|
|
return;
|
|
}
|
|
states.value = {
|
|
...unref(states),
|
|
scrollOffset: offset3,
|
|
scrollDir: getScrollDir(unref(states).scrollOffset, offset3),
|
|
updateRequested: true
|
|
};
|
|
nextTick(resetIsScrolling);
|
|
};
|
|
const scrollToItem = (idx, alignment = AUTO_ALIGNMENT) => {
|
|
const { scrollOffset } = unref(states);
|
|
idx = Math.max(0, Math.min(idx, props2.total - 1));
|
|
scrollTo(getOffset3(props2, idx, alignment, scrollOffset, unref(dynamicSizeCache)));
|
|
};
|
|
const getItemStyle = (idx) => {
|
|
const { direction: direction2, itemSize: itemSize3, layout: layout2 } = props2;
|
|
const itemStyleCache = getItemStyleCache.value(clearCache && itemSize3, clearCache && layout2, clearCache && direction2);
|
|
let style;
|
|
if (hasOwn(itemStyleCache, String(idx))) {
|
|
style = itemStyleCache[idx];
|
|
} else {
|
|
const offset3 = getItemOffset(props2, idx, unref(dynamicSizeCache));
|
|
const size3 = getItemSize(props2, idx, unref(dynamicSizeCache));
|
|
const horizontal = unref(_isHorizontal);
|
|
const isRtl = direction2 === RTL;
|
|
const offsetHorizontal = horizontal ? offset3 : 0;
|
|
itemStyleCache[idx] = style = {
|
|
position: "absolute",
|
|
left: isRtl ? void 0 : `${offsetHorizontal}px`,
|
|
right: isRtl ? `${offsetHorizontal}px` : void 0,
|
|
top: !horizontal ? `${offset3}px` : 0,
|
|
height: !horizontal ? `${size3}px` : "100%",
|
|
width: horizontal ? `${size3}px` : "100%"
|
|
};
|
|
}
|
|
return style;
|
|
};
|
|
const resetIsScrolling = () => {
|
|
states.value.isScrolling = false;
|
|
nextTick(() => {
|
|
getItemStyleCache.value(-1, null, null);
|
|
});
|
|
};
|
|
const resetScrollTop = () => {
|
|
const window2 = windowRef.value;
|
|
if (window2) {
|
|
window2.scrollTop = 0;
|
|
}
|
|
};
|
|
onMounted(() => {
|
|
if (!isClient)
|
|
return;
|
|
const { initScrollOffset: initScrollOffset2 } = props2;
|
|
const windowElement = unref(windowRef);
|
|
if (isNumber2(initScrollOffset2) && windowElement) {
|
|
if (unref(_isHorizontal)) {
|
|
windowElement.scrollLeft = initScrollOffset2;
|
|
} else {
|
|
windowElement.scrollTop = initScrollOffset2;
|
|
}
|
|
}
|
|
emitEvents();
|
|
});
|
|
onUpdated(() => {
|
|
const { direction: direction2, layout: layout2 } = props2;
|
|
const { scrollOffset, updateRequested } = unref(states);
|
|
const windowElement = unref(windowRef);
|
|
if (updateRequested && windowElement) {
|
|
if (layout2 === HORIZONTAL) {
|
|
if (direction2 === RTL) {
|
|
switch (getRTLOffsetType()) {
|
|
case RTL_OFFSET_NAG: {
|
|
windowElement.scrollLeft = -scrollOffset;
|
|
break;
|
|
}
|
|
case RTL_OFFSET_POS_ASC: {
|
|
windowElement.scrollLeft = scrollOffset;
|
|
break;
|
|
}
|
|
default: {
|
|
const { clientWidth, scrollWidth } = windowElement;
|
|
windowElement.scrollLeft = scrollWidth - clientWidth - scrollOffset;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
windowElement.scrollLeft = scrollOffset;
|
|
}
|
|
} else {
|
|
windowElement.scrollTop = scrollOffset;
|
|
}
|
|
}
|
|
});
|
|
onActivated(() => {
|
|
unref(windowRef).scrollTop = unref(states).scrollOffset;
|
|
});
|
|
const api = {
|
|
ns,
|
|
clientSize,
|
|
estimatedTotalSize,
|
|
windowStyle,
|
|
windowRef,
|
|
innerRef,
|
|
innerStyle,
|
|
itemsToRender,
|
|
scrollbarRef,
|
|
states,
|
|
getItemStyle,
|
|
onScroll,
|
|
onScrollbarScroll,
|
|
onWheel,
|
|
scrollTo,
|
|
scrollToItem,
|
|
resetScrollTop
|
|
};
|
|
expose({
|
|
windowRef,
|
|
innerRef,
|
|
getItemStyleCache,
|
|
scrollTo,
|
|
scrollToItem,
|
|
resetScrollTop,
|
|
states
|
|
});
|
|
return api;
|
|
},
|
|
render(ctx) {
|
|
var _a2;
|
|
const {
|
|
$slots,
|
|
className,
|
|
clientSize,
|
|
containerElement,
|
|
data,
|
|
getItemStyle,
|
|
innerElement,
|
|
itemsToRender,
|
|
innerStyle,
|
|
layout: layout2,
|
|
total: total2,
|
|
onScroll,
|
|
onScrollbarScroll,
|
|
states,
|
|
useIsScrolling,
|
|
windowStyle,
|
|
ns
|
|
} = ctx;
|
|
const [start, end] = itemsToRender;
|
|
const Container2 = resolveDynamicComponent(containerElement);
|
|
const Inner = resolveDynamicComponent(innerElement);
|
|
const children = [];
|
|
if (total2 > 0) {
|
|
for (let i = start; i <= end; i++) {
|
|
children.push(h(Fragment, { key: i }, (_a2 = $slots.default) == null ? void 0 : _a2.call($slots, {
|
|
data,
|
|
index: i,
|
|
isScrolling: useIsScrolling ? states.isScrolling : void 0,
|
|
style: getItemStyle(i)
|
|
})));
|
|
}
|
|
}
|
|
const InnerNode = [
|
|
h(Inner, {
|
|
style: innerStyle,
|
|
ref: "innerRef"
|
|
}, !isString(Inner) ? {
|
|
default: () => children
|
|
} : children)
|
|
];
|
|
const scrollbar = h(ScrollBar, {
|
|
ref: "scrollbarRef",
|
|
clientSize,
|
|
layout: layout2,
|
|
onScroll: onScrollbarScroll,
|
|
ratio: clientSize * 100 / this.estimatedTotalSize,
|
|
scrollFrom: states.scrollOffset / (this.estimatedTotalSize - clientSize),
|
|
total: total2
|
|
});
|
|
const listContainer = h(Container2, {
|
|
class: [ns.e("window"), className],
|
|
style: windowStyle,
|
|
onScroll,
|
|
ref: "windowRef",
|
|
key: 0
|
|
}, !isString(Container2) ? { default: () => [InnerNode] } : [InnerNode]);
|
|
return h("div", {
|
|
key: 0,
|
|
class: [ns.e("wrapper"), states.scrollbarAlwaysOn ? "always-on" : ""]
|
|
}, [listContainer, scrollbar]);
|
|
}
|
|
});
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/virtual-list/src/components/fixed-size-list.mjs
|
|
var FixedSizeList = createList({
|
|
name: "ElFixedSizeList",
|
|
getItemOffset: ({ itemSize: itemSize3 }, index) => index * itemSize3,
|
|
getItemSize: ({ itemSize: itemSize3 }) => itemSize3,
|
|
getEstimatedTotalSize: ({ total: total2, itemSize: itemSize3 }) => itemSize3 * total2,
|
|
getOffset: ({ height, total: total2, itemSize: itemSize3, layout: layout2, width }, index, alignment, scrollOffset) => {
|
|
const size3 = isHorizontal(layout2) ? width : height;
|
|
if (isString(size3)) {
|
|
throwError("[ElVirtualList]", `
|
|
You should set
|
|
width/height
|
|
to number when your layout is
|
|
horizontal/vertical
|
|
`);
|
|
}
|
|
const lastItemOffset = Math.max(0, total2 * itemSize3 - size3);
|
|
const maxOffset = Math.min(lastItemOffset, index * itemSize3);
|
|
const minOffset = Math.max(0, (index + 1) * itemSize3 - size3);
|
|
if (alignment === SMART_ALIGNMENT) {
|
|
if (scrollOffset >= minOffset - size3 && scrollOffset <= maxOffset + size3) {
|
|
alignment = AUTO_ALIGNMENT;
|
|
} else {
|
|
alignment = CENTERED_ALIGNMENT;
|
|
}
|
|
}
|
|
switch (alignment) {
|
|
case START_ALIGNMENT: {
|
|
return maxOffset;
|
|
}
|
|
case END_ALIGNMENT: {
|
|
return minOffset;
|
|
}
|
|
case CENTERED_ALIGNMENT: {
|
|
const middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
|
|
if (middleOffset < Math.ceil(size3 / 2)) {
|
|
return 0;
|
|
} else if (middleOffset > lastItemOffset + Math.floor(size3 / 2)) {
|
|
return lastItemOffset;
|
|
} else {
|
|
return middleOffset;
|
|
}
|
|
}
|
|
case AUTO_ALIGNMENT:
|
|
default: {
|
|
if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
|
|
return scrollOffset;
|
|
} else if (scrollOffset < minOffset) {
|
|
return minOffset;
|
|
} else {
|
|
return maxOffset;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
getStartIndexForOffset: ({ total: total2, itemSize: itemSize3 }, offset3) => Math.max(0, Math.min(total2 - 1, Math.floor(offset3 / itemSize3))),
|
|
getStopIndexForStartIndex: ({ height, total: total2, itemSize: itemSize3, layout: layout2, width }, startIndex, scrollOffset) => {
|
|
const offset3 = startIndex * itemSize3;
|
|
const size3 = isHorizontal(layout2) ? width : height;
|
|
const numVisibleItems = Math.ceil((size3 + scrollOffset - offset3) / itemSize3);
|
|
return Math.max(0, Math.min(total2 - 1, startIndex + numVisibleItems - 1));
|
|
},
|
|
initCache() {
|
|
return void 0;
|
|
},
|
|
clearCache: true,
|
|
validateProps() {
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/virtual-list/src/components/dynamic-size-list.mjs
|
|
var SCOPE6 = "ElDynamicSizeList";
|
|
var getItemFromCache = (props2, index, listCache) => {
|
|
const { itemSize: itemSize3 } = props2;
|
|
const { items, lastVisitedIndex } = listCache;
|
|
if (index > lastVisitedIndex) {
|
|
let offset3 = 0;
|
|
if (lastVisitedIndex >= 0) {
|
|
const item = items[lastVisitedIndex];
|
|
offset3 = item.offset + item.size;
|
|
}
|
|
for (let i = lastVisitedIndex + 1; i <= index; i++) {
|
|
const size3 = itemSize3(i);
|
|
items[i] = {
|
|
offset: offset3,
|
|
size: size3
|
|
};
|
|
offset3 += size3;
|
|
}
|
|
listCache.lastVisitedIndex = index;
|
|
}
|
|
return items[index];
|
|
};
|
|
var findItem = (props2, listCache, offset3) => {
|
|
const { items, lastVisitedIndex } = listCache;
|
|
const lastVisitedOffset = lastVisitedIndex > 0 ? items[lastVisitedIndex].offset : 0;
|
|
if (lastVisitedOffset >= offset3) {
|
|
return bs(props2, listCache, 0, lastVisitedIndex, offset3);
|
|
}
|
|
return es(props2, listCache, Math.max(0, lastVisitedIndex), offset3);
|
|
};
|
|
var bs = (props2, listCache, low, high, offset3) => {
|
|
while (low <= high) {
|
|
const mid = low + Math.floor((high - low) / 2);
|
|
const currentOffset = getItemFromCache(props2, mid, listCache).offset;
|
|
if (currentOffset === offset3) {
|
|
return mid;
|
|
} else if (currentOffset < offset3) {
|
|
low = mid + 1;
|
|
} else if (currentOffset > offset3) {
|
|
high = mid - 1;
|
|
}
|
|
}
|
|
return Math.max(0, low - 1);
|
|
};
|
|
var es = (props2, listCache, index, offset3) => {
|
|
const { total: total2 } = props2;
|
|
let exponent = 1;
|
|
while (index < total2 && getItemFromCache(props2, index, listCache).offset < offset3) {
|
|
index += exponent;
|
|
exponent *= 2;
|
|
}
|
|
return bs(props2, listCache, Math.floor(index / 2), Math.min(index, total2 - 1), offset3);
|
|
};
|
|
var getEstimatedTotalSize = ({ total: total2 }, { items, estimatedItemSize: estimatedItemSize2, lastVisitedIndex }) => {
|
|
let totalSizeOfMeasuredItems = 0;
|
|
if (lastVisitedIndex >= total2) {
|
|
lastVisitedIndex = total2 - 1;
|
|
}
|
|
if (lastVisitedIndex >= 0) {
|
|
const item = items[lastVisitedIndex];
|
|
totalSizeOfMeasuredItems = item.offset + item.size;
|
|
}
|
|
const numUnmeasuredItems = total2 - lastVisitedIndex - 1;
|
|
const totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedItemSize2;
|
|
return totalSizeOfMeasuredItems + totalSizeOfUnmeasuredItems;
|
|
};
|
|
var DynamicSizeList = createList({
|
|
name: "ElDynamicSizeList",
|
|
getItemOffset: (props2, index, listCache) => getItemFromCache(props2, index, listCache).offset,
|
|
getItemSize: (_2, index, { items }) => items[index].size,
|
|
getEstimatedTotalSize,
|
|
getOffset: (props2, index, alignment, scrollOffset, listCache) => {
|
|
const { height, layout: layout2, width } = props2;
|
|
const size3 = isHorizontal(layout2) ? width : height;
|
|
const item = getItemFromCache(props2, index, listCache);
|
|
const estimatedTotalSize = getEstimatedTotalSize(props2, listCache);
|
|
const maxOffset = Math.max(0, Math.min(estimatedTotalSize - size3, item.offset));
|
|
const minOffset = Math.max(0, item.offset - size3 + item.size);
|
|
if (alignment === SMART_ALIGNMENT) {
|
|
if (scrollOffset >= minOffset - size3 && scrollOffset <= maxOffset + size3) {
|
|
alignment = AUTO_ALIGNMENT;
|
|
} else {
|
|
alignment = CENTERED_ALIGNMENT;
|
|
}
|
|
}
|
|
switch (alignment) {
|
|
case START_ALIGNMENT: {
|
|
return maxOffset;
|
|
}
|
|
case END_ALIGNMENT: {
|
|
return minOffset;
|
|
}
|
|
case CENTERED_ALIGNMENT: {
|
|
return Math.round(minOffset + (maxOffset - minOffset) / 2);
|
|
}
|
|
case AUTO_ALIGNMENT:
|
|
default: {
|
|
if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
|
|
return scrollOffset;
|
|
} else if (scrollOffset < minOffset) {
|
|
return minOffset;
|
|
} else {
|
|
return maxOffset;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
getStartIndexForOffset: (props2, offset3, listCache) => findItem(props2, listCache, offset3),
|
|
getStopIndexForStartIndex: (props2, startIndex, scrollOffset, listCache) => {
|
|
const { height, total: total2, layout: layout2, width } = props2;
|
|
const size3 = isHorizontal(layout2) ? width : height;
|
|
const item = getItemFromCache(props2, startIndex, listCache);
|
|
const maxOffset = scrollOffset + size3;
|
|
let offset3 = item.offset + item.size;
|
|
let stopIndex = startIndex;
|
|
while (stopIndex < total2 - 1 && offset3 < maxOffset) {
|
|
stopIndex++;
|
|
offset3 += getItemFromCache(props2, stopIndex, listCache).size;
|
|
}
|
|
return stopIndex;
|
|
},
|
|
initCache({ estimatedItemSize: estimatedItemSize2 = DEFAULT_DYNAMIC_LIST_ITEM_SIZE }, instance) {
|
|
const cache2 = {
|
|
items: {},
|
|
estimatedItemSize: estimatedItemSize2,
|
|
lastVisitedIndex: -1
|
|
};
|
|
cache2.clearCacheAfterIndex = (index, forceUpdate = true) => {
|
|
var _a2, _b;
|
|
cache2.lastVisitedIndex = Math.min(cache2.lastVisitedIndex, index - 1);
|
|
(_a2 = instance.exposed) == null ? void 0 : _a2.getItemStyleCache(-1);
|
|
if (forceUpdate) {
|
|
(_b = instance.proxy) == null ? void 0 : _b.$forceUpdate();
|
|
}
|
|
};
|
|
return cache2;
|
|
},
|
|
clearCache: false,
|
|
validateProps: ({ itemSize: itemSize3 }) => {
|
|
if (true) {
|
|
if (typeof itemSize3 !== "function") {
|
|
throwError(SCOPE6, `
|
|
itemSize is required as function, but the given value was ${typeof itemSize3}
|
|
`);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/select-v2/src/group-item.mjs
|
|
var _sfc_main112 = defineComponent({
|
|
props: {
|
|
item: {
|
|
type: Object,
|
|
required: true
|
|
},
|
|
style: {
|
|
type: Object
|
|
},
|
|
height: Number
|
|
},
|
|
setup() {
|
|
const ns = useNamespace("select");
|
|
return {
|
|
ns
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render21(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(_ctx.ns.be("group", "title")),
|
|
style: normalizeStyle({ ..._ctx.style, lineHeight: `${_ctx.height}px` })
|
|
}, toDisplayString(_ctx.item.label), 7);
|
|
}
|
|
var GroupItem = _export_sfc(_sfc_main112, [["render", _sfc_render21], ["__file", "group-item.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/select-v2/src/useOption.mjs
|
|
function useOption2(props2, { emit }) {
|
|
return {
|
|
hoverItem: () => {
|
|
if (!props2.disabled) {
|
|
emit("hover", props2.index);
|
|
}
|
|
},
|
|
selectOptionClick: () => {
|
|
if (!props2.disabled) {
|
|
emit("select", props2.item, props2.index);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/select-v2/src/useProps.mjs
|
|
var defaultProps = {
|
|
label: "label",
|
|
value: "value",
|
|
disabled: "disabled",
|
|
options: "options"
|
|
};
|
|
function useProps(props2) {
|
|
const aliasProps = computed(() => ({ ...defaultProps, ...props2.props }));
|
|
const getLabel = (option) => get_default(option, aliasProps.value.label);
|
|
const getValue3 = (option) => get_default(option, aliasProps.value.value);
|
|
const getDisabled = (option) => get_default(option, aliasProps.value.disabled);
|
|
const getOptions = (option) => get_default(option, aliasProps.value.options);
|
|
return {
|
|
aliasProps,
|
|
getLabel,
|
|
getValue: getValue3,
|
|
getDisabled,
|
|
getOptions
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/select-v2/src/defaults.mjs
|
|
var SelectProps2 = buildProps({
|
|
allowCreate: Boolean,
|
|
autocomplete: {
|
|
type: definePropType(String),
|
|
default: "none"
|
|
},
|
|
automaticDropdown: Boolean,
|
|
clearable: Boolean,
|
|
clearIcon: {
|
|
type: iconPropType,
|
|
default: circle_close_default
|
|
},
|
|
effect: {
|
|
type: definePropType(String),
|
|
default: "light"
|
|
},
|
|
collapseTags: Boolean,
|
|
collapseTagsTooltip: Boolean,
|
|
maxCollapseTags: {
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
defaultFirstOption: Boolean,
|
|
disabled: Boolean,
|
|
estimatedOptionHeight: {
|
|
type: Number,
|
|
default: void 0
|
|
},
|
|
filterable: Boolean,
|
|
filterMethod: Function,
|
|
height: {
|
|
type: Number,
|
|
default: 274
|
|
},
|
|
itemHeight: {
|
|
type: Number,
|
|
default: 34
|
|
},
|
|
id: String,
|
|
loading: Boolean,
|
|
loadingText: String,
|
|
modelValue: {
|
|
type: definePropType([Array, String, Number, Boolean, Object])
|
|
},
|
|
multiple: Boolean,
|
|
multipleLimit: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
name: String,
|
|
noDataText: String,
|
|
noMatchText: String,
|
|
remoteMethod: Function,
|
|
reserveKeyword: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
options: {
|
|
type: definePropType(Array),
|
|
required: true
|
|
},
|
|
placeholder: {
|
|
type: String
|
|
},
|
|
teleported: useTooltipContentProps.teleported,
|
|
persistent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
popperClass: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
popperOptions: {
|
|
type: definePropType(Object),
|
|
default: () => ({})
|
|
},
|
|
remote: Boolean,
|
|
size: useSizeProp,
|
|
props: {
|
|
type: definePropType(Object),
|
|
default: () => defaultProps
|
|
},
|
|
valueKey: {
|
|
type: String,
|
|
default: "value"
|
|
},
|
|
scrollbarAlwaysOn: Boolean,
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
offset: {
|
|
type: Number,
|
|
default: 12
|
|
},
|
|
showArrow: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
placement: {
|
|
type: definePropType(String),
|
|
values: Ee,
|
|
default: "bottom-start"
|
|
},
|
|
fallbackPlacements: {
|
|
type: definePropType(Array),
|
|
default: ["bottom-start", "top-start", "right", "left"]
|
|
},
|
|
tagType: { ...tagProps.type, default: "info" },
|
|
tagEffect: { ...tagProps.effect, default: "light" },
|
|
tabindex: {
|
|
type: [String, Number],
|
|
default: 0
|
|
},
|
|
appendTo: useTooltipContentProps.appendTo,
|
|
fitInputWidth: {
|
|
type: [Boolean, Number],
|
|
default: true,
|
|
validator(val) {
|
|
return isBoolean2(val) || isNumber2(val);
|
|
}
|
|
},
|
|
suffixIcon: {
|
|
type: iconPropType,
|
|
default: arrow_down_default
|
|
},
|
|
...useEmptyValuesProps,
|
|
...useAriaProps(["ariaLabel"])
|
|
});
|
|
var OptionProps = buildProps({
|
|
data: Array,
|
|
disabled: Boolean,
|
|
hovering: Boolean,
|
|
item: {
|
|
type: definePropType(Object),
|
|
required: true
|
|
},
|
|
index: Number,
|
|
style: Object,
|
|
selected: Boolean,
|
|
created: Boolean
|
|
});
|
|
var selectEmits2 = {
|
|
[UPDATE_MODEL_EVENT]: (val) => true,
|
|
[CHANGE_EVENT]: (val) => true,
|
|
"remove-tag": (val) => true,
|
|
"visible-change": (visible) => true,
|
|
focus: (evt) => evt instanceof FocusEvent,
|
|
blur: (evt) => evt instanceof FocusEvent,
|
|
clear: () => true
|
|
};
|
|
var optionEmits = {
|
|
hover: (index) => isNumber2(index),
|
|
select: (val, index) => true
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/select-v2/src/option-item.mjs
|
|
var _sfc_main113 = defineComponent({
|
|
props: OptionProps,
|
|
emits: optionEmits,
|
|
setup(props2, { emit }) {
|
|
const select = inject(selectV2InjectionKey);
|
|
const ns = useNamespace("select");
|
|
const { hoverItem, selectOptionClick } = useOption2(props2, { emit });
|
|
const { getLabel } = useProps(select.props);
|
|
return {
|
|
ns,
|
|
hoverItem,
|
|
selectOptionClick,
|
|
getLabel
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render22(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return openBlock(), createElementBlock("li", {
|
|
"aria-selected": _ctx.selected,
|
|
style: normalizeStyle(_ctx.style),
|
|
class: normalizeClass([
|
|
_ctx.ns.be("dropdown", "item"),
|
|
_ctx.ns.is("selected", _ctx.selected),
|
|
_ctx.ns.is("disabled", _ctx.disabled),
|
|
_ctx.ns.is("created", _ctx.created),
|
|
_ctx.ns.is("hovering", _ctx.hovering)
|
|
]),
|
|
onMousemove: _ctx.hoverItem,
|
|
onClick: withModifiers(_ctx.selectOptionClick, ["stop"])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default", {
|
|
item: _ctx.item,
|
|
index: _ctx.index,
|
|
disabled: _ctx.disabled
|
|
}, () => [
|
|
createBaseVNode("span", null, toDisplayString(_ctx.getLabel(_ctx.item)), 1)
|
|
])
|
|
], 46, ["aria-selected", "onMousemove", "onClick"]);
|
|
}
|
|
var OptionItem = _export_sfc(_sfc_main113, [["render", _sfc_render22], ["__file", "option-item.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/select-v2/src/select-dropdown.mjs
|
|
var props = {
|
|
loading: Boolean,
|
|
data: {
|
|
type: Array,
|
|
required: true
|
|
},
|
|
hoveringIndex: Number,
|
|
width: Number
|
|
};
|
|
var ElSelectMenu2 = defineComponent({
|
|
name: "ElSelectDropdown",
|
|
props,
|
|
setup(props2, {
|
|
slots,
|
|
expose
|
|
}) {
|
|
const select = inject(selectV2InjectionKey);
|
|
const ns = useNamespace("select");
|
|
const {
|
|
getLabel,
|
|
getValue: getValue3,
|
|
getDisabled
|
|
} = useProps(select.props);
|
|
const cachedHeights = ref([]);
|
|
const listRef = ref();
|
|
const size3 = computed(() => props2.data.length);
|
|
watch(() => size3.value, () => {
|
|
var _a2, _b;
|
|
(_b = (_a2 = select.tooltipRef.value) == null ? void 0 : _a2.updatePopper) == null ? void 0 : _b.call(_a2);
|
|
});
|
|
const isSized = computed(() => isUndefined2(select.props.estimatedOptionHeight));
|
|
const listProps = computed(() => {
|
|
if (isSized.value) {
|
|
return {
|
|
itemSize: select.props.itemHeight
|
|
};
|
|
}
|
|
return {
|
|
estimatedSize: select.props.estimatedOptionHeight,
|
|
itemSize: (idx) => cachedHeights.value[idx]
|
|
};
|
|
});
|
|
const contains = (arr = [], target2) => {
|
|
const {
|
|
props: {
|
|
valueKey
|
|
}
|
|
} = select;
|
|
if (!isObject(target2)) {
|
|
return arr.includes(target2);
|
|
}
|
|
return arr && arr.some((item) => {
|
|
return toRaw(get_default(item, valueKey)) === get_default(target2, valueKey);
|
|
});
|
|
};
|
|
const isEqual3 = (selected, target2) => {
|
|
if (!isObject(target2)) {
|
|
return selected === target2;
|
|
} else {
|
|
const {
|
|
valueKey
|
|
} = select.props;
|
|
return get_default(selected, valueKey) === get_default(target2, valueKey);
|
|
}
|
|
};
|
|
const isItemSelected = (modelValue, target2) => {
|
|
if (select.props.multiple) {
|
|
return contains(modelValue, getValue3(target2));
|
|
}
|
|
return isEqual3(modelValue, getValue3(target2));
|
|
};
|
|
const isItemDisabled = (modelValue, selected) => {
|
|
const {
|
|
disabled,
|
|
multiple,
|
|
multipleLimit
|
|
} = select.props;
|
|
return disabled || !selected && (multiple ? multipleLimit > 0 && modelValue.length >= multipleLimit : false);
|
|
};
|
|
const isItemHovering = (target2) => props2.hoveringIndex === target2;
|
|
const scrollToItem = (index) => {
|
|
const list = listRef.value;
|
|
if (list) {
|
|
list.scrollToItem(index);
|
|
}
|
|
};
|
|
const resetScrollTop = () => {
|
|
const list = listRef.value;
|
|
if (list) {
|
|
list.resetScrollTop();
|
|
}
|
|
};
|
|
const exposed = {
|
|
listRef,
|
|
isSized,
|
|
isItemDisabled,
|
|
isItemHovering,
|
|
isItemSelected,
|
|
scrollToItem,
|
|
resetScrollTop
|
|
};
|
|
expose(exposed);
|
|
const Item = (itemProps) => {
|
|
const {
|
|
index,
|
|
data,
|
|
style
|
|
} = itemProps;
|
|
const sized = unref(isSized);
|
|
const {
|
|
itemSize: itemSize3,
|
|
estimatedSize
|
|
} = unref(listProps);
|
|
const {
|
|
modelValue
|
|
} = select.props;
|
|
const {
|
|
onSelect,
|
|
onHover
|
|
} = select;
|
|
const item = data[index];
|
|
if (item.type === "Group") {
|
|
return createVNode(GroupItem, {
|
|
"item": item,
|
|
"style": style,
|
|
"height": sized ? itemSize3 : estimatedSize
|
|
}, null);
|
|
}
|
|
const isSelected = isItemSelected(modelValue, item);
|
|
const isDisabled = isItemDisabled(modelValue, isSelected);
|
|
const isHovering = isItemHovering(index);
|
|
return createVNode(OptionItem, mergeProps(itemProps, {
|
|
"selected": isSelected,
|
|
"disabled": getDisabled(item) || isDisabled,
|
|
"created": !!item.created,
|
|
"hovering": isHovering,
|
|
"item": item,
|
|
"onSelect": onSelect,
|
|
"onHover": onHover
|
|
}), {
|
|
default: (props3) => {
|
|
var _a2;
|
|
return ((_a2 = slots.default) == null ? void 0 : _a2.call(slots, props3)) || createVNode("span", null, [getLabel(item)]);
|
|
}
|
|
});
|
|
};
|
|
const {
|
|
onKeyboardNavigate,
|
|
onKeyboardSelect
|
|
} = select;
|
|
const onForward = () => {
|
|
onKeyboardNavigate("forward");
|
|
};
|
|
const onBackward = () => {
|
|
onKeyboardNavigate("backward");
|
|
};
|
|
const onKeydown = (e) => {
|
|
const {
|
|
code
|
|
} = e;
|
|
const {
|
|
tab,
|
|
esc,
|
|
down,
|
|
up,
|
|
enter,
|
|
numpadEnter
|
|
} = EVENT_CODE;
|
|
if ([esc, down, up, enter, numpadEnter].includes(code)) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
}
|
|
switch (code) {
|
|
case tab:
|
|
case esc:
|
|
break;
|
|
case down:
|
|
onForward();
|
|
break;
|
|
case up:
|
|
onBackward();
|
|
break;
|
|
case enter:
|
|
case numpadEnter:
|
|
onKeyboardSelect();
|
|
break;
|
|
}
|
|
};
|
|
return () => {
|
|
var _a2, _b, _c, _d;
|
|
const {
|
|
data,
|
|
width
|
|
} = props2;
|
|
const {
|
|
height,
|
|
multiple,
|
|
scrollbarAlwaysOn
|
|
} = select.props;
|
|
const isScrollbarAlwaysOn = computed(() => {
|
|
return isIOS ? true : scrollbarAlwaysOn;
|
|
});
|
|
const List = unref(isSized) ? FixedSizeList : DynamicSizeList;
|
|
return createVNode("div", {
|
|
"class": [ns.b("dropdown"), ns.is("multiple", multiple)],
|
|
"style": {
|
|
width: `${width}px`
|
|
}
|
|
}, [(_a2 = slots.header) == null ? void 0 : _a2.call(slots), ((_b = slots.loading) == null ? void 0 : _b.call(slots)) || ((_c = slots.empty) == null ? void 0 : _c.call(slots)) || createVNode(List, mergeProps({
|
|
"ref": listRef
|
|
}, unref(listProps), {
|
|
"className": ns.be("dropdown", "list"),
|
|
"scrollbarAlwaysOn": isScrollbarAlwaysOn.value,
|
|
"data": data,
|
|
"height": height,
|
|
"width": width,
|
|
"total": data.length,
|
|
"onKeydown": onKeydown
|
|
}), {
|
|
default: (props3) => createVNode(Item, props3, null)
|
|
}), (_d = slots.footer) == null ? void 0 : _d.call(slots)]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/select-v2/src/useAllowCreate.mjs
|
|
function useAllowCreate(props2, states) {
|
|
const { aliasProps, getLabel, getValue: getValue3 } = useProps(props2);
|
|
const createOptionCount = ref(0);
|
|
const cachedSelectedOption = ref();
|
|
const enableAllowCreateMode = computed(() => {
|
|
return props2.allowCreate && props2.filterable;
|
|
});
|
|
function hasExistingOption(query) {
|
|
const hasOption = (option) => getLabel(option) === query;
|
|
return props2.options && props2.options.some(hasOption) || states.createdOptions.some(hasOption);
|
|
}
|
|
function selectNewOption(option) {
|
|
if (!enableAllowCreateMode.value) {
|
|
return;
|
|
}
|
|
if (props2.multiple && option.created) {
|
|
createOptionCount.value++;
|
|
} else {
|
|
cachedSelectedOption.value = option;
|
|
}
|
|
}
|
|
function createNewOption(query) {
|
|
if (enableAllowCreateMode.value) {
|
|
if (query && query.length > 0) {
|
|
if (hasExistingOption(query)) {
|
|
return;
|
|
}
|
|
const newOption = {
|
|
[aliasProps.value.value]: query,
|
|
[aliasProps.value.label]: query,
|
|
created: true,
|
|
[aliasProps.value.disabled]: false
|
|
};
|
|
if (states.createdOptions.length >= createOptionCount.value) {
|
|
states.createdOptions[createOptionCount.value] = newOption;
|
|
} else {
|
|
states.createdOptions.push(newOption);
|
|
}
|
|
} else {
|
|
if (props2.multiple) {
|
|
states.createdOptions.length = createOptionCount.value;
|
|
} else {
|
|
const selectedOption = cachedSelectedOption.value;
|
|
states.createdOptions.length = 0;
|
|
if (selectedOption && selectedOption.created) {
|
|
states.createdOptions.push(selectedOption);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function removeNewOption(option) {
|
|
if (!enableAllowCreateMode.value || !option || !option.created || option.created && props2.reserveKeyword && states.inputValue === getLabel(option)) {
|
|
return;
|
|
}
|
|
const idx = states.createdOptions.findIndex((it2) => getValue3(it2) === getValue3(option));
|
|
if (~idx) {
|
|
states.createdOptions.splice(idx, 1);
|
|
createOptionCount.value--;
|
|
}
|
|
}
|
|
function clearAllNewOption() {
|
|
if (enableAllowCreateMode.value) {
|
|
states.createdOptions.length = 0;
|
|
createOptionCount.value = 0;
|
|
}
|
|
}
|
|
return {
|
|
createNewOption,
|
|
removeNewOption,
|
|
selectNewOption,
|
|
clearAllNewOption
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/select-v2/src/useSelect.mjs
|
|
var useSelect2 = (props2, emit) => {
|
|
const { t } = useLocale();
|
|
const nsSelect = useNamespace("select");
|
|
const nsInput = useNamespace("input");
|
|
const { form: elForm, formItem: elFormItem } = useFormItem();
|
|
const { inputId } = useFormItemInputId(props2, {
|
|
formItemContext: elFormItem
|
|
});
|
|
const { aliasProps, getLabel, getValue: getValue3, getDisabled, getOptions } = useProps(props2);
|
|
const { valueOnClear, isEmptyValue: isEmptyValue2 } = useEmptyValues(props2);
|
|
const states = reactive({
|
|
inputValue: "",
|
|
cachedOptions: [],
|
|
createdOptions: [],
|
|
hoveringIndex: -1,
|
|
inputHovering: false,
|
|
selectionWidth: 0,
|
|
collapseItemWidth: 0,
|
|
previousQuery: null,
|
|
previousValue: void 0,
|
|
selectedLabel: "",
|
|
menuVisibleOnFocus: false,
|
|
isBeforeHide: false
|
|
});
|
|
const popperSize = ref(-1);
|
|
const selectRef = ref();
|
|
const selectionRef = ref();
|
|
const tooltipRef = ref();
|
|
const tagTooltipRef = ref();
|
|
const inputRef = ref();
|
|
const prefixRef = ref();
|
|
const suffixRef = ref();
|
|
const menuRef = ref();
|
|
const tagMenuRef = ref();
|
|
const collapseItemRef = ref();
|
|
const {
|
|
isComposing,
|
|
handleCompositionStart,
|
|
handleCompositionEnd,
|
|
handleCompositionUpdate
|
|
} = useComposition({
|
|
afterComposition: (e) => onInput(e)
|
|
});
|
|
const { wrapperRef, isFocused, handleBlur } = useFocusController(inputRef, {
|
|
beforeFocus() {
|
|
return selectDisabled.value;
|
|
},
|
|
afterFocus() {
|
|
if (props2.automaticDropdown && !expanded.value) {
|
|
expanded.value = true;
|
|
states.menuVisibleOnFocus = true;
|
|
}
|
|
},
|
|
beforeBlur(event) {
|
|
var _a2, _b;
|
|
return ((_a2 = tooltipRef.value) == null ? void 0 : _a2.isFocusInsideContent(event)) || ((_b = tagTooltipRef.value) == null ? void 0 : _b.isFocusInsideContent(event));
|
|
},
|
|
afterBlur() {
|
|
var _a2;
|
|
expanded.value = false;
|
|
states.menuVisibleOnFocus = false;
|
|
if (props2.validateEvent) {
|
|
(_a2 = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a2.call(elFormItem, "blur").catch((err) => debugWarn(err));
|
|
}
|
|
}
|
|
});
|
|
const allOptions = computed(() => filterOptions(""));
|
|
const hasOptions = computed(() => {
|
|
if (props2.loading)
|
|
return false;
|
|
return props2.options.length > 0 || states.createdOptions.length > 0;
|
|
});
|
|
const filteredOptions = ref([]);
|
|
const expanded = ref(false);
|
|
const selectDisabled = computed(() => props2.disabled || (elForm == null ? void 0 : elForm.disabled));
|
|
const needStatusIcon = computed(() => {
|
|
var _a2;
|
|
return (_a2 = elForm == null ? void 0 : elForm.statusIcon) != null ? _a2 : false;
|
|
});
|
|
const popupHeight = computed(() => {
|
|
const totalHeight = filteredOptions.value.length * props2.itemHeight;
|
|
return totalHeight > props2.height ? props2.height : totalHeight;
|
|
});
|
|
const hasModelValue = computed(() => {
|
|
return props2.multiple ? isArray(props2.modelValue) && props2.modelValue.length > 0 : !isEmptyValue2(props2.modelValue);
|
|
});
|
|
const showClearBtn = computed(() => {
|
|
return props2.clearable && !selectDisabled.value && states.inputHovering && hasModelValue.value;
|
|
});
|
|
const iconComponent = computed(() => props2.remote && props2.filterable ? "" : props2.suffixIcon);
|
|
const iconReverse = computed(() => iconComponent.value && nsSelect.is("reverse", expanded.value));
|
|
const validateState = computed(() => (elFormItem == null ? void 0 : elFormItem.validateState) || "");
|
|
const validateIcon = computed(() => {
|
|
if (!validateState.value)
|
|
return;
|
|
return ValidateComponentsMap[validateState.value];
|
|
});
|
|
const debounce$1 = computed(() => props2.remote ? 300 : 0);
|
|
const emptyText = computed(() => {
|
|
if (props2.loading) {
|
|
return props2.loadingText || t("el.select.loading");
|
|
} else {
|
|
if (props2.remote && !states.inputValue && !hasOptions.value)
|
|
return false;
|
|
if (props2.filterable && states.inputValue && hasOptions.value && filteredOptions.value.length === 0) {
|
|
return props2.noMatchText || t("el.select.noMatch");
|
|
}
|
|
if (!hasOptions.value) {
|
|
return props2.noDataText || t("el.select.noData");
|
|
}
|
|
}
|
|
return null;
|
|
});
|
|
const filterOptions = (query) => {
|
|
const regexp4 = new RegExp(escapeStringRegexp(query), "i");
|
|
const isFilterMethodValid = props2.filterable && isFunction(props2.filterMethod);
|
|
const isRemoteMethodValid = props2.filterable && props2.remote && isFunction(props2.remoteMethod);
|
|
const isValidOption = (o2) => {
|
|
if (isFilterMethodValid || isRemoteMethodValid)
|
|
return true;
|
|
return query ? regexp4.test(getLabel(o2) || "") : true;
|
|
};
|
|
if (props2.loading) {
|
|
return [];
|
|
}
|
|
return [...states.createdOptions, ...props2.options].reduce((all, item) => {
|
|
const options = getOptions(item);
|
|
if (isArray(options)) {
|
|
const filtered = options.filter(isValidOption);
|
|
if (filtered.length > 0) {
|
|
all.push({
|
|
label: getLabel(item),
|
|
type: "Group"
|
|
}, ...filtered);
|
|
}
|
|
} else if (props2.remote || isValidOption(item)) {
|
|
all.push(item);
|
|
}
|
|
return all;
|
|
}, []);
|
|
};
|
|
const updateOptions2 = () => {
|
|
filteredOptions.value = filterOptions(states.inputValue);
|
|
};
|
|
const allOptionsValueMap = computed(() => {
|
|
const valueMap = new Map();
|
|
allOptions.value.forEach((option, index) => {
|
|
valueMap.set(getValueKey(getValue3(option)), { option, index });
|
|
});
|
|
return valueMap;
|
|
});
|
|
const filteredOptionsValueMap = computed(() => {
|
|
const valueMap = new Map();
|
|
filteredOptions.value.forEach((option, index) => {
|
|
valueMap.set(getValueKey(getValue3(option)), { option, index });
|
|
});
|
|
return valueMap;
|
|
});
|
|
const optionsAllDisabled = computed(() => filteredOptions.value.every((option) => getDisabled(option)));
|
|
const selectSize = useFormSize();
|
|
const collapseTagSize = computed(() => selectSize.value === "small" ? "small" : "default");
|
|
const calculatePopperSize = () => {
|
|
var _a2;
|
|
if (isNumber2(props2.fitInputWidth)) {
|
|
popperSize.value = props2.fitInputWidth;
|
|
return;
|
|
}
|
|
const width = ((_a2 = selectRef.value) == null ? void 0 : _a2.offsetWidth) || 200;
|
|
if (!props2.fitInputWidth && hasOptions.value) {
|
|
nextTick(() => {
|
|
popperSize.value = Math.max(width, calculateLabelMaxWidth());
|
|
});
|
|
} else {
|
|
popperSize.value = width;
|
|
}
|
|
};
|
|
const calculateLabelMaxWidth = () => {
|
|
var _a2, _b;
|
|
const canvas = document.createElement("canvas");
|
|
const ctx = canvas.getContext("2d");
|
|
const selector = nsSelect.be("dropdown", "item");
|
|
const dom = ((_b = (_a2 = menuRef.value) == null ? void 0 : _a2.listRef) == null ? void 0 : _b.innerRef) || document;
|
|
const dropdownItemEl = dom.querySelector(`.${selector}`);
|
|
if (dropdownItemEl === null || ctx === null)
|
|
return 0;
|
|
const style = getComputedStyle(dropdownItemEl);
|
|
const padding = Number.parseFloat(style.paddingLeft) + Number.parseFloat(style.paddingRight);
|
|
ctx.font = `bold ${style.font.replace(new RegExp(`\\b${style.fontWeight}\\b`), "")}`;
|
|
const maxWidth = filteredOptions.value.reduce((max4, option) => {
|
|
const metrics = ctx.measureText(getLabel(option));
|
|
return Math.max(metrics.width, max4);
|
|
}, 0);
|
|
return maxWidth + padding;
|
|
};
|
|
const getGapWidth = () => {
|
|
if (!selectionRef.value)
|
|
return 0;
|
|
const style = window.getComputedStyle(selectionRef.value);
|
|
return Number.parseFloat(style.gap || "6px");
|
|
};
|
|
const tagStyle = computed(() => {
|
|
const gapWidth = getGapWidth();
|
|
const maxWidth = collapseItemRef.value && props2.maxCollapseTags === 1 ? states.selectionWidth - states.collapseItemWidth - gapWidth : states.selectionWidth;
|
|
return { maxWidth: `${maxWidth}px` };
|
|
});
|
|
const collapseTagStyle = computed(() => {
|
|
return { maxWidth: `${states.selectionWidth}px` };
|
|
});
|
|
const shouldShowPlaceholder = computed(() => {
|
|
if (isArray(props2.modelValue)) {
|
|
return props2.modelValue.length === 0 && !states.inputValue;
|
|
}
|
|
return props2.filterable ? !states.inputValue : true;
|
|
});
|
|
const currentPlaceholder = computed(() => {
|
|
var _a2;
|
|
const _placeholder = (_a2 = props2.placeholder) != null ? _a2 : t("el.select.placeholder");
|
|
return props2.multiple || !hasModelValue.value ? _placeholder : states.selectedLabel;
|
|
});
|
|
const popperRef = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = tooltipRef.value) == null ? void 0 : _a2.popperRef) == null ? void 0 : _b.contentRef;
|
|
});
|
|
const indexRef = computed(() => {
|
|
if (props2.multiple) {
|
|
const len = props2.modelValue.length;
|
|
if (props2.modelValue.length > 0 && filteredOptionsValueMap.value.has(props2.modelValue[len - 1])) {
|
|
const { index } = filteredOptionsValueMap.value.get(props2.modelValue[len - 1]);
|
|
return index;
|
|
}
|
|
} else {
|
|
if (!isEmptyValue2(props2.modelValue) && filteredOptionsValueMap.value.has(props2.modelValue)) {
|
|
const { index } = filteredOptionsValueMap.value.get(props2.modelValue);
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
});
|
|
const dropdownMenuVisible = computed({
|
|
get() {
|
|
return expanded.value && emptyText.value !== false;
|
|
},
|
|
set(val) {
|
|
expanded.value = val;
|
|
}
|
|
});
|
|
const showTagList = computed(() => {
|
|
if (!props2.multiple) {
|
|
return [];
|
|
}
|
|
return props2.collapseTags ? states.cachedOptions.slice(0, props2.maxCollapseTags) : states.cachedOptions;
|
|
});
|
|
const collapseTagList = computed(() => {
|
|
if (!props2.multiple) {
|
|
return [];
|
|
}
|
|
return props2.collapseTags ? states.cachedOptions.slice(props2.maxCollapseTags) : [];
|
|
});
|
|
const {
|
|
createNewOption,
|
|
removeNewOption,
|
|
selectNewOption,
|
|
clearAllNewOption
|
|
} = useAllowCreate(props2, states);
|
|
const toggleMenu = () => {
|
|
if (selectDisabled.value)
|
|
return;
|
|
if (states.menuVisibleOnFocus) {
|
|
states.menuVisibleOnFocus = false;
|
|
} else {
|
|
expanded.value = !expanded.value;
|
|
}
|
|
};
|
|
const onInputChange = () => {
|
|
if (states.inputValue.length > 0 && !expanded.value) {
|
|
expanded.value = true;
|
|
}
|
|
createNewOption(states.inputValue);
|
|
handleQueryChange(states.inputValue);
|
|
};
|
|
const debouncedOnInputChange = debounce_default(onInputChange, debounce$1.value);
|
|
const handleQueryChange = (val) => {
|
|
if (states.previousQuery === val || isComposing.value) {
|
|
return;
|
|
}
|
|
states.previousQuery = val;
|
|
if (props2.filterable && isFunction(props2.filterMethod)) {
|
|
props2.filterMethod(val);
|
|
} else if (props2.filterable && props2.remote && isFunction(props2.remoteMethod)) {
|
|
props2.remoteMethod(val);
|
|
}
|
|
if (props2.defaultFirstOption && (props2.filterable || props2.remote) && filteredOptions.value.length) {
|
|
nextTick(checkDefaultFirstOption);
|
|
} else {
|
|
nextTick(updateHoveringIndex);
|
|
}
|
|
};
|
|
const checkDefaultFirstOption = () => {
|
|
const optionsInDropdown = filteredOptions.value.filter((n) => !n.disabled && n.type !== "Group");
|
|
const userCreatedOption = optionsInDropdown.find((n) => n.created);
|
|
const firstOriginOption = optionsInDropdown[0];
|
|
states.hoveringIndex = getValueIndex(filteredOptions.value, userCreatedOption || firstOriginOption);
|
|
};
|
|
const emitChange = (val) => {
|
|
if (!isEqual_default(props2.modelValue, val)) {
|
|
emit(CHANGE_EVENT, val);
|
|
}
|
|
};
|
|
const update2 = (val) => {
|
|
emit(UPDATE_MODEL_EVENT, val);
|
|
emitChange(val);
|
|
states.previousValue = props2.multiple ? String(val) : val;
|
|
nextTick(() => {
|
|
if (props2.multiple && isArray(props2.modelValue)) {
|
|
const cachedOptions = states.cachedOptions.slice();
|
|
const selectedOptions = props2.modelValue.map((value) => getOption(value, cachedOptions));
|
|
if (!isEqual_default(states.cachedOptions, selectedOptions)) {
|
|
states.cachedOptions = selectedOptions;
|
|
}
|
|
} else {
|
|
initStates(true);
|
|
}
|
|
});
|
|
};
|
|
const getValueIndex = (arr = [], value) => {
|
|
if (!isObject(value)) {
|
|
return arr.indexOf(value);
|
|
}
|
|
const valueKey = props2.valueKey;
|
|
let index = -1;
|
|
arr.some((item, i) => {
|
|
if (get_default(item, valueKey) === get_default(value, valueKey)) {
|
|
index = i;
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
return index;
|
|
};
|
|
const getValueKey = (item) => {
|
|
return isObject(item) ? get_default(item, props2.valueKey) : item;
|
|
};
|
|
const handleResize = () => {
|
|
calculatePopperSize();
|
|
};
|
|
const resetSelectionWidth = () => {
|
|
states.selectionWidth = Number.parseFloat(window.getComputedStyle(selectionRef.value).width);
|
|
};
|
|
const resetCollapseItemWidth = () => {
|
|
states.collapseItemWidth = collapseItemRef.value.getBoundingClientRect().width;
|
|
};
|
|
const updateTooltip = () => {
|
|
var _a2, _b;
|
|
(_b = (_a2 = tooltipRef.value) == null ? void 0 : _a2.updatePopper) == null ? void 0 : _b.call(_a2);
|
|
};
|
|
const updateTagTooltip = () => {
|
|
var _a2, _b;
|
|
(_b = (_a2 = tagTooltipRef.value) == null ? void 0 : _a2.updatePopper) == null ? void 0 : _b.call(_a2);
|
|
};
|
|
const onSelect = (option) => {
|
|
if (props2.multiple) {
|
|
let selectedOptions = props2.modelValue.slice();
|
|
const index = getValueIndex(selectedOptions, getValue3(option));
|
|
if (index > -1) {
|
|
selectedOptions = [
|
|
...selectedOptions.slice(0, index),
|
|
...selectedOptions.slice(index + 1)
|
|
];
|
|
states.cachedOptions.splice(index, 1);
|
|
removeNewOption(option);
|
|
} else if (props2.multipleLimit <= 0 || selectedOptions.length < props2.multipleLimit) {
|
|
selectedOptions = [...selectedOptions, getValue3(option)];
|
|
states.cachedOptions.push(option);
|
|
selectNewOption(option);
|
|
}
|
|
update2(selectedOptions);
|
|
if (option.created) {
|
|
handleQueryChange("");
|
|
}
|
|
if (props2.filterable && !props2.reserveKeyword) {
|
|
states.inputValue = "";
|
|
}
|
|
} else {
|
|
states.selectedLabel = getLabel(option);
|
|
update2(getValue3(option));
|
|
expanded.value = false;
|
|
selectNewOption(option);
|
|
if (!option.created) {
|
|
clearAllNewOption();
|
|
}
|
|
}
|
|
focus();
|
|
};
|
|
const deleteTag = (event, option) => {
|
|
let selectedOptions = props2.modelValue.slice();
|
|
const index = getValueIndex(selectedOptions, getValue3(option));
|
|
if (index > -1 && !selectDisabled.value) {
|
|
selectedOptions = [
|
|
...props2.modelValue.slice(0, index),
|
|
...props2.modelValue.slice(index + 1)
|
|
];
|
|
states.cachedOptions.splice(index, 1);
|
|
update2(selectedOptions);
|
|
emit("remove-tag", getValue3(option));
|
|
removeNewOption(option);
|
|
}
|
|
event.stopPropagation();
|
|
focus();
|
|
};
|
|
const focus = () => {
|
|
var _a2;
|
|
(_a2 = inputRef.value) == null ? void 0 : _a2.focus();
|
|
};
|
|
const blur = () => {
|
|
var _a2;
|
|
if (expanded.value) {
|
|
expanded.value = false;
|
|
nextTick(() => {
|
|
var _a22;
|
|
return (_a22 = inputRef.value) == null ? void 0 : _a22.blur();
|
|
});
|
|
return;
|
|
}
|
|
(_a2 = inputRef.value) == null ? void 0 : _a2.blur();
|
|
};
|
|
const handleEsc = () => {
|
|
if (states.inputValue.length > 0) {
|
|
states.inputValue = "";
|
|
} else {
|
|
expanded.value = false;
|
|
}
|
|
};
|
|
const getLastNotDisabledIndex = (value) => findLastIndex_default(value, (it2) => !states.cachedOptions.some((option) => getValue3(option) === it2 && getDisabled(option)));
|
|
const handleDel = (e) => {
|
|
if (!props2.multiple)
|
|
return;
|
|
if (e.code === EVENT_CODE.delete)
|
|
return;
|
|
if (states.inputValue.length === 0) {
|
|
e.preventDefault();
|
|
const selected = props2.modelValue.slice();
|
|
const lastNotDisabledIndex = getLastNotDisabledIndex(selected);
|
|
if (lastNotDisabledIndex < 0)
|
|
return;
|
|
const removeTagValue = selected[lastNotDisabledIndex];
|
|
selected.splice(lastNotDisabledIndex, 1);
|
|
const option = states.cachedOptions[lastNotDisabledIndex];
|
|
states.cachedOptions.splice(lastNotDisabledIndex, 1);
|
|
removeNewOption(option);
|
|
update2(selected);
|
|
emit("remove-tag", removeTagValue);
|
|
}
|
|
};
|
|
const handleClear = () => {
|
|
let emptyValue;
|
|
if (isArray(props2.modelValue)) {
|
|
emptyValue = [];
|
|
} else {
|
|
emptyValue = valueOnClear.value;
|
|
}
|
|
states.selectedLabel = "";
|
|
expanded.value = false;
|
|
update2(emptyValue);
|
|
emit("clear");
|
|
clearAllNewOption();
|
|
focus();
|
|
};
|
|
const onKeyboardNavigate = (direction2, hoveringIndex = void 0) => {
|
|
const options = filteredOptions.value;
|
|
if (!["forward", "backward"].includes(direction2) || selectDisabled.value || options.length <= 0 || optionsAllDisabled.value || isComposing.value) {
|
|
return;
|
|
}
|
|
if (!expanded.value) {
|
|
return toggleMenu();
|
|
}
|
|
if (isUndefined2(hoveringIndex)) {
|
|
hoveringIndex = states.hoveringIndex;
|
|
}
|
|
let newIndex = -1;
|
|
if (direction2 === "forward") {
|
|
newIndex = hoveringIndex + 1;
|
|
if (newIndex >= options.length) {
|
|
newIndex = 0;
|
|
}
|
|
} else if (direction2 === "backward") {
|
|
newIndex = hoveringIndex - 1;
|
|
if (newIndex < 0 || newIndex >= options.length) {
|
|
newIndex = options.length - 1;
|
|
}
|
|
}
|
|
const option = options[newIndex];
|
|
if (getDisabled(option) || option.type === "Group") {
|
|
return onKeyboardNavigate(direction2, newIndex);
|
|
} else {
|
|
states.hoveringIndex = newIndex;
|
|
scrollToItem(newIndex);
|
|
}
|
|
};
|
|
const onKeyboardSelect = () => {
|
|
if (!expanded.value) {
|
|
return toggleMenu();
|
|
} else if (~states.hoveringIndex && filteredOptions.value[states.hoveringIndex]) {
|
|
onSelect(filteredOptions.value[states.hoveringIndex]);
|
|
}
|
|
};
|
|
const onHoverOption = (idx) => {
|
|
states.hoveringIndex = idx != null ? idx : -1;
|
|
};
|
|
const updateHoveringIndex = () => {
|
|
if (!props2.multiple) {
|
|
states.hoveringIndex = filteredOptions.value.findIndex((item) => {
|
|
return getValueKey(getValue3(item)) === getValueKey(props2.modelValue);
|
|
});
|
|
} else {
|
|
states.hoveringIndex = filteredOptions.value.findIndex((item) => props2.modelValue.some((modelValue) => getValueKey(modelValue) === getValueKey(getValue3(item))));
|
|
}
|
|
};
|
|
const onInput = (event) => {
|
|
states.inputValue = event.target.value;
|
|
if (props2.remote) {
|
|
debouncedOnInputChange();
|
|
} else {
|
|
return onInputChange();
|
|
}
|
|
};
|
|
const handleClickOutside = (event) => {
|
|
expanded.value = false;
|
|
if (isFocused.value) {
|
|
const _event2 = new FocusEvent("focus", event);
|
|
handleBlur(_event2);
|
|
}
|
|
};
|
|
const handleMenuEnter = () => {
|
|
states.isBeforeHide = false;
|
|
return nextTick(() => {
|
|
if (~indexRef.value) {
|
|
scrollToItem(states.hoveringIndex);
|
|
}
|
|
});
|
|
};
|
|
const scrollToItem = (index) => {
|
|
menuRef.value.scrollToItem(index);
|
|
};
|
|
const getOption = (value, cachedOptions) => {
|
|
const selectValue = getValueKey(value);
|
|
if (allOptionsValueMap.value.has(selectValue)) {
|
|
const { option } = allOptionsValueMap.value.get(selectValue);
|
|
return option;
|
|
}
|
|
if (cachedOptions && cachedOptions.length) {
|
|
const option = cachedOptions.find((option2) => getValueKey(getValue3(option2)) === selectValue);
|
|
if (option) {
|
|
return option;
|
|
}
|
|
}
|
|
return {
|
|
[aliasProps.value.value]: value,
|
|
[aliasProps.value.label]: value
|
|
};
|
|
};
|
|
const initStates = (needUpdateSelectedLabel = false) => {
|
|
if (props2.multiple) {
|
|
if (props2.modelValue.length > 0) {
|
|
const cachedOptions = states.cachedOptions.slice();
|
|
states.cachedOptions.length = 0;
|
|
states.previousValue = props2.modelValue.toString();
|
|
for (const value of props2.modelValue) {
|
|
const option = getOption(value, cachedOptions);
|
|
states.cachedOptions.push(option);
|
|
}
|
|
} else {
|
|
states.cachedOptions = [];
|
|
states.previousValue = void 0;
|
|
}
|
|
} else {
|
|
if (hasModelValue.value) {
|
|
states.previousValue = props2.modelValue;
|
|
const options = filteredOptions.value;
|
|
const selectedItemIndex = options.findIndex((option) => getValueKey(getValue3(option)) === getValueKey(props2.modelValue));
|
|
if (~selectedItemIndex) {
|
|
states.selectedLabel = getLabel(options[selectedItemIndex]);
|
|
} else {
|
|
if (!states.selectedLabel || needUpdateSelectedLabel) {
|
|
states.selectedLabel = getValueKey(props2.modelValue);
|
|
}
|
|
}
|
|
} else {
|
|
states.selectedLabel = "";
|
|
states.previousValue = void 0;
|
|
}
|
|
}
|
|
clearAllNewOption();
|
|
calculatePopperSize();
|
|
};
|
|
watch(() => props2.fitInputWidth, () => {
|
|
calculatePopperSize();
|
|
});
|
|
watch(expanded, (val) => {
|
|
if (val) {
|
|
if (!props2.persistent) {
|
|
calculatePopperSize();
|
|
}
|
|
handleQueryChange("");
|
|
} else {
|
|
states.inputValue = "";
|
|
states.previousQuery = null;
|
|
states.isBeforeHide = true;
|
|
createNewOption("");
|
|
}
|
|
emit("visible-change", val);
|
|
});
|
|
watch(() => props2.modelValue, (val, oldVal) => {
|
|
var _a2;
|
|
const isValEmpty = !val || isArray(val) && val.length === 0;
|
|
if (isValEmpty || props2.multiple && !isEqual_default(val.toString(), states.previousValue) || !props2.multiple && getValueKey(val) !== getValueKey(states.previousValue)) {
|
|
initStates(true);
|
|
}
|
|
if (!isEqual_default(val, oldVal) && props2.validateEvent) {
|
|
(_a2 = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a2.call(elFormItem, "change").catch((err) => debugWarn(err));
|
|
}
|
|
}, {
|
|
deep: true
|
|
});
|
|
watch(() => props2.options, () => {
|
|
const input = inputRef.value;
|
|
if (!input || input && document.activeElement !== input) {
|
|
initStates();
|
|
}
|
|
}, {
|
|
deep: true,
|
|
flush: "post"
|
|
});
|
|
watch(() => filteredOptions.value, () => {
|
|
calculatePopperSize();
|
|
return menuRef.value && nextTick(menuRef.value.resetScrollTop);
|
|
});
|
|
watchEffect(() => {
|
|
if (states.isBeforeHide)
|
|
return;
|
|
updateOptions2();
|
|
});
|
|
watchEffect(() => {
|
|
const { valueKey, options } = props2;
|
|
const duplicateValue = new Map();
|
|
for (const item of options) {
|
|
const optionValue = getValue3(item);
|
|
let v2 = optionValue;
|
|
if (isObject(v2)) {
|
|
v2 = get_default(optionValue, valueKey);
|
|
}
|
|
if (duplicateValue.get(v2)) {
|
|
debugWarn("ElSelectV2", `The option values you provided seem to be duplicated, which may cause some problems, please check.`);
|
|
break;
|
|
} else {
|
|
duplicateValue.set(v2, true);
|
|
}
|
|
}
|
|
});
|
|
onMounted(() => {
|
|
initStates();
|
|
});
|
|
useResizeObserver(selectRef, handleResize);
|
|
useResizeObserver(selectionRef, resetSelectionWidth);
|
|
useResizeObserver(menuRef, updateTooltip);
|
|
useResizeObserver(wrapperRef, updateTooltip);
|
|
useResizeObserver(tagMenuRef, updateTagTooltip);
|
|
useResizeObserver(collapseItemRef, resetCollapseItemWidth);
|
|
return {
|
|
inputId,
|
|
collapseTagSize,
|
|
currentPlaceholder,
|
|
expanded,
|
|
emptyText,
|
|
popupHeight,
|
|
debounce: debounce$1,
|
|
allOptions,
|
|
filteredOptions,
|
|
iconComponent,
|
|
iconReverse,
|
|
tagStyle,
|
|
collapseTagStyle,
|
|
popperSize,
|
|
dropdownMenuVisible,
|
|
hasModelValue,
|
|
shouldShowPlaceholder,
|
|
selectDisabled,
|
|
selectSize,
|
|
needStatusIcon,
|
|
showClearBtn,
|
|
states,
|
|
isFocused,
|
|
nsSelect,
|
|
nsInput,
|
|
inputRef,
|
|
menuRef,
|
|
tagMenuRef,
|
|
tooltipRef,
|
|
tagTooltipRef,
|
|
selectRef,
|
|
wrapperRef,
|
|
selectionRef,
|
|
prefixRef,
|
|
suffixRef,
|
|
collapseItemRef,
|
|
popperRef,
|
|
validateState,
|
|
validateIcon,
|
|
showTagList,
|
|
collapseTagList,
|
|
debouncedOnInputChange,
|
|
deleteTag,
|
|
getLabel,
|
|
getValue: getValue3,
|
|
getDisabled,
|
|
getValueKey,
|
|
handleClear,
|
|
handleClickOutside,
|
|
handleDel,
|
|
handleEsc,
|
|
focus,
|
|
blur,
|
|
handleMenuEnter,
|
|
handleResize,
|
|
resetSelectionWidth,
|
|
updateTooltip,
|
|
updateTagTooltip,
|
|
updateOptions: updateOptions2,
|
|
toggleMenu,
|
|
scrollTo: scrollToItem,
|
|
onInput,
|
|
onKeyboardNavigate,
|
|
onKeyboardSelect,
|
|
onSelect,
|
|
onHover: onHoverOption,
|
|
handleCompositionStart,
|
|
handleCompositionEnd,
|
|
handleCompositionUpdate
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/select-v2/src/select.mjs
|
|
var _sfc_main114 = defineComponent({
|
|
name: "ElSelectV2",
|
|
components: {
|
|
ElSelectMenu: ElSelectMenu2,
|
|
ElTag,
|
|
ElTooltip,
|
|
ElIcon
|
|
},
|
|
directives: { ClickOutside },
|
|
props: SelectProps2,
|
|
emits: selectEmits2,
|
|
setup(props2, { emit }) {
|
|
const modelValue = computed(() => {
|
|
const { modelValue: rawModelValue, multiple } = props2;
|
|
const fallback = multiple ? [] : void 0;
|
|
if (isArray(rawModelValue)) {
|
|
return multiple ? rawModelValue : fallback;
|
|
}
|
|
return multiple ? fallback : rawModelValue;
|
|
});
|
|
const API = useSelect2(reactive({
|
|
...toRefs(props2),
|
|
modelValue
|
|
}), emit);
|
|
const { calculatorRef, inputStyle } = useCalcInputWidth();
|
|
provide(selectV2InjectionKey, {
|
|
props: reactive({
|
|
...toRefs(props2),
|
|
height: API.popupHeight,
|
|
modelValue
|
|
}),
|
|
expanded: API.expanded,
|
|
tooltipRef: API.tooltipRef,
|
|
onSelect: API.onSelect,
|
|
onHover: API.onHover,
|
|
onKeyboardNavigate: API.onKeyboardNavigate,
|
|
onKeyboardSelect: API.onKeyboardSelect
|
|
});
|
|
const selectedLabel = computed(() => {
|
|
if (!props2.multiple) {
|
|
return API.states.selectedLabel;
|
|
}
|
|
return API.states.cachedOptions.map((i) => i.label);
|
|
});
|
|
return {
|
|
...API,
|
|
modelValue,
|
|
selectedLabel,
|
|
calculatorRef,
|
|
inputStyle
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render23(_ctx, _cache, $props, $setup, $data, $options) {
|
|
const _component_el_tag = resolveComponent("el-tag");
|
|
const _component_el_tooltip = resolveComponent("el-tooltip");
|
|
const _component_el_icon = resolveComponent("el-icon");
|
|
const _component_el_select_menu = resolveComponent("el-select-menu");
|
|
const _directive_click_outside = resolveDirective("click-outside");
|
|
return withDirectives((openBlock(), createElementBlock("div", {
|
|
ref: "selectRef",
|
|
class: normalizeClass([_ctx.nsSelect.b(), _ctx.nsSelect.m(_ctx.selectSize)]),
|
|
onMouseenter: ($event) => _ctx.states.inputHovering = true,
|
|
onMouseleave: ($event) => _ctx.states.inputHovering = false
|
|
}, [
|
|
createVNode(_component_el_tooltip, {
|
|
ref: "tooltipRef",
|
|
visible: _ctx.dropdownMenuVisible,
|
|
teleported: _ctx.teleported,
|
|
"popper-class": [_ctx.nsSelect.e("popper"), _ctx.popperClass],
|
|
"gpu-acceleration": false,
|
|
"stop-popper-mouse-event": false,
|
|
"popper-options": _ctx.popperOptions,
|
|
"fallback-placements": _ctx.fallbackPlacements,
|
|
effect: _ctx.effect,
|
|
placement: _ctx.placement,
|
|
pure: "",
|
|
transition: `${_ctx.nsSelect.namespace.value}-zoom-in-top`,
|
|
trigger: "click",
|
|
persistent: _ctx.persistent,
|
|
"append-to": _ctx.appendTo,
|
|
"show-arrow": _ctx.showArrow,
|
|
offset: _ctx.offset,
|
|
onBeforeShow: _ctx.handleMenuEnter,
|
|
onHide: ($event) => _ctx.states.isBeforeHide = false
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
ref: "wrapperRef",
|
|
class: normalizeClass([
|
|
_ctx.nsSelect.e("wrapper"),
|
|
_ctx.nsSelect.is("focused", _ctx.isFocused),
|
|
_ctx.nsSelect.is("hovering", _ctx.states.inputHovering),
|
|
_ctx.nsSelect.is("filterable", _ctx.filterable),
|
|
_ctx.nsSelect.is("disabled", _ctx.selectDisabled)
|
|
]),
|
|
onClick: withModifiers(_ctx.toggleMenu, ["prevent"])
|
|
}, [
|
|
_ctx.$slots.prefix ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
ref: "prefixRef",
|
|
class: normalizeClass(_ctx.nsSelect.e("prefix"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "prefix")
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
ref: "selectionRef",
|
|
class: normalizeClass([
|
|
_ctx.nsSelect.e("selection"),
|
|
_ctx.nsSelect.is("near", _ctx.multiple && !_ctx.$slots.prefix && !!_ctx.modelValue.length)
|
|
])
|
|
}, [
|
|
_ctx.multiple ? renderSlot(_ctx.$slots, "tag", { key: 0 }, () => [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.showTagList, (item) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
key: _ctx.getValueKey(_ctx.getValue(item)),
|
|
class: normalizeClass(_ctx.nsSelect.e("selected-item"))
|
|
}, [
|
|
createVNode(_component_el_tag, {
|
|
closable: !_ctx.selectDisabled && !_ctx.getDisabled(item),
|
|
size: _ctx.collapseTagSize,
|
|
type: _ctx.tagType,
|
|
effect: _ctx.tagEffect,
|
|
"disable-transitions": "",
|
|
style: normalizeStyle(_ctx.tagStyle),
|
|
onClose: ($event) => _ctx.deleteTag($event, item)
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(_ctx.nsSelect.e("tags-text"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "label", {
|
|
label: _ctx.getLabel(item),
|
|
value: _ctx.getValue(item)
|
|
}, () => [
|
|
createTextVNode(toDisplayString(_ctx.getLabel(item)), 1)
|
|
])
|
|
], 2)
|
|
]),
|
|
_: 2
|
|
}, 1032, ["closable", "size", "type", "effect", "style", "onClose"])
|
|
], 2);
|
|
}), 128)),
|
|
_ctx.collapseTags && _ctx.modelValue.length > _ctx.maxCollapseTags ? (openBlock(), createBlock(_component_el_tooltip, {
|
|
key: 0,
|
|
ref: "tagTooltipRef",
|
|
disabled: _ctx.dropdownMenuVisible || !_ctx.collapseTagsTooltip,
|
|
"fallback-placements": ["bottom", "top", "right", "left"],
|
|
effect: _ctx.effect,
|
|
placement: "bottom",
|
|
teleported: _ctx.teleported
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
ref: "collapseItemRef",
|
|
class: normalizeClass(_ctx.nsSelect.e("selected-item"))
|
|
}, [
|
|
createVNode(_component_el_tag, {
|
|
closable: false,
|
|
size: _ctx.collapseTagSize,
|
|
type: _ctx.tagType,
|
|
effect: _ctx.tagEffect,
|
|
style: normalizeStyle(_ctx.collapseTagStyle),
|
|
"disable-transitions": ""
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(_ctx.nsSelect.e("tags-text"))
|
|
}, " + " + toDisplayString(_ctx.modelValue.length - _ctx.maxCollapseTags), 3)
|
|
]),
|
|
_: 1
|
|
}, 8, ["size", "type", "effect", "style"])
|
|
], 2)
|
|
]),
|
|
content: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
ref: "tagMenuRef",
|
|
class: normalizeClass(_ctx.nsSelect.e("selection"))
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.collapseTagList, (selected) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
key: _ctx.getValueKey(_ctx.getValue(selected)),
|
|
class: normalizeClass(_ctx.nsSelect.e("selected-item"))
|
|
}, [
|
|
createVNode(_component_el_tag, {
|
|
class: "in-tooltip",
|
|
closable: !_ctx.selectDisabled && !_ctx.getDisabled(selected),
|
|
size: _ctx.collapseTagSize,
|
|
type: _ctx.tagType,
|
|
effect: _ctx.tagEffect,
|
|
"disable-transitions": "",
|
|
onClose: ($event) => _ctx.deleteTag($event, selected)
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(_ctx.nsSelect.e("tags-text"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "label", {
|
|
label: _ctx.getLabel(selected),
|
|
value: _ctx.getValue(selected)
|
|
}, () => [
|
|
createTextVNode(toDisplayString(_ctx.getLabel(selected)), 1)
|
|
])
|
|
], 2)
|
|
]),
|
|
_: 2
|
|
}, 1032, ["closable", "size", "type", "effect", "onClose"])
|
|
], 2);
|
|
}), 128))
|
|
], 2)
|
|
]),
|
|
_: 3
|
|
}, 8, ["disabled", "effect", "teleported"])) : createCommentVNode("v-if", true)
|
|
]) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([
|
|
_ctx.nsSelect.e("selected-item"),
|
|
_ctx.nsSelect.e("input-wrapper"),
|
|
_ctx.nsSelect.is("hidden", !_ctx.filterable)
|
|
])
|
|
}, [
|
|
withDirectives(createBaseVNode("input", {
|
|
id: _ctx.inputId,
|
|
ref: "inputRef",
|
|
"onUpdate:modelValue": ($event) => _ctx.states.inputValue = $event,
|
|
style: normalizeStyle(_ctx.inputStyle),
|
|
autocomplete: _ctx.autocomplete,
|
|
tabindex: _ctx.tabindex,
|
|
"aria-autocomplete": "list",
|
|
"aria-haspopup": "listbox",
|
|
autocapitalize: "off",
|
|
"aria-expanded": _ctx.expanded,
|
|
"aria-label": _ctx.ariaLabel,
|
|
class: normalizeClass([_ctx.nsSelect.e("input"), _ctx.nsSelect.is(_ctx.selectSize)]),
|
|
disabled: _ctx.selectDisabled,
|
|
role: "combobox",
|
|
readonly: !_ctx.filterable,
|
|
spellcheck: "false",
|
|
type: "text",
|
|
name: _ctx.name,
|
|
onInput: _ctx.onInput,
|
|
onCompositionstart: _ctx.handleCompositionStart,
|
|
onCompositionupdate: _ctx.handleCompositionUpdate,
|
|
onCompositionend: _ctx.handleCompositionEnd,
|
|
onKeydown: [
|
|
withKeys(withModifiers(($event) => _ctx.onKeyboardNavigate("backward"), ["stop", "prevent"]), ["up"]),
|
|
withKeys(withModifiers(($event) => _ctx.onKeyboardNavigate("forward"), ["stop", "prevent"]), ["down"]),
|
|
withKeys(withModifiers(_ctx.onKeyboardSelect, ["stop", "prevent"]), ["enter"]),
|
|
withKeys(withModifiers(_ctx.handleEsc, ["stop", "prevent"]), ["esc"]),
|
|
withKeys(withModifiers(_ctx.handleDel, ["stop"]), ["delete"])
|
|
],
|
|
onClick: withModifiers(_ctx.toggleMenu, ["stop"])
|
|
}, null, 46, ["id", "onUpdate:modelValue", "autocomplete", "tabindex", "aria-expanded", "aria-label", "disabled", "readonly", "name", "onInput", "onCompositionstart", "onCompositionupdate", "onCompositionend", "onKeydown", "onClick"]), [
|
|
[vModelText, _ctx.states.inputValue]
|
|
]),
|
|
_ctx.filterable ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
ref: "calculatorRef",
|
|
"aria-hidden": "true",
|
|
class: normalizeClass(_ctx.nsSelect.e("input-calculator")),
|
|
textContent: toDisplayString(_ctx.states.inputValue)
|
|
}, null, 10, ["textContent"])) : createCommentVNode("v-if", true)
|
|
], 2),
|
|
_ctx.shouldShowPlaceholder ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass([
|
|
_ctx.nsSelect.e("selected-item"),
|
|
_ctx.nsSelect.e("placeholder"),
|
|
_ctx.nsSelect.is("transparent", !_ctx.hasModelValue || _ctx.expanded && !_ctx.states.inputValue)
|
|
])
|
|
}, [
|
|
_ctx.hasModelValue ? renderSlot(_ctx.$slots, "label", {
|
|
key: 0,
|
|
label: _ctx.currentPlaceholder,
|
|
value: _ctx.modelValue
|
|
}, () => [
|
|
createBaseVNode("span", null, toDisplayString(_ctx.currentPlaceholder), 1)
|
|
]) : (openBlock(), createElementBlock("span", { key: 1 }, toDisplayString(_ctx.currentPlaceholder), 1))
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 2),
|
|
createBaseVNode("div", {
|
|
ref: "suffixRef",
|
|
class: normalizeClass(_ctx.nsSelect.e("suffix"))
|
|
}, [
|
|
_ctx.iconComponent ? withDirectives((openBlock(), createBlock(_component_el_icon, {
|
|
key: 0,
|
|
class: normalizeClass([_ctx.nsSelect.e("caret"), _ctx.nsInput.e("icon"), _ctx.iconReverse])
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.iconComponent)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])), [
|
|
[vShow, !_ctx.showClearBtn]
|
|
]) : createCommentVNode("v-if", true),
|
|
_ctx.showClearBtn && _ctx.clearIcon ? (openBlock(), createBlock(_component_el_icon, {
|
|
key: 1,
|
|
class: normalizeClass([
|
|
_ctx.nsSelect.e("caret"),
|
|
_ctx.nsInput.e("icon"),
|
|
_ctx.nsSelect.e("clear")
|
|
]),
|
|
onClick: withModifiers(_ctx.handleClear, ["prevent", "stop"])
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.clearIcon)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "onClick"])) : createCommentVNode("v-if", true),
|
|
_ctx.validateState && _ctx.validateIcon && _ctx.needStatusIcon ? (openBlock(), createBlock(_component_el_icon, {
|
|
key: 2,
|
|
class: normalizeClass([
|
|
_ctx.nsInput.e("icon"),
|
|
_ctx.nsInput.e("validateIcon"),
|
|
_ctx.nsInput.is("loading", _ctx.validateState === "validating")
|
|
])
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.validateIcon)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true)
|
|
], 2)
|
|
], 10, ["onClick"])
|
|
]),
|
|
content: withCtx(() => [
|
|
createVNode(_component_el_select_menu, {
|
|
ref: "menuRef",
|
|
data: _ctx.filteredOptions,
|
|
width: _ctx.popperSize,
|
|
"hovering-index": _ctx.states.hoveringIndex,
|
|
"scrollbar-always-on": _ctx.scrollbarAlwaysOn
|
|
}, createSlots({
|
|
default: withCtx((scope) => [
|
|
renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(scope)))
|
|
]),
|
|
_: 2
|
|
}, [
|
|
_ctx.$slots.header ? {
|
|
name: "header",
|
|
fn: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.nsSelect.be("dropdown", "header"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "header")
|
|
], 2)
|
|
])
|
|
} : void 0,
|
|
_ctx.$slots.loading && _ctx.loading ? {
|
|
name: "loading",
|
|
fn: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.nsSelect.be("dropdown", "loading"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "loading")
|
|
], 2)
|
|
])
|
|
} : _ctx.loading || _ctx.filteredOptions.length === 0 ? {
|
|
name: "empty",
|
|
fn: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.nsSelect.be("dropdown", "empty"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "empty", {}, () => [
|
|
createBaseVNode("span", null, toDisplayString(_ctx.emptyText), 1)
|
|
])
|
|
], 2)
|
|
])
|
|
} : void 0,
|
|
_ctx.$slots.footer ? {
|
|
name: "footer",
|
|
fn: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.nsSelect.be("dropdown", "footer"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "footer")
|
|
], 2)
|
|
])
|
|
} : void 0
|
|
]), 1032, ["data", "width", "hovering-index", "scrollbar-always-on"])
|
|
]),
|
|
_: 3
|
|
}, 8, ["visible", "teleported", "popper-class", "popper-options", "fallback-placements", "effect", "placement", "transition", "persistent", "append-to", "show-arrow", "offset", "onBeforeShow", "onHide"])
|
|
], 42, ["onMouseenter", "onMouseleave"])), [
|
|
[_directive_click_outside, _ctx.handleClickOutside, _ctx.popperRef]
|
|
]);
|
|
}
|
|
var Select2 = _export_sfc(_sfc_main114, [["render", _sfc_render23], ["__file", "select.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/select-v2/index.mjs
|
|
var ElSelectV2 = withInstall(Select2);
|
|
|
|
// node_modules/element-plus/es/components/skeleton/src/skeleton.mjs
|
|
var skeletonProps = buildProps({
|
|
animated: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
count: {
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
rows: {
|
|
type: Number,
|
|
default: 3
|
|
},
|
|
loading: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
throttle: {
|
|
type: definePropType([Number, Object])
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/skeleton/src/skeleton-item.mjs
|
|
var skeletonItemProps = buildProps({
|
|
variant: {
|
|
type: String,
|
|
values: [
|
|
"circle",
|
|
"rect",
|
|
"h1",
|
|
"h3",
|
|
"text",
|
|
"caption",
|
|
"p",
|
|
"image",
|
|
"button"
|
|
],
|
|
default: "text"
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/hooks/use-throttle-render/index.mjs
|
|
var useThrottleRender = (loading, throttle2 = 0) => {
|
|
if (throttle2 === 0)
|
|
return loading;
|
|
const initVal = isObject(throttle2) && Boolean(throttle2.initVal);
|
|
const throttled = ref(initVal);
|
|
let timeoutHandle = null;
|
|
const dispatchThrottling = (timer) => {
|
|
if (isUndefined2(timer)) {
|
|
throttled.value = loading.value;
|
|
return;
|
|
}
|
|
if (timeoutHandle) {
|
|
clearTimeout(timeoutHandle);
|
|
}
|
|
timeoutHandle = setTimeout(() => {
|
|
throttled.value = loading.value;
|
|
}, timer);
|
|
};
|
|
const dispatcher = (type4) => {
|
|
if (type4 === "leading") {
|
|
if (isNumber2(throttle2)) {
|
|
dispatchThrottling(throttle2);
|
|
} else {
|
|
dispatchThrottling(throttle2.leading);
|
|
}
|
|
} else {
|
|
if (isObject(throttle2)) {
|
|
dispatchThrottling(throttle2.trailing);
|
|
} else {
|
|
throttled.value = false;
|
|
}
|
|
}
|
|
};
|
|
onMounted(() => dispatcher("leading"));
|
|
watch(() => loading.value, (val) => {
|
|
dispatcher(val ? "leading" : "trailing");
|
|
});
|
|
return throttled;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/skeleton/src/skeleton-item2.mjs
|
|
var __default__81 = defineComponent({
|
|
name: "ElSkeletonItem"
|
|
});
|
|
var _sfc_main115 = defineComponent({
|
|
...__default__81,
|
|
props: skeletonItemProps,
|
|
setup(__props) {
|
|
const ns = useNamespace("skeleton");
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([unref(ns).e("item"), unref(ns).e(_ctx.variant)])
|
|
}, [
|
|
_ctx.variant === "image" ? (openBlock(), createBlock(unref(picture_filled_default), { key: 0 })) : createCommentVNode("v-if", true)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var SkeletonItem = _export_sfc(_sfc_main115, [["__file", "skeleton-item.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/skeleton/src/skeleton2.mjs
|
|
var __default__82 = defineComponent({
|
|
name: "ElSkeleton"
|
|
});
|
|
var _sfc_main116 = defineComponent({
|
|
...__default__82,
|
|
props: skeletonProps,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("skeleton");
|
|
const uiLoading = useThrottleRender(toRef(props2, "loading"), props2.throttle);
|
|
expose({
|
|
uiLoading
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return unref(uiLoading) ? (openBlock(), createElementBlock("div", mergeProps({
|
|
key: 0,
|
|
class: [unref(ns).b(), unref(ns).is("animated", _ctx.animated)]
|
|
}, _ctx.$attrs), [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.count, (i) => {
|
|
return openBlock(), createElementBlock(Fragment, { key: i }, [
|
|
unref(uiLoading) ? renderSlot(_ctx.$slots, "template", { key: i }, () => [
|
|
createVNode(SkeletonItem, {
|
|
class: normalizeClass(unref(ns).is("first")),
|
|
variant: "p"
|
|
}, null, 8, ["class"]),
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.rows, (item) => {
|
|
return openBlock(), createBlock(SkeletonItem, {
|
|
key: item,
|
|
class: normalizeClass([
|
|
unref(ns).e("paragraph"),
|
|
unref(ns).is("last", item === _ctx.rows && _ctx.rows > 1)
|
|
]),
|
|
variant: "p"
|
|
}, null, 8, ["class"]);
|
|
}), 128))
|
|
]) : createCommentVNode("v-if", true)
|
|
], 64);
|
|
}), 128))
|
|
], 16)) : renderSlot(_ctx.$slots, "default", normalizeProps(mergeProps({ key: 1 }, _ctx.$attrs)));
|
|
};
|
|
}
|
|
});
|
|
var Skeleton = _export_sfc(_sfc_main116, [["__file", "skeleton.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/skeleton/index.mjs
|
|
var ElSkeleton = withInstall(Skeleton, {
|
|
SkeletonItem
|
|
});
|
|
var ElSkeletonItem = withNoopInstall(SkeletonItem);
|
|
|
|
// node_modules/element-plus/es/components/slider/src/constants.mjs
|
|
var sliderContextKey = Symbol("sliderContextKey");
|
|
|
|
// node_modules/element-plus/es/components/slider/src/slider.mjs
|
|
var sliderProps = buildProps({
|
|
modelValue: {
|
|
type: definePropType([Number, Array]),
|
|
default: 0
|
|
},
|
|
id: {
|
|
type: String,
|
|
default: void 0
|
|
},
|
|
min: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
max: {
|
|
type: Number,
|
|
default: 100
|
|
},
|
|
step: {
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
showInput: Boolean,
|
|
showInputControls: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
size: useSizeProp,
|
|
inputSize: useSizeProp,
|
|
showStops: Boolean,
|
|
showTooltip: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
formatTooltip: {
|
|
type: definePropType(Function),
|
|
default: void 0
|
|
},
|
|
disabled: Boolean,
|
|
range: Boolean,
|
|
vertical: Boolean,
|
|
height: String,
|
|
debounce: {
|
|
type: Number,
|
|
default: 300
|
|
},
|
|
rangeStartLabel: {
|
|
type: String,
|
|
default: void 0
|
|
},
|
|
rangeEndLabel: {
|
|
type: String,
|
|
default: void 0
|
|
},
|
|
formatValueText: {
|
|
type: definePropType(Function),
|
|
default: void 0
|
|
},
|
|
tooltipClass: {
|
|
type: String,
|
|
default: void 0
|
|
},
|
|
placement: {
|
|
type: String,
|
|
values: Ee,
|
|
default: "top"
|
|
},
|
|
marks: {
|
|
type: definePropType(Object)
|
|
},
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
persistent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
...useAriaProps(["ariaLabel"])
|
|
});
|
|
var isValidValue = (value) => isNumber2(value) || isArray(value) && value.every(isNumber2);
|
|
var sliderEmits = {
|
|
[UPDATE_MODEL_EVENT]: isValidValue,
|
|
[INPUT_EVENT]: isValidValue,
|
|
[CHANGE_EVENT]: isValidValue
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/slider/src/button.mjs
|
|
var sliderButtonProps = buildProps({
|
|
modelValue: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
vertical: Boolean,
|
|
tooltipClass: String,
|
|
placement: {
|
|
type: String,
|
|
values: Ee,
|
|
default: "top"
|
|
}
|
|
});
|
|
var sliderButtonEmits = {
|
|
[UPDATE_MODEL_EVENT]: (value) => isNumber2(value)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/slider/src/composables/use-slider-button.mjs
|
|
var useTooltip = (props2, formatTooltip, showTooltip) => {
|
|
const tooltip = ref();
|
|
const tooltipVisible = ref(false);
|
|
const enableFormat = computed(() => {
|
|
return formatTooltip.value instanceof Function;
|
|
});
|
|
const formatValue = computed(() => {
|
|
return enableFormat.value && formatTooltip.value(props2.modelValue) || props2.modelValue;
|
|
});
|
|
const displayTooltip = debounce_default(() => {
|
|
showTooltip.value && (tooltipVisible.value = true);
|
|
}, 50);
|
|
const hideTooltip = debounce_default(() => {
|
|
showTooltip.value && (tooltipVisible.value = false);
|
|
}, 50);
|
|
return {
|
|
tooltip,
|
|
tooltipVisible,
|
|
formatValue,
|
|
displayTooltip,
|
|
hideTooltip
|
|
};
|
|
};
|
|
var useSliderButton = (props2, initData, emit) => {
|
|
const {
|
|
disabled,
|
|
min: min4,
|
|
max: max4,
|
|
step,
|
|
showTooltip,
|
|
persistent,
|
|
precision,
|
|
sliderSize,
|
|
formatTooltip,
|
|
emitChange,
|
|
resetSize,
|
|
updateDragging
|
|
} = inject(sliderContextKey);
|
|
const { tooltip, tooltipVisible, formatValue, displayTooltip, hideTooltip } = useTooltip(props2, formatTooltip, showTooltip);
|
|
const button = ref();
|
|
const currentPosition = computed(() => {
|
|
return `${(props2.modelValue - min4.value) / (max4.value - min4.value) * 100}%`;
|
|
});
|
|
const wrapperStyle = computed(() => {
|
|
return props2.vertical ? { bottom: currentPosition.value } : { left: currentPosition.value };
|
|
});
|
|
const handleMouseEnter = () => {
|
|
initData.hovering = true;
|
|
displayTooltip();
|
|
};
|
|
const handleMouseLeave = () => {
|
|
initData.hovering = false;
|
|
if (!initData.dragging) {
|
|
hideTooltip();
|
|
}
|
|
};
|
|
const onButtonDown = (event) => {
|
|
if (disabled.value)
|
|
return;
|
|
event.preventDefault();
|
|
onDragStart(event);
|
|
window.addEventListener("mousemove", onDragging);
|
|
window.addEventListener("touchmove", onDragging);
|
|
window.addEventListener("mouseup", onDragEnd);
|
|
window.addEventListener("touchend", onDragEnd);
|
|
window.addEventListener("contextmenu", onDragEnd);
|
|
button.value.focus();
|
|
};
|
|
const incrementPosition = (amount) => {
|
|
if (disabled.value)
|
|
return;
|
|
initData.newPosition = Number.parseFloat(currentPosition.value) + amount / (max4.value - min4.value) * 100;
|
|
setPosition(initData.newPosition);
|
|
emitChange();
|
|
};
|
|
const onLeftKeyDown = () => {
|
|
incrementPosition(-step.value);
|
|
};
|
|
const onRightKeyDown = () => {
|
|
incrementPosition(step.value);
|
|
};
|
|
const onPageDownKeyDown = () => {
|
|
incrementPosition(-step.value * 4);
|
|
};
|
|
const onPageUpKeyDown = () => {
|
|
incrementPosition(step.value * 4);
|
|
};
|
|
const onHomeKeyDown = () => {
|
|
if (disabled.value)
|
|
return;
|
|
setPosition(0);
|
|
emitChange();
|
|
};
|
|
const onEndKeyDown = () => {
|
|
if (disabled.value)
|
|
return;
|
|
setPosition(100);
|
|
emitChange();
|
|
};
|
|
const onKeyDown = (event) => {
|
|
let isPreventDefault = true;
|
|
switch (event.code) {
|
|
case EVENT_CODE.left:
|
|
case EVENT_CODE.down:
|
|
onLeftKeyDown();
|
|
break;
|
|
case EVENT_CODE.right:
|
|
case EVENT_CODE.up:
|
|
onRightKeyDown();
|
|
break;
|
|
case EVENT_CODE.home:
|
|
onHomeKeyDown();
|
|
break;
|
|
case EVENT_CODE.end:
|
|
onEndKeyDown();
|
|
break;
|
|
case EVENT_CODE.pageDown:
|
|
onPageDownKeyDown();
|
|
break;
|
|
case EVENT_CODE.pageUp:
|
|
onPageUpKeyDown();
|
|
break;
|
|
default:
|
|
isPreventDefault = false;
|
|
break;
|
|
}
|
|
isPreventDefault && event.preventDefault();
|
|
};
|
|
const getClientXY2 = (event) => {
|
|
let clientX;
|
|
let clientY;
|
|
if (event.type.startsWith("touch")) {
|
|
clientY = event.touches[0].clientY;
|
|
clientX = event.touches[0].clientX;
|
|
} else {
|
|
clientY = event.clientY;
|
|
clientX = event.clientX;
|
|
}
|
|
return {
|
|
clientX,
|
|
clientY
|
|
};
|
|
};
|
|
const onDragStart = (event) => {
|
|
initData.dragging = true;
|
|
initData.isClick = true;
|
|
const { clientX, clientY } = getClientXY2(event);
|
|
if (props2.vertical) {
|
|
initData.startY = clientY;
|
|
} else {
|
|
initData.startX = clientX;
|
|
}
|
|
initData.startPosition = Number.parseFloat(currentPosition.value);
|
|
initData.newPosition = initData.startPosition;
|
|
};
|
|
const onDragging = (event) => {
|
|
if (initData.dragging) {
|
|
initData.isClick = false;
|
|
displayTooltip();
|
|
resetSize();
|
|
let diff;
|
|
const { clientX, clientY } = getClientXY2(event);
|
|
if (props2.vertical) {
|
|
initData.currentY = clientY;
|
|
diff = (initData.startY - initData.currentY) / sliderSize.value * 100;
|
|
} else {
|
|
initData.currentX = clientX;
|
|
diff = (initData.currentX - initData.startX) / sliderSize.value * 100;
|
|
}
|
|
initData.newPosition = initData.startPosition + diff;
|
|
setPosition(initData.newPosition);
|
|
}
|
|
};
|
|
const onDragEnd = () => {
|
|
if (initData.dragging) {
|
|
setTimeout(() => {
|
|
initData.dragging = false;
|
|
if (!initData.hovering) {
|
|
hideTooltip();
|
|
}
|
|
if (!initData.isClick) {
|
|
setPosition(initData.newPosition);
|
|
}
|
|
emitChange();
|
|
}, 0);
|
|
window.removeEventListener("mousemove", onDragging);
|
|
window.removeEventListener("touchmove", onDragging);
|
|
window.removeEventListener("mouseup", onDragEnd);
|
|
window.removeEventListener("touchend", onDragEnd);
|
|
window.removeEventListener("contextmenu", onDragEnd);
|
|
}
|
|
};
|
|
const setPosition = async (newPosition) => {
|
|
if (newPosition === null || Number.isNaN(+newPosition))
|
|
return;
|
|
if (newPosition < 0) {
|
|
newPosition = 0;
|
|
} else if (newPosition > 100) {
|
|
newPosition = 100;
|
|
}
|
|
const lengthPerStep = 100 / ((max4.value - min4.value) / step.value);
|
|
const steps = Math.round(newPosition / lengthPerStep);
|
|
let value = steps * lengthPerStep * (max4.value - min4.value) * 0.01 + min4.value;
|
|
value = Number.parseFloat(value.toFixed(precision.value));
|
|
if (value !== props2.modelValue) {
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
}
|
|
if (!initData.dragging && props2.modelValue !== initData.oldValue) {
|
|
initData.oldValue = props2.modelValue;
|
|
}
|
|
await nextTick();
|
|
initData.dragging && displayTooltip();
|
|
tooltip.value.updatePopper();
|
|
};
|
|
watch(() => initData.dragging, (val) => {
|
|
updateDragging(val);
|
|
});
|
|
useEventListener(button, "touchstart", onButtonDown, { passive: false });
|
|
return {
|
|
disabled,
|
|
button,
|
|
tooltip,
|
|
tooltipVisible,
|
|
showTooltip,
|
|
persistent,
|
|
wrapperStyle,
|
|
formatValue,
|
|
handleMouseEnter,
|
|
handleMouseLeave,
|
|
onButtonDown,
|
|
onKeyDown,
|
|
setPosition
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/slider/src/button2.mjs
|
|
var __default__83 = defineComponent({
|
|
name: "ElSliderButton"
|
|
});
|
|
var _sfc_main117 = defineComponent({
|
|
...__default__83,
|
|
props: sliderButtonProps,
|
|
emits: sliderButtonEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("slider");
|
|
const initData = reactive({
|
|
hovering: false,
|
|
dragging: false,
|
|
isClick: false,
|
|
startX: 0,
|
|
currentX: 0,
|
|
startY: 0,
|
|
currentY: 0,
|
|
startPosition: 0,
|
|
newPosition: 0,
|
|
oldValue: props2.modelValue
|
|
});
|
|
const tooltipPersistent = computed(() => !showTooltip.value ? false : persistent.value);
|
|
const {
|
|
disabled,
|
|
button,
|
|
tooltip,
|
|
showTooltip,
|
|
persistent,
|
|
tooltipVisible,
|
|
wrapperStyle,
|
|
formatValue,
|
|
handleMouseEnter,
|
|
handleMouseLeave,
|
|
onButtonDown,
|
|
onKeyDown,
|
|
setPosition
|
|
} = useSliderButton(props2, initData, emit);
|
|
const { hovering, dragging } = toRefs(initData);
|
|
expose({
|
|
onButtonDown,
|
|
onKeyDown,
|
|
setPosition,
|
|
hovering,
|
|
dragging
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "button",
|
|
ref: button,
|
|
class: normalizeClass([unref(ns).e("button-wrapper"), { hover: unref(hovering), dragging: unref(dragging) }]),
|
|
style: normalizeStyle(unref(wrapperStyle)),
|
|
tabindex: unref(disabled) ? -1 : 0,
|
|
onMouseenter: unref(handleMouseEnter),
|
|
onMouseleave: unref(handleMouseLeave),
|
|
onMousedown: unref(onButtonDown),
|
|
onFocus: unref(handleMouseEnter),
|
|
onBlur: unref(handleMouseLeave),
|
|
onKeydown: unref(onKeyDown)
|
|
}, [
|
|
createVNode(unref(ElTooltip), {
|
|
ref_key: "tooltip",
|
|
ref: tooltip,
|
|
visible: unref(tooltipVisible),
|
|
placement: _ctx.placement,
|
|
"fallback-placements": ["top", "bottom", "right", "left"],
|
|
"stop-popper-mouse-event": false,
|
|
"popper-class": _ctx.tooltipClass,
|
|
disabled: !unref(showTooltip),
|
|
persistent: unref(tooltipPersistent)
|
|
}, {
|
|
content: withCtx(() => [
|
|
createBaseVNode("span", null, toDisplayString(unref(formatValue)), 1)
|
|
]),
|
|
default: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([unref(ns).e("button"), { hover: unref(hovering), dragging: unref(dragging) }])
|
|
}, null, 2)
|
|
]),
|
|
_: 1
|
|
}, 8, ["visible", "placement", "popper-class", "disabled", "persistent"])
|
|
], 46, ["tabindex", "onMouseenter", "onMouseleave", "onMousedown", "onFocus", "onBlur", "onKeydown"]);
|
|
};
|
|
}
|
|
});
|
|
var SliderButton = _export_sfc(_sfc_main117, [["__file", "button.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/slider/src/marker.mjs
|
|
var sliderMarkerProps = buildProps({
|
|
mark: {
|
|
type: definePropType([String, Object]),
|
|
default: void 0
|
|
}
|
|
});
|
|
var SliderMarker = defineComponent({
|
|
name: "ElSliderMarker",
|
|
props: sliderMarkerProps,
|
|
setup(props2) {
|
|
const ns = useNamespace("slider");
|
|
const label = computed(() => {
|
|
return isString(props2.mark) ? props2.mark : props2.mark.label;
|
|
});
|
|
const style = computed(() => isString(props2.mark) ? void 0 : props2.mark.style);
|
|
return () => h("div", {
|
|
class: ns.e("marks-text"),
|
|
style: style.value
|
|
}, label.value);
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/slider/src/composables/use-slide.mjs
|
|
var useSlide = (props2, initData, emit) => {
|
|
const { form: elForm, formItem: elFormItem } = useFormItem();
|
|
const slider = shallowRef();
|
|
const firstButton = ref();
|
|
const secondButton = ref();
|
|
const buttonRefs = {
|
|
firstButton,
|
|
secondButton
|
|
};
|
|
const sliderDisabled = computed(() => {
|
|
return props2.disabled || (elForm == null ? void 0 : elForm.disabled) || false;
|
|
});
|
|
const minValue = computed(() => {
|
|
return Math.min(initData.firstValue, initData.secondValue);
|
|
});
|
|
const maxValue = computed(() => {
|
|
return Math.max(initData.firstValue, initData.secondValue);
|
|
});
|
|
const barSize = computed(() => {
|
|
return props2.range ? `${100 * (maxValue.value - minValue.value) / (props2.max - props2.min)}%` : `${100 * (initData.firstValue - props2.min) / (props2.max - props2.min)}%`;
|
|
});
|
|
const barStart = computed(() => {
|
|
return props2.range ? `${100 * (minValue.value - props2.min) / (props2.max - props2.min)}%` : "0%";
|
|
});
|
|
const runwayStyle = computed(() => {
|
|
return props2.vertical ? { height: props2.height } : {};
|
|
});
|
|
const barStyle = computed(() => {
|
|
return props2.vertical ? {
|
|
height: barSize.value,
|
|
bottom: barStart.value
|
|
} : {
|
|
width: barSize.value,
|
|
left: barStart.value
|
|
};
|
|
});
|
|
const resetSize = () => {
|
|
if (slider.value) {
|
|
initData.sliderSize = slider.value[`client${props2.vertical ? "Height" : "Width"}`];
|
|
}
|
|
};
|
|
const getButtonRefByPercent = (percent) => {
|
|
const targetValue = props2.min + percent * (props2.max - props2.min) / 100;
|
|
if (!props2.range) {
|
|
return firstButton;
|
|
}
|
|
let buttonRefName;
|
|
if (Math.abs(minValue.value - targetValue) < Math.abs(maxValue.value - targetValue)) {
|
|
buttonRefName = initData.firstValue < initData.secondValue ? "firstButton" : "secondButton";
|
|
} else {
|
|
buttonRefName = initData.firstValue > initData.secondValue ? "firstButton" : "secondButton";
|
|
}
|
|
return buttonRefs[buttonRefName];
|
|
};
|
|
const setPosition = (percent) => {
|
|
const buttonRef = getButtonRefByPercent(percent);
|
|
buttonRef.value.setPosition(percent);
|
|
return buttonRef;
|
|
};
|
|
const setFirstValue = (firstValue) => {
|
|
initData.firstValue = firstValue != null ? firstValue : props2.min;
|
|
_emit(props2.range ? [minValue.value, maxValue.value] : firstValue != null ? firstValue : props2.min);
|
|
};
|
|
const setSecondValue = (secondValue) => {
|
|
initData.secondValue = secondValue;
|
|
if (props2.range) {
|
|
_emit([minValue.value, maxValue.value]);
|
|
}
|
|
};
|
|
const _emit = (val) => {
|
|
emit(UPDATE_MODEL_EVENT, val);
|
|
emit(INPUT_EVENT, val);
|
|
};
|
|
const emitChange = async () => {
|
|
await nextTick();
|
|
emit(CHANGE_EVENT, props2.range ? [minValue.value, maxValue.value] : props2.modelValue);
|
|
};
|
|
const handleSliderPointerEvent = (event) => {
|
|
var _a2, _b, _c, _d, _e, _f;
|
|
if (sliderDisabled.value || initData.dragging)
|
|
return;
|
|
resetSize();
|
|
let newPercent = 0;
|
|
if (props2.vertical) {
|
|
const clientY = (_c = (_b = (_a2 = event.touches) == null ? void 0 : _a2.item(0)) == null ? void 0 : _b.clientY) != null ? _c : event.clientY;
|
|
const sliderOffsetBottom = slider.value.getBoundingClientRect().bottom;
|
|
newPercent = (sliderOffsetBottom - clientY) / initData.sliderSize * 100;
|
|
} else {
|
|
const clientX = (_f = (_e = (_d = event.touches) == null ? void 0 : _d.item(0)) == null ? void 0 : _e.clientX) != null ? _f : event.clientX;
|
|
const sliderOffsetLeft = slider.value.getBoundingClientRect().left;
|
|
newPercent = (clientX - sliderOffsetLeft) / initData.sliderSize * 100;
|
|
}
|
|
if (newPercent < 0 || newPercent > 100)
|
|
return;
|
|
return setPosition(newPercent);
|
|
};
|
|
const onSliderWrapperPrevent = (event) => {
|
|
var _a2, _b;
|
|
if (((_a2 = buttonRefs["firstButton"].value) == null ? void 0 : _a2.dragging) || ((_b = buttonRefs["secondButton"].value) == null ? void 0 : _b.dragging)) {
|
|
event.preventDefault();
|
|
}
|
|
};
|
|
const onSliderDown = async (event) => {
|
|
const buttonRef = handleSliderPointerEvent(event);
|
|
if (buttonRef) {
|
|
await nextTick();
|
|
buttonRef.value.onButtonDown(event);
|
|
}
|
|
};
|
|
const onSliderClick = (event) => {
|
|
const buttonRef = handleSliderPointerEvent(event);
|
|
if (buttonRef) {
|
|
emitChange();
|
|
}
|
|
};
|
|
const onSliderMarkerDown = (position) => {
|
|
if (sliderDisabled.value || initData.dragging)
|
|
return;
|
|
const buttonRef = setPosition(position);
|
|
if (buttonRef) {
|
|
emitChange();
|
|
}
|
|
};
|
|
return {
|
|
elFormItem,
|
|
slider,
|
|
firstButton,
|
|
secondButton,
|
|
sliderDisabled,
|
|
minValue,
|
|
maxValue,
|
|
runwayStyle,
|
|
barStyle,
|
|
resetSize,
|
|
setPosition,
|
|
emitChange,
|
|
onSliderWrapperPrevent,
|
|
onSliderClick,
|
|
onSliderDown,
|
|
onSliderMarkerDown,
|
|
setFirstValue,
|
|
setSecondValue
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/slider/src/composables/use-stops.mjs
|
|
var useStops = (props2, initData, minValue, maxValue) => {
|
|
const stops = computed(() => {
|
|
if (!props2.showStops || props2.min > props2.max)
|
|
return [];
|
|
if (props2.step === 0) {
|
|
debugWarn("ElSlider", "step should not be 0.");
|
|
return [];
|
|
}
|
|
const stopCount = (props2.max - props2.min) / props2.step;
|
|
const stepWidth = 100 * props2.step / (props2.max - props2.min);
|
|
const result2 = Array.from({ length: stopCount - 1 }).map((_2, index) => (index + 1) * stepWidth);
|
|
if (props2.range) {
|
|
return result2.filter((step) => {
|
|
return step < 100 * (minValue.value - props2.min) / (props2.max - props2.min) || step > 100 * (maxValue.value - props2.min) / (props2.max - props2.min);
|
|
});
|
|
} else {
|
|
return result2.filter((step) => step > 100 * (initData.firstValue - props2.min) / (props2.max - props2.min));
|
|
}
|
|
});
|
|
const getStopStyle = (position) => {
|
|
return props2.vertical ? { bottom: `${position}%` } : { left: `${position}%` };
|
|
};
|
|
return {
|
|
stops,
|
|
getStopStyle
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/slider/src/composables/use-marks.mjs
|
|
var useMarks = (props2) => {
|
|
return computed(() => {
|
|
if (!props2.marks) {
|
|
return [];
|
|
}
|
|
const marksKeys = Object.keys(props2.marks);
|
|
return marksKeys.map(Number.parseFloat).sort((a2, b2) => a2 - b2).filter((point) => point <= props2.max && point >= props2.min).map((point) => ({
|
|
point,
|
|
position: (point - props2.min) * 100 / (props2.max - props2.min),
|
|
mark: props2.marks[point]
|
|
}));
|
|
});
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/slider/src/composables/use-watch.mjs
|
|
var useWatch = (props2, initData, minValue, maxValue, emit, elFormItem) => {
|
|
const _emit = (val) => {
|
|
emit(UPDATE_MODEL_EVENT, val);
|
|
emit(INPUT_EVENT, val);
|
|
};
|
|
const valueChanged = () => {
|
|
if (props2.range) {
|
|
return ![minValue.value, maxValue.value].every((item, index) => item === initData.oldValue[index]);
|
|
} else {
|
|
return props2.modelValue !== initData.oldValue;
|
|
}
|
|
};
|
|
const setValues = () => {
|
|
var _a2, _b;
|
|
if (props2.min > props2.max) {
|
|
throwError("Slider", "min should not be greater than max.");
|
|
}
|
|
const val = props2.modelValue;
|
|
if (props2.range && isArray(val)) {
|
|
if (val[1] < props2.min) {
|
|
_emit([props2.min, props2.min]);
|
|
} else if (val[0] > props2.max) {
|
|
_emit([props2.max, props2.max]);
|
|
} else if (val[0] < props2.min) {
|
|
_emit([props2.min, val[1]]);
|
|
} else if (val[1] > props2.max) {
|
|
_emit([val[0], props2.max]);
|
|
} else {
|
|
initData.firstValue = val[0];
|
|
initData.secondValue = val[1];
|
|
if (valueChanged()) {
|
|
if (props2.validateEvent) {
|
|
(_a2 = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a2.call(elFormItem, "change").catch((err) => debugWarn(err));
|
|
}
|
|
initData.oldValue = val.slice();
|
|
}
|
|
}
|
|
} else if (!props2.range && isNumber2(val) && !Number.isNaN(val)) {
|
|
if (val < props2.min) {
|
|
_emit(props2.min);
|
|
} else if (val > props2.max) {
|
|
_emit(props2.max);
|
|
} else {
|
|
initData.firstValue = val;
|
|
if (valueChanged()) {
|
|
if (props2.validateEvent) {
|
|
(_b = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _b.call(elFormItem, "change").catch((err) => debugWarn(err));
|
|
}
|
|
initData.oldValue = val;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
setValues();
|
|
watch(() => initData.dragging, (val) => {
|
|
if (!val) {
|
|
setValues();
|
|
}
|
|
});
|
|
watch(() => props2.modelValue, (val, oldVal) => {
|
|
if (initData.dragging || isArray(val) && isArray(oldVal) && val.every((item, index) => item === oldVal[index]) && initData.firstValue === val[0] && initData.secondValue === val[1]) {
|
|
return;
|
|
}
|
|
setValues();
|
|
}, {
|
|
deep: true
|
|
});
|
|
watch(() => [props2.min, props2.max], () => {
|
|
setValues();
|
|
});
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/slider/src/composables/use-lifecycle.mjs
|
|
var useLifecycle = (props2, initData, resetSize) => {
|
|
const sliderWrapper = ref();
|
|
onMounted(async () => {
|
|
if (props2.range) {
|
|
if (isArray(props2.modelValue)) {
|
|
initData.firstValue = Math.max(props2.min, props2.modelValue[0]);
|
|
initData.secondValue = Math.min(props2.max, props2.modelValue[1]);
|
|
} else {
|
|
initData.firstValue = props2.min;
|
|
initData.secondValue = props2.max;
|
|
}
|
|
initData.oldValue = [initData.firstValue, initData.secondValue];
|
|
} else {
|
|
if (!isNumber2(props2.modelValue) || Number.isNaN(props2.modelValue)) {
|
|
initData.firstValue = props2.min;
|
|
} else {
|
|
initData.firstValue = Math.min(props2.max, Math.max(props2.min, props2.modelValue));
|
|
}
|
|
initData.oldValue = initData.firstValue;
|
|
}
|
|
useEventListener(window, "resize", resetSize);
|
|
await nextTick();
|
|
resetSize();
|
|
});
|
|
return {
|
|
sliderWrapper
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/slider/src/slider2.mjs
|
|
var __default__84 = defineComponent({
|
|
name: "ElSlider"
|
|
});
|
|
var _sfc_main118 = defineComponent({
|
|
...__default__84,
|
|
props: sliderProps,
|
|
emits: sliderEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("slider");
|
|
const { t } = useLocale();
|
|
const initData = reactive({
|
|
firstValue: 0,
|
|
secondValue: 0,
|
|
oldValue: 0,
|
|
dragging: false,
|
|
sliderSize: 1
|
|
});
|
|
const {
|
|
elFormItem,
|
|
slider,
|
|
firstButton,
|
|
secondButton,
|
|
sliderDisabled,
|
|
minValue,
|
|
maxValue,
|
|
runwayStyle,
|
|
barStyle,
|
|
resetSize,
|
|
emitChange,
|
|
onSliderWrapperPrevent,
|
|
onSliderClick,
|
|
onSliderDown,
|
|
onSliderMarkerDown,
|
|
setFirstValue,
|
|
setSecondValue
|
|
} = useSlide(props2, initData, emit);
|
|
const { stops, getStopStyle } = useStops(props2, initData, minValue, maxValue);
|
|
const { inputId, isLabeledByFormItem } = useFormItemInputId(props2, {
|
|
formItemContext: elFormItem
|
|
});
|
|
const sliderWrapperSize = useFormSize();
|
|
const sliderInputSize = computed(() => props2.inputSize || sliderWrapperSize.value);
|
|
const groupLabel = computed(() => {
|
|
return props2.ariaLabel || t("el.slider.defaultLabel", {
|
|
min: props2.min,
|
|
max: props2.max
|
|
});
|
|
});
|
|
const firstButtonLabel = computed(() => {
|
|
if (props2.range) {
|
|
return props2.rangeStartLabel || t("el.slider.defaultRangeStartLabel");
|
|
} else {
|
|
return groupLabel.value;
|
|
}
|
|
});
|
|
const firstValueText = computed(() => {
|
|
return props2.formatValueText ? props2.formatValueText(firstValue.value) : `${firstValue.value}`;
|
|
});
|
|
const secondButtonLabel = computed(() => {
|
|
return props2.rangeEndLabel || t("el.slider.defaultRangeEndLabel");
|
|
});
|
|
const secondValueText = computed(() => {
|
|
return props2.formatValueText ? props2.formatValueText(secondValue.value) : `${secondValue.value}`;
|
|
});
|
|
const sliderKls = computed(() => [
|
|
ns.b(),
|
|
ns.m(sliderWrapperSize.value),
|
|
ns.is("vertical", props2.vertical),
|
|
{ [ns.m("with-input")]: props2.showInput }
|
|
]);
|
|
const markList = useMarks(props2);
|
|
useWatch(props2, initData, minValue, maxValue, emit, elFormItem);
|
|
const precision = computed(() => {
|
|
const precisions = [props2.min, props2.max, props2.step].map((item) => {
|
|
const decimal = `${item}`.split(".")[1];
|
|
return decimal ? decimal.length : 0;
|
|
});
|
|
return Math.max.apply(null, precisions);
|
|
});
|
|
const { sliderWrapper } = useLifecycle(props2, initData, resetSize);
|
|
const { firstValue, secondValue, sliderSize } = toRefs(initData);
|
|
const updateDragging = (val) => {
|
|
initData.dragging = val;
|
|
};
|
|
useEventListener(sliderWrapper, "touchstart", onSliderWrapperPrevent, {
|
|
passive: false
|
|
});
|
|
useEventListener(sliderWrapper, "touchmove", onSliderWrapperPrevent, {
|
|
passive: false
|
|
});
|
|
provide(sliderContextKey, {
|
|
...toRefs(props2),
|
|
sliderSize,
|
|
disabled: sliderDisabled,
|
|
precision,
|
|
emitChange,
|
|
resetSize,
|
|
updateDragging
|
|
});
|
|
expose({
|
|
onSliderClick
|
|
});
|
|
return (_ctx, _cache) => {
|
|
var _a2, _b;
|
|
return openBlock(), createElementBlock("div", {
|
|
id: _ctx.range ? unref(inputId) : void 0,
|
|
ref_key: "sliderWrapper",
|
|
ref: sliderWrapper,
|
|
class: normalizeClass(unref(sliderKls)),
|
|
role: _ctx.range ? "group" : void 0,
|
|
"aria-label": _ctx.range && !unref(isLabeledByFormItem) ? unref(groupLabel) : void 0,
|
|
"aria-labelledby": _ctx.range && unref(isLabeledByFormItem) ? (_a2 = unref(elFormItem)) == null ? void 0 : _a2.labelId : void 0
|
|
}, [
|
|
createBaseVNode("div", {
|
|
ref_key: "slider",
|
|
ref: slider,
|
|
class: normalizeClass([
|
|
unref(ns).e("runway"),
|
|
{ "show-input": _ctx.showInput && !_ctx.range },
|
|
unref(ns).is("disabled", unref(sliderDisabled))
|
|
]),
|
|
style: normalizeStyle(unref(runwayStyle)),
|
|
onMousedown: unref(onSliderDown),
|
|
onTouchstartPassive: unref(onSliderDown)
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("bar")),
|
|
style: normalizeStyle(unref(barStyle))
|
|
}, null, 6),
|
|
createVNode(SliderButton, {
|
|
id: !_ctx.range ? unref(inputId) : void 0,
|
|
ref_key: "firstButton",
|
|
ref: firstButton,
|
|
"model-value": unref(firstValue),
|
|
vertical: _ctx.vertical,
|
|
"tooltip-class": _ctx.tooltipClass,
|
|
placement: _ctx.placement,
|
|
role: "slider",
|
|
"aria-label": _ctx.range || !unref(isLabeledByFormItem) ? unref(firstButtonLabel) : void 0,
|
|
"aria-labelledby": !_ctx.range && unref(isLabeledByFormItem) ? (_b = unref(elFormItem)) == null ? void 0 : _b.labelId : void 0,
|
|
"aria-valuemin": _ctx.min,
|
|
"aria-valuemax": _ctx.range ? unref(secondValue) : _ctx.max,
|
|
"aria-valuenow": unref(firstValue),
|
|
"aria-valuetext": unref(firstValueText),
|
|
"aria-orientation": _ctx.vertical ? "vertical" : "horizontal",
|
|
"aria-disabled": unref(sliderDisabled),
|
|
"onUpdate:modelValue": unref(setFirstValue)
|
|
}, null, 8, ["id", "model-value", "vertical", "tooltip-class", "placement", "aria-label", "aria-labelledby", "aria-valuemin", "aria-valuemax", "aria-valuenow", "aria-valuetext", "aria-orientation", "aria-disabled", "onUpdate:modelValue"]),
|
|
_ctx.range ? (openBlock(), createBlock(SliderButton, {
|
|
key: 0,
|
|
ref_key: "secondButton",
|
|
ref: secondButton,
|
|
"model-value": unref(secondValue),
|
|
vertical: _ctx.vertical,
|
|
"tooltip-class": _ctx.tooltipClass,
|
|
placement: _ctx.placement,
|
|
role: "slider",
|
|
"aria-label": unref(secondButtonLabel),
|
|
"aria-valuemin": unref(firstValue),
|
|
"aria-valuemax": _ctx.max,
|
|
"aria-valuenow": unref(secondValue),
|
|
"aria-valuetext": unref(secondValueText),
|
|
"aria-orientation": _ctx.vertical ? "vertical" : "horizontal",
|
|
"aria-disabled": unref(sliderDisabled),
|
|
"onUpdate:modelValue": unref(setSecondValue)
|
|
}, null, 8, ["model-value", "vertical", "tooltip-class", "placement", "aria-label", "aria-valuemin", "aria-valuemax", "aria-valuenow", "aria-valuetext", "aria-orientation", "aria-disabled", "onUpdate:modelValue"])) : createCommentVNode("v-if", true),
|
|
_ctx.showStops ? (openBlock(), createElementBlock("div", { key: 1 }, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(stops), (item, key) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
key,
|
|
class: normalizeClass(unref(ns).e("stop")),
|
|
style: normalizeStyle(unref(getStopStyle)(item))
|
|
}, null, 6);
|
|
}), 128))
|
|
])) : createCommentVNode("v-if", true),
|
|
unref(markList).length > 0 ? (openBlock(), createElementBlock(Fragment, { key: 2 }, [
|
|
createBaseVNode("div", null, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(markList), (item, key) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
key,
|
|
style: normalizeStyle(unref(getStopStyle)(item.position)),
|
|
class: normalizeClass([unref(ns).e("stop"), unref(ns).e("marks-stop")])
|
|
}, null, 6);
|
|
}), 128))
|
|
]),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("marks"))
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(markList), (item, key) => {
|
|
return openBlock(), createBlock(unref(SliderMarker), {
|
|
key,
|
|
mark: item.mark,
|
|
style: normalizeStyle(unref(getStopStyle)(item.position)),
|
|
onMousedown: withModifiers(($event) => unref(onSliderMarkerDown)(item.position), ["stop"])
|
|
}, null, 8, ["mark", "style", "onMousedown"]);
|
|
}), 128))
|
|
], 2)
|
|
], 64)) : createCommentVNode("v-if", true)
|
|
], 46, ["onMousedown", "onTouchstartPassive"]),
|
|
_ctx.showInput && !_ctx.range ? (openBlock(), createBlock(unref(ElInputNumber), {
|
|
key: 0,
|
|
ref: "input",
|
|
"model-value": unref(firstValue),
|
|
class: normalizeClass(unref(ns).e("input")),
|
|
step: _ctx.step,
|
|
disabled: unref(sliderDisabled),
|
|
controls: _ctx.showInputControls,
|
|
min: _ctx.min,
|
|
max: _ctx.max,
|
|
precision: unref(precision),
|
|
debounce: _ctx.debounce,
|
|
size: unref(sliderInputSize),
|
|
"onUpdate:modelValue": unref(setFirstValue),
|
|
onChange: unref(emitChange)
|
|
}, null, 8, ["model-value", "class", "step", "disabled", "controls", "min", "max", "precision", "debounce", "size", "onUpdate:modelValue", "onChange"])) : createCommentVNode("v-if", true)
|
|
], 10, ["id", "role", "aria-label", "aria-labelledby"]);
|
|
};
|
|
}
|
|
});
|
|
var Slider = _export_sfc(_sfc_main118, [["__file", "slider.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/slider/index.mjs
|
|
var ElSlider = withInstall(Slider);
|
|
|
|
// node_modules/element-plus/es/components/space/src/item.mjs
|
|
var spaceItemProps = buildProps({
|
|
prefixCls: {
|
|
type: String
|
|
}
|
|
});
|
|
var SpaceItem = defineComponent({
|
|
name: "ElSpaceItem",
|
|
props: spaceItemProps,
|
|
setup(props2, { slots }) {
|
|
const ns = useNamespace("space");
|
|
const classes = computed(() => `${props2.prefixCls || ns.b()}__item`);
|
|
return () => h("div", { class: classes.value }, renderSlot(slots, "default"));
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/space/src/use-space.mjs
|
|
var SIZE_MAP = {
|
|
small: 8,
|
|
default: 12,
|
|
large: 16
|
|
};
|
|
function useSpace(props2) {
|
|
const ns = useNamespace("space");
|
|
const classes = computed(() => [ns.b(), ns.m(props2.direction), props2.class]);
|
|
const horizontalSize = ref(0);
|
|
const verticalSize = ref(0);
|
|
const containerStyle = computed(() => {
|
|
const wrapKls = props2.wrap || props2.fill ? { flexWrap: "wrap" } : {};
|
|
const alignment = {
|
|
alignItems: props2.alignment
|
|
};
|
|
const gap = {
|
|
rowGap: `${verticalSize.value}px`,
|
|
columnGap: `${horizontalSize.value}px`
|
|
};
|
|
return [wrapKls, alignment, gap, props2.style];
|
|
});
|
|
const itemStyle = computed(() => {
|
|
return props2.fill ? { flexGrow: 1, minWidth: `${props2.fillRatio}%` } : {};
|
|
});
|
|
watchEffect(() => {
|
|
const { size: size3 = "small", wrap: wrap2, direction: dir, fill: fill2 } = props2;
|
|
if (isArray(size3)) {
|
|
const [h3 = 0, v2 = 0] = size3;
|
|
horizontalSize.value = h3;
|
|
verticalSize.value = v2;
|
|
} else {
|
|
let val;
|
|
if (isNumber2(size3)) {
|
|
val = size3;
|
|
} else {
|
|
val = SIZE_MAP[size3 || "small"] || SIZE_MAP.small;
|
|
}
|
|
if ((wrap2 || fill2) && dir === "horizontal") {
|
|
horizontalSize.value = verticalSize.value = val;
|
|
} else {
|
|
if (dir === "horizontal") {
|
|
horizontalSize.value = val;
|
|
verticalSize.value = 0;
|
|
} else {
|
|
verticalSize.value = val;
|
|
horizontalSize.value = 0;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return {
|
|
classes,
|
|
containerStyle,
|
|
itemStyle
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/space/src/space.mjs
|
|
var spaceProps = buildProps({
|
|
direction: {
|
|
type: String,
|
|
values: ["horizontal", "vertical"],
|
|
default: "horizontal"
|
|
},
|
|
class: {
|
|
type: definePropType([
|
|
String,
|
|
Object,
|
|
Array
|
|
]),
|
|
default: ""
|
|
},
|
|
style: {
|
|
type: definePropType([String, Array, Object]),
|
|
default: ""
|
|
},
|
|
alignment: {
|
|
type: definePropType(String),
|
|
default: "center"
|
|
},
|
|
prefixCls: {
|
|
type: String
|
|
},
|
|
spacer: {
|
|
type: definePropType([Object, String, Number, Array]),
|
|
default: null,
|
|
validator: (val) => isVNode(val) || isNumber2(val) || isString(val)
|
|
},
|
|
wrap: Boolean,
|
|
fill: Boolean,
|
|
fillRatio: {
|
|
type: Number,
|
|
default: 100
|
|
},
|
|
size: {
|
|
type: [String, Array, Number],
|
|
values: componentSizes,
|
|
validator: (val) => {
|
|
return isNumber2(val) || isArray(val) && val.length === 2 && val.every(isNumber2);
|
|
}
|
|
}
|
|
});
|
|
var Space = defineComponent({
|
|
name: "ElSpace",
|
|
props: spaceProps,
|
|
setup(props2, { slots }) {
|
|
const { classes, containerStyle, itemStyle } = useSpace(props2);
|
|
function extractChildren(children, parentKey = "", extractedChildren = []) {
|
|
const { prefixCls } = props2;
|
|
children.forEach((child, loopKey) => {
|
|
if (isFragment(child)) {
|
|
if (isArray(child.children)) {
|
|
child.children.forEach((nested, key) => {
|
|
if (isFragment(nested) && isArray(nested.children)) {
|
|
extractChildren(nested.children, `${parentKey + key}-`, extractedChildren);
|
|
} else {
|
|
extractedChildren.push(createVNode(SpaceItem, {
|
|
style: itemStyle.value,
|
|
prefixCls,
|
|
key: `nested-${parentKey + key}`
|
|
}, {
|
|
default: () => [nested]
|
|
}, PatchFlags.PROPS | PatchFlags.STYLE, ["style", "prefixCls"]));
|
|
}
|
|
});
|
|
}
|
|
} else if (isValidElementNode(child)) {
|
|
extractedChildren.push(createVNode(SpaceItem, {
|
|
style: itemStyle.value,
|
|
prefixCls,
|
|
key: `LoopKey${parentKey + loopKey}`
|
|
}, {
|
|
default: () => [child]
|
|
}, PatchFlags.PROPS | PatchFlags.STYLE, ["style", "prefixCls"]));
|
|
}
|
|
});
|
|
return extractedChildren;
|
|
}
|
|
return () => {
|
|
var _a2;
|
|
const { spacer, direction: direction2 } = props2;
|
|
const children = renderSlot(slots, "default", { key: 0 }, () => []);
|
|
if (((_a2 = children.children) != null ? _a2 : []).length === 0)
|
|
return null;
|
|
if (isArray(children.children)) {
|
|
let extractedChildren = extractChildren(children.children);
|
|
if (spacer) {
|
|
const len = extractedChildren.length - 1;
|
|
extractedChildren = extractedChildren.reduce((acc, child, idx) => {
|
|
const children2 = [...acc, child];
|
|
if (idx !== len) {
|
|
children2.push(createVNode("span", {
|
|
style: [
|
|
itemStyle.value,
|
|
direction2 === "vertical" ? "width: 100%" : null
|
|
],
|
|
key: idx
|
|
}, [
|
|
isVNode(spacer) ? spacer : createTextVNode(spacer, PatchFlags.TEXT)
|
|
], PatchFlags.STYLE));
|
|
}
|
|
return children2;
|
|
}, []);
|
|
}
|
|
return createVNode("div", {
|
|
class: classes.value,
|
|
style: containerStyle.value
|
|
}, extractedChildren, PatchFlags.STYLE | PatchFlags.CLASS);
|
|
}
|
|
return children.children;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/space/index.mjs
|
|
var ElSpace = withInstall(Space);
|
|
|
|
// node_modules/element-plus/es/components/statistic/src/statistic.mjs
|
|
var statisticProps = buildProps({
|
|
decimalSeparator: {
|
|
type: String,
|
|
default: "."
|
|
},
|
|
groupSeparator: {
|
|
type: String,
|
|
default: ","
|
|
},
|
|
precision: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
formatter: Function,
|
|
value: {
|
|
type: definePropType([Number, Object]),
|
|
default: 0
|
|
},
|
|
prefix: String,
|
|
suffix: String,
|
|
title: String,
|
|
valueStyle: {
|
|
type: definePropType([String, Object, Array])
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/statistic/src/statistic2.mjs
|
|
var __default__85 = defineComponent({
|
|
name: "ElStatistic"
|
|
});
|
|
var _sfc_main119 = defineComponent({
|
|
...__default__85,
|
|
props: statisticProps,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("statistic");
|
|
const displayValue = computed(() => {
|
|
const { value, formatter: formatter2, precision, decimalSeparator, groupSeparator } = props2;
|
|
if (isFunction(formatter2))
|
|
return formatter2(value);
|
|
if (!isNumber2(value) || Number.isNaN(value))
|
|
return value;
|
|
let [integer4, decimal = ""] = String(value).split(".");
|
|
decimal = decimal.padEnd(precision, "0").slice(0, precision > 0 ? precision : 0);
|
|
integer4 = integer4.replace(/\B(?=(\d{3})+(?!\d))/g, groupSeparator);
|
|
return [integer4, decimal].join(decimal ? decimalSeparator : "");
|
|
});
|
|
expose({
|
|
displayValue
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(unref(ns).b())
|
|
}, [
|
|
_ctx.$slots.title || _ctx.title ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("head"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "title", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.title), 1)
|
|
])
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("content"))
|
|
}, [
|
|
_ctx.$slots.prefix || _ctx.prefix ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("prefix"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "prefix", {}, () => [
|
|
createBaseVNode("span", null, toDisplayString(_ctx.prefix), 1)
|
|
])
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(ns).e("number")),
|
|
style: normalizeStyle(_ctx.valueStyle)
|
|
}, toDisplayString(unref(displayValue)), 7),
|
|
_ctx.$slots.suffix || _ctx.suffix ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("suffix"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "suffix", {}, () => [
|
|
createBaseVNode("span", null, toDisplayString(_ctx.suffix), 1)
|
|
])
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 2)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Statistic = _export_sfc(_sfc_main119, [["__file", "statistic.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/statistic/index.mjs
|
|
var ElStatistic = withInstall(Statistic);
|
|
|
|
// node_modules/element-plus/es/components/countdown/src/countdown.mjs
|
|
var countdownProps = buildProps({
|
|
format: {
|
|
type: String,
|
|
default: "HH:mm:ss"
|
|
},
|
|
prefix: String,
|
|
suffix: String,
|
|
title: String,
|
|
value: {
|
|
type: definePropType([Number, Object]),
|
|
default: 0
|
|
},
|
|
valueStyle: {
|
|
type: definePropType([String, Object, Array])
|
|
}
|
|
});
|
|
var countdownEmits = {
|
|
finish: () => true,
|
|
[CHANGE_EVENT]: (value) => isNumber2(value)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/countdown/src/utils.mjs
|
|
var timeUnits2 = [
|
|
["Y", 1e3 * 60 * 60 * 24 * 365],
|
|
["M", 1e3 * 60 * 60 * 24 * 30],
|
|
["D", 1e3 * 60 * 60 * 24],
|
|
["H", 1e3 * 60 * 60],
|
|
["m", 1e3 * 60],
|
|
["s", 1e3],
|
|
["S", 1]
|
|
];
|
|
var getTime = (value) => {
|
|
return isNumber2(value) ? new Date(value).getTime() : value.valueOf();
|
|
};
|
|
var formatTime = (timestamp2, format2) => {
|
|
let timeLeft = timestamp2;
|
|
const escapeRegex = /\[([^\]]*)]/g;
|
|
const replacedText = timeUnits2.reduce((current, [name, unit4]) => {
|
|
const replaceRegex = new RegExp(`${name}+(?![^\\[\\]]*\\])`, "g");
|
|
if (replaceRegex.test(current)) {
|
|
const value = Math.floor(timeLeft / unit4);
|
|
timeLeft -= value * unit4;
|
|
return current.replace(replaceRegex, (match) => String(value).padStart(match.length, "0"));
|
|
}
|
|
return current;
|
|
}, format2);
|
|
return replacedText.replace(escapeRegex, "$1");
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/countdown/src/countdown2.mjs
|
|
var __default__86 = defineComponent({
|
|
name: "ElCountdown"
|
|
});
|
|
var _sfc_main120 = defineComponent({
|
|
...__default__86,
|
|
props: countdownProps,
|
|
emits: countdownEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
let timer;
|
|
const rawValue = ref(0);
|
|
const displayValue = computed(() => formatTime(rawValue.value, props2.format));
|
|
const formatter2 = (val) => formatTime(val, props2.format);
|
|
const stopTimer = () => {
|
|
if (timer) {
|
|
cAF(timer);
|
|
timer = void 0;
|
|
}
|
|
};
|
|
const startTimer = () => {
|
|
const timestamp2 = getTime(props2.value);
|
|
const frameFunc = () => {
|
|
let diff = timestamp2 - Date.now();
|
|
emit(CHANGE_EVENT, diff);
|
|
if (diff <= 0) {
|
|
diff = 0;
|
|
stopTimer();
|
|
emit("finish");
|
|
} else {
|
|
timer = rAF(frameFunc);
|
|
}
|
|
rawValue.value = diff;
|
|
};
|
|
timer = rAF(frameFunc);
|
|
};
|
|
onMounted(() => {
|
|
rawValue.value = getTime(props2.value) - Date.now();
|
|
watch(() => [props2.value, props2.format], () => {
|
|
stopTimer();
|
|
startTimer();
|
|
}, {
|
|
immediate: true
|
|
});
|
|
});
|
|
onBeforeUnmount(() => {
|
|
stopTimer();
|
|
});
|
|
expose({
|
|
displayValue
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElStatistic), {
|
|
value: rawValue.value,
|
|
title: _ctx.title,
|
|
prefix: _ctx.prefix,
|
|
suffix: _ctx.suffix,
|
|
"value-style": _ctx.valueStyle,
|
|
formatter: formatter2
|
|
}, createSlots({
|
|
_: 2
|
|
}, [
|
|
renderList(_ctx.$slots, (_2, name) => {
|
|
return {
|
|
name,
|
|
fn: withCtx(() => [
|
|
renderSlot(_ctx.$slots, name)
|
|
])
|
|
};
|
|
})
|
|
]), 1032, ["value", "title", "prefix", "suffix", "value-style"]);
|
|
};
|
|
}
|
|
});
|
|
var Countdown = _export_sfc(_sfc_main120, [["__file", "countdown.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/countdown/index.mjs
|
|
var ElCountdown = withInstall(Countdown);
|
|
|
|
// node_modules/element-plus/es/components/steps/src/steps.mjs
|
|
var stepsProps = buildProps({
|
|
space: {
|
|
type: [Number, String],
|
|
default: ""
|
|
},
|
|
active: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
direction: {
|
|
type: String,
|
|
default: "horizontal",
|
|
values: ["horizontal", "vertical"]
|
|
},
|
|
alignCenter: {
|
|
type: Boolean
|
|
},
|
|
simple: {
|
|
type: Boolean
|
|
},
|
|
finishStatus: {
|
|
type: String,
|
|
values: ["wait", "process", "finish", "error", "success"],
|
|
default: "finish"
|
|
},
|
|
processStatus: {
|
|
type: String,
|
|
values: ["wait", "process", "finish", "error", "success"],
|
|
default: "process"
|
|
}
|
|
});
|
|
var stepsEmits = {
|
|
[CHANGE_EVENT]: (newVal, oldVal) => [newVal, oldVal].every(isNumber2)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/steps/src/item.mjs
|
|
var stepProps = buildProps({
|
|
title: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
icon: {
|
|
type: iconPropType
|
|
},
|
|
description: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
status: {
|
|
type: String,
|
|
values: ["", "wait", "process", "finish", "error", "success"],
|
|
default: ""
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/steps/src/steps2.mjs
|
|
var __default__87 = defineComponent({
|
|
name: "ElSteps"
|
|
});
|
|
var _sfc_main121 = defineComponent({
|
|
...__default__87,
|
|
props: stepsProps,
|
|
emits: stepsEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("steps");
|
|
const {
|
|
children: steps,
|
|
addChild: addStep,
|
|
removeChild: removeStep
|
|
} = useOrderedChildren(getCurrentInstance(), "ElStep");
|
|
watch(steps, () => {
|
|
steps.value.forEach((instance, index) => {
|
|
instance.setIndex(index);
|
|
});
|
|
});
|
|
provide("ElSteps", { props: props2, steps, addStep, removeStep });
|
|
watch(() => props2.active, (newVal, oldVal) => {
|
|
emit(CHANGE_EVENT, newVal, oldVal);
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([unref(ns).b(), unref(ns).m(_ctx.simple ? "simple" : _ctx.direction)])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Steps = _export_sfc(_sfc_main121, [["__file", "steps.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/steps/src/item2.mjs
|
|
var __default__88 = defineComponent({
|
|
name: "ElStep"
|
|
});
|
|
var _sfc_main122 = defineComponent({
|
|
...__default__88,
|
|
props: stepProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("step");
|
|
const index = ref(-1);
|
|
const lineStyle = ref({});
|
|
const internalStatus = ref("");
|
|
const parent2 = inject("ElSteps");
|
|
const currentInstance = getCurrentInstance();
|
|
onMounted(() => {
|
|
watch([
|
|
() => parent2.props.active,
|
|
() => parent2.props.processStatus,
|
|
() => parent2.props.finishStatus
|
|
], ([active]) => {
|
|
updateStatus(active);
|
|
}, { immediate: true });
|
|
});
|
|
onBeforeUnmount(() => {
|
|
parent2.removeStep(stepItemState.uid);
|
|
});
|
|
const currentStatus = computed(() => {
|
|
return props2.status || internalStatus.value;
|
|
});
|
|
const prevStatus = computed(() => {
|
|
const prevStep = parent2.steps.value[index.value - 1];
|
|
return prevStep ? prevStep.currentStatus : "wait";
|
|
});
|
|
const isCenter = computed(() => {
|
|
return parent2.props.alignCenter;
|
|
});
|
|
const isVertical = computed(() => {
|
|
return parent2.props.direction === "vertical";
|
|
});
|
|
const isSimple = computed(() => {
|
|
return parent2.props.simple;
|
|
});
|
|
const stepsCount = computed(() => {
|
|
return parent2.steps.value.length;
|
|
});
|
|
const isLast = computed(() => {
|
|
var _a2;
|
|
return ((_a2 = parent2.steps.value[stepsCount.value - 1]) == null ? void 0 : _a2.uid) === (currentInstance == null ? void 0 : currentInstance.uid);
|
|
});
|
|
const space = computed(() => {
|
|
return isSimple.value ? "" : parent2.props.space;
|
|
});
|
|
const containerKls = computed(() => {
|
|
return [
|
|
ns.b(),
|
|
ns.is(isSimple.value ? "simple" : parent2.props.direction),
|
|
ns.is("flex", isLast.value && !space.value && !isCenter.value),
|
|
ns.is("center", isCenter.value && !isVertical.value && !isSimple.value)
|
|
];
|
|
});
|
|
const style = computed(() => {
|
|
const style2 = {
|
|
flexBasis: isNumber2(space.value) ? `${space.value}px` : space.value ? space.value : `${100 / (stepsCount.value - (isCenter.value ? 0 : 1))}%`
|
|
};
|
|
if (isVertical.value)
|
|
return style2;
|
|
if (isLast.value) {
|
|
style2.maxWidth = `${100 / stepsCount.value}%`;
|
|
}
|
|
return style2;
|
|
});
|
|
const setIndex = (val) => {
|
|
index.value = val;
|
|
};
|
|
const calcProgress = (status) => {
|
|
const isWait = status === "wait";
|
|
const style2 = {
|
|
transitionDelay: `${isWait ? "-" : ""}${150 * index.value}ms`
|
|
};
|
|
const step = status === parent2.props.processStatus || isWait ? 0 : 100;
|
|
style2.borderWidth = step && !isSimple.value ? "1px" : 0;
|
|
style2[parent2.props.direction === "vertical" ? "height" : "width"] = `${step}%`;
|
|
lineStyle.value = style2;
|
|
};
|
|
const updateStatus = (activeIndex) => {
|
|
if (activeIndex > index.value) {
|
|
internalStatus.value = parent2.props.finishStatus;
|
|
} else if (activeIndex === index.value && prevStatus.value !== "error") {
|
|
internalStatus.value = parent2.props.processStatus;
|
|
} else {
|
|
internalStatus.value = "wait";
|
|
}
|
|
const prevChild = parent2.steps.value[index.value - 1];
|
|
if (prevChild)
|
|
prevChild.calcProgress(internalStatus.value);
|
|
};
|
|
const stepItemState = reactive({
|
|
uid: currentInstance.uid,
|
|
currentStatus,
|
|
setIndex,
|
|
calcProgress
|
|
});
|
|
parent2.addStep(stepItemState);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
style: normalizeStyle(unref(style)),
|
|
class: normalizeClass(unref(containerKls))
|
|
}, [
|
|
createCommentVNode(" icon & line "),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([unref(ns).e("head"), unref(ns).is(unref(currentStatus))])
|
|
}, [
|
|
!unref(isSimple) ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("line"))
|
|
}, [
|
|
createBaseVNode("i", {
|
|
class: normalizeClass(unref(ns).e("line-inner")),
|
|
style: normalizeStyle(lineStyle.value)
|
|
}, null, 6)
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([unref(ns).e("icon"), unref(ns).is(_ctx.icon || _ctx.$slots.icon ? "icon" : "text")])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "icon", {}, () => [
|
|
_ctx.icon ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("icon-inner"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : unref(currentStatus) === "success" ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 1,
|
|
class: normalizeClass([unref(ns).e("icon-inner"), unref(ns).is("status")])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(check_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : unref(currentStatus) === "error" ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 2,
|
|
class: normalizeClass([unref(ns).e("icon-inner"), unref(ns).is("status")])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(close_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : !unref(isSimple) ? (openBlock(), createElementBlock("div", {
|
|
key: 3,
|
|
class: normalizeClass(unref(ns).e("icon-inner"))
|
|
}, toDisplayString(index.value + 1), 3)) : createCommentVNode("v-if", true)
|
|
])
|
|
], 2)
|
|
], 2),
|
|
createCommentVNode(" title & description "),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("main"))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([unref(ns).e("title"), unref(ns).is(unref(currentStatus))])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "title", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.title), 1)
|
|
])
|
|
], 2),
|
|
unref(isSimple) ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("arrow"))
|
|
}, null, 2)) : (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass([unref(ns).e("description"), unref(ns).is(unref(currentStatus))])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "description", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.description), 1)
|
|
])
|
|
], 2))
|
|
], 2)
|
|
], 6);
|
|
};
|
|
}
|
|
});
|
|
var Step = _export_sfc(_sfc_main122, [["__file", "item.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/steps/index.mjs
|
|
var ElSteps = withInstall(Steps, {
|
|
Step
|
|
});
|
|
var ElStep = withNoopInstall(Step);
|
|
|
|
// node_modules/element-plus/es/utils/vue/validator.mjs
|
|
var isValidComponentSize = (val) => ["", ...componentSizes].includes(val);
|
|
|
|
// node_modules/element-plus/es/components/switch/src/switch.mjs
|
|
var switchProps = buildProps({
|
|
modelValue: {
|
|
type: [Boolean, String, Number],
|
|
default: false
|
|
},
|
|
disabled: Boolean,
|
|
loading: Boolean,
|
|
size: {
|
|
type: String,
|
|
validator: isValidComponentSize
|
|
},
|
|
width: {
|
|
type: [String, Number],
|
|
default: ""
|
|
},
|
|
inlinePrompt: Boolean,
|
|
inactiveActionIcon: {
|
|
type: iconPropType
|
|
},
|
|
activeActionIcon: {
|
|
type: iconPropType
|
|
},
|
|
activeIcon: {
|
|
type: iconPropType
|
|
},
|
|
inactiveIcon: {
|
|
type: iconPropType
|
|
},
|
|
activeText: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
inactiveText: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
activeValue: {
|
|
type: [Boolean, String, Number],
|
|
default: true
|
|
},
|
|
inactiveValue: {
|
|
type: [Boolean, String, Number],
|
|
default: false
|
|
},
|
|
name: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
beforeChange: {
|
|
type: definePropType(Function)
|
|
},
|
|
id: String,
|
|
tabindex: {
|
|
type: [String, Number]
|
|
},
|
|
...useAriaProps(["ariaLabel"])
|
|
});
|
|
var switchEmits = {
|
|
[UPDATE_MODEL_EVENT]: (val) => isBoolean2(val) || isString(val) || isNumber2(val),
|
|
[CHANGE_EVENT]: (val) => isBoolean2(val) || isString(val) || isNumber2(val),
|
|
[INPUT_EVENT]: (val) => isBoolean2(val) || isString(val) || isNumber2(val)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/switch/src/switch2.mjs
|
|
var COMPONENT_NAME18 = "ElSwitch";
|
|
var __default__89 = defineComponent({
|
|
name: COMPONENT_NAME18
|
|
});
|
|
var _sfc_main123 = defineComponent({
|
|
...__default__89,
|
|
props: switchProps,
|
|
emits: switchEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const { formItem } = useFormItem();
|
|
const switchSize = useFormSize();
|
|
const ns = useNamespace("switch");
|
|
const { inputId } = useFormItemInputId(props2, {
|
|
formItemContext: formItem
|
|
});
|
|
const switchDisabled = useFormDisabled(computed(() => props2.loading));
|
|
const isControlled = ref(props2.modelValue !== false);
|
|
const input = ref();
|
|
const core = ref();
|
|
const switchKls = computed(() => [
|
|
ns.b(),
|
|
ns.m(switchSize.value),
|
|
ns.is("disabled", switchDisabled.value),
|
|
ns.is("checked", checked.value)
|
|
]);
|
|
const labelLeftKls = computed(() => [
|
|
ns.e("label"),
|
|
ns.em("label", "left"),
|
|
ns.is("active", !checked.value)
|
|
]);
|
|
const labelRightKls = computed(() => [
|
|
ns.e("label"),
|
|
ns.em("label", "right"),
|
|
ns.is("active", checked.value)
|
|
]);
|
|
const coreStyle = computed(() => ({
|
|
width: addUnit(props2.width)
|
|
}));
|
|
watch(() => props2.modelValue, () => {
|
|
isControlled.value = true;
|
|
});
|
|
const actualValue = computed(() => {
|
|
return isControlled.value ? props2.modelValue : false;
|
|
});
|
|
const checked = computed(() => actualValue.value === props2.activeValue);
|
|
if (![props2.activeValue, props2.inactiveValue].includes(actualValue.value)) {
|
|
emit(UPDATE_MODEL_EVENT, props2.inactiveValue);
|
|
emit(CHANGE_EVENT, props2.inactiveValue);
|
|
emit(INPUT_EVENT, props2.inactiveValue);
|
|
}
|
|
watch(checked, (val) => {
|
|
var _a2;
|
|
input.value.checked = val;
|
|
if (props2.validateEvent) {
|
|
(_a2 = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a2.call(formItem, "change").catch((err) => debugWarn(err));
|
|
}
|
|
});
|
|
const handleChange = () => {
|
|
const val = checked.value ? props2.inactiveValue : props2.activeValue;
|
|
emit(UPDATE_MODEL_EVENT, val);
|
|
emit(CHANGE_EVENT, val);
|
|
emit(INPUT_EVENT, val);
|
|
nextTick(() => {
|
|
input.value.checked = checked.value;
|
|
});
|
|
};
|
|
const switchValue = () => {
|
|
if (switchDisabled.value)
|
|
return;
|
|
const { beforeChange } = props2;
|
|
if (!beforeChange) {
|
|
handleChange();
|
|
return;
|
|
}
|
|
const shouldChange = beforeChange();
|
|
const isPromiseOrBool = [
|
|
isPromise(shouldChange),
|
|
isBoolean2(shouldChange)
|
|
].includes(true);
|
|
if (!isPromiseOrBool) {
|
|
throwError(COMPONENT_NAME18, "beforeChange must return type `Promise<boolean>` or `boolean`");
|
|
}
|
|
if (isPromise(shouldChange)) {
|
|
shouldChange.then((result2) => {
|
|
if (result2) {
|
|
handleChange();
|
|
}
|
|
}).catch((e) => {
|
|
debugWarn(COMPONENT_NAME18, `some error occurred: ${e}`);
|
|
});
|
|
} else if (shouldChange) {
|
|
handleChange();
|
|
}
|
|
};
|
|
const focus = () => {
|
|
var _a2, _b;
|
|
(_b = (_a2 = input.value) == null ? void 0 : _a2.focus) == null ? void 0 : _b.call(_a2);
|
|
};
|
|
onMounted(() => {
|
|
input.value.checked = checked.value;
|
|
});
|
|
expose({
|
|
focus,
|
|
checked
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(unref(switchKls)),
|
|
onClick: withModifiers(switchValue, ["prevent"])
|
|
}, [
|
|
createBaseVNode("input", {
|
|
id: unref(inputId),
|
|
ref_key: "input",
|
|
ref: input,
|
|
class: normalizeClass(unref(ns).e("input")),
|
|
type: "checkbox",
|
|
role: "switch",
|
|
"aria-checked": unref(checked),
|
|
"aria-disabled": unref(switchDisabled),
|
|
"aria-label": _ctx.ariaLabel,
|
|
name: _ctx.name,
|
|
"true-value": _ctx.activeValue,
|
|
"false-value": _ctx.inactiveValue,
|
|
disabled: unref(switchDisabled),
|
|
tabindex: _ctx.tabindex,
|
|
onChange: handleChange,
|
|
onKeydown: withKeys(switchValue, ["enter"])
|
|
}, null, 42, ["id", "aria-checked", "aria-disabled", "aria-label", "name", "true-value", "false-value", "disabled", "tabindex", "onKeydown"]),
|
|
!_ctx.inlinePrompt && (_ctx.inactiveIcon || _ctx.inactiveText) ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
class: normalizeClass(unref(labelLeftKls))
|
|
}, [
|
|
_ctx.inactiveIcon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.inactiveIcon)))
|
|
]),
|
|
_: 1
|
|
})) : createCommentVNode("v-if", true),
|
|
!_ctx.inactiveIcon && _ctx.inactiveText ? (openBlock(), createElementBlock("span", {
|
|
key: 1,
|
|
"aria-hidden": unref(checked)
|
|
}, toDisplayString(_ctx.inactiveText), 9, ["aria-hidden"])) : createCommentVNode("v-if", true)
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("span", {
|
|
ref_key: "core",
|
|
ref: core,
|
|
class: normalizeClass(unref(ns).e("core")),
|
|
style: normalizeStyle(unref(coreStyle))
|
|
}, [
|
|
_ctx.inlinePrompt ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("inner"))
|
|
}, [
|
|
_ctx.activeIcon || _ctx.inactiveIcon ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).is("icon"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(unref(checked) ? _ctx.activeIcon : _ctx.inactiveIcon)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : _ctx.activeText || _ctx.inactiveText ? (openBlock(), createElementBlock("span", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).is("text")),
|
|
"aria-hidden": !unref(checked)
|
|
}, toDisplayString(unref(checked) ? _ctx.activeText : _ctx.inactiveText), 11, ["aria-hidden"])) : createCommentVNode("v-if", true)
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("action"))
|
|
}, [
|
|
_ctx.loading ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).is("loading"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(loading_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : unref(checked) ? renderSlot(_ctx.$slots, "active-action", { key: 1 }, () => [
|
|
_ctx.activeActionIcon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.activeActionIcon)))
|
|
]),
|
|
_: 1
|
|
})) : createCommentVNode("v-if", true)
|
|
]) : !unref(checked) ? renderSlot(_ctx.$slots, "inactive-action", { key: 2 }, () => [
|
|
_ctx.inactiveActionIcon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.inactiveActionIcon)))
|
|
]),
|
|
_: 1
|
|
})) : createCommentVNode("v-if", true)
|
|
]) : createCommentVNode("v-if", true)
|
|
], 2)
|
|
], 6),
|
|
!_ctx.inlinePrompt && (_ctx.activeIcon || _ctx.activeText) ? (openBlock(), createElementBlock("span", {
|
|
key: 1,
|
|
class: normalizeClass(unref(labelRightKls))
|
|
}, [
|
|
_ctx.activeIcon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.activeIcon)))
|
|
]),
|
|
_: 1
|
|
})) : createCommentVNode("v-if", true),
|
|
!_ctx.activeIcon && _ctx.activeText ? (openBlock(), createElementBlock("span", {
|
|
key: 1,
|
|
"aria-hidden": !unref(checked)
|
|
}, toDisplayString(_ctx.activeText), 9, ["aria-hidden"])) : createCommentVNode("v-if", true)
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 10, ["onClick"]);
|
|
};
|
|
}
|
|
});
|
|
var Switch = _export_sfc(_sfc_main123, [["__file", "switch.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/switch/index.mjs
|
|
var ElSwitch = withInstall(Switch);
|
|
|
|
// node_modules/normalize-wheel-es/dist/index.mjs
|
|
var v = false;
|
|
var o;
|
|
var f;
|
|
var s;
|
|
var u;
|
|
var d;
|
|
var N2;
|
|
var l;
|
|
var p;
|
|
var m;
|
|
var w;
|
|
var D;
|
|
var x;
|
|
var E2;
|
|
var M;
|
|
var F;
|
|
function a() {
|
|
if (!v) {
|
|
v = true;
|
|
var e = navigator.userAgent, n = /(?:MSIE.(\d+\.\d+))|(?:(?:Firefox|GranParadiso|Iceweasel).(\d+\.\d+))|(?:Opera(?:.+Version.|.)(\d+\.\d+))|(?:AppleWebKit.(\d+(?:\.\d+)?))|(?:Trident\/\d+\.\d+.*rv:(\d+\.\d+))/.exec(e), i = /(Mac OS X)|(Windows)|(Linux)/.exec(e);
|
|
if (x = /\b(iPhone|iP[ao]d)/.exec(e), E2 = /\b(iP[ao]d)/.exec(e), w = /Android/i.exec(e), M = /FBAN\/\w+;/i.exec(e), F = /Mobile/i.exec(e), D = !!/Win64/.exec(e), n) {
|
|
o = n[1] ? parseFloat(n[1]) : n[5] ? parseFloat(n[5]) : NaN, o && document && document.documentMode && (o = document.documentMode);
|
|
var r = /(?:Trident\/(\d+.\d+))/.exec(e);
|
|
N2 = r ? parseFloat(r[1]) + 4 : o, f = n[2] ? parseFloat(n[2]) : NaN, s = n[3] ? parseFloat(n[3]) : NaN, u = n[4] ? parseFloat(n[4]) : NaN, u ? (n = /(?:Chrome\/(\d+\.\d+))/.exec(e), d = n && n[1] ? parseFloat(n[1]) : NaN) : d = NaN;
|
|
} else
|
|
o = f = s = d = u = NaN;
|
|
if (i) {
|
|
if (i[1]) {
|
|
var t = /(?:Mac OS X (\d+(?:[._]\d+)?))/.exec(e);
|
|
l = t ? parseFloat(t[1].replace("_", ".")) : true;
|
|
} else
|
|
l = false;
|
|
p = !!i[2], m = !!i[3];
|
|
} else
|
|
l = p = m = false;
|
|
}
|
|
}
|
|
var _ = { ie: function() {
|
|
return a() || o;
|
|
}, ieCompatibilityMode: function() {
|
|
return a() || N2 > o;
|
|
}, ie64: function() {
|
|
return _.ie() && D;
|
|
}, firefox: function() {
|
|
return a() || f;
|
|
}, opera: function() {
|
|
return a() || s;
|
|
}, webkit: function() {
|
|
return a() || u;
|
|
}, safari: function() {
|
|
return _.webkit();
|
|
}, chrome: function() {
|
|
return a() || d;
|
|
}, windows: function() {
|
|
return a() || p;
|
|
}, osx: function() {
|
|
return a() || l;
|
|
}, linux: function() {
|
|
return a() || m;
|
|
}, iphone: function() {
|
|
return a() || x;
|
|
}, mobile: function() {
|
|
return a() || x || E2 || w || F;
|
|
}, nativeApp: function() {
|
|
return a() || M;
|
|
}, android: function() {
|
|
return a() || w;
|
|
}, ipad: function() {
|
|
return a() || E2;
|
|
} };
|
|
var A = _;
|
|
var c = !!(typeof window < "u" && window.document && window.document.createElement);
|
|
var U2 = { canUseDOM: c, canUseWorkers: typeof Worker < "u", canUseEventListeners: c && !!(window.addEventListener || window.attachEvent), canUseViewport: c && !!window.screen, isInWorker: !c };
|
|
var h2 = U2;
|
|
var X2;
|
|
h2.canUseDOM && (X2 = document.implementation && document.implementation.hasFeature && document.implementation.hasFeature("", "") !== true);
|
|
function S(e, n) {
|
|
if (!h2.canUseDOM || n && !("addEventListener" in document))
|
|
return false;
|
|
var i = "on" + e, r = i in document;
|
|
if (!r) {
|
|
var t = document.createElement("div");
|
|
t.setAttribute(i, "return;"), r = typeof t[i] == "function";
|
|
}
|
|
return !r && X2 && e === "wheel" && (r = document.implementation.hasFeature("Events.wheel", "3.0")), r;
|
|
}
|
|
var b = S;
|
|
var O = 10;
|
|
var I2 = 40;
|
|
var P2 = 800;
|
|
function T(e) {
|
|
var n = 0, i = 0, r = 0, t = 0;
|
|
return "detail" in e && (i = e.detail), "wheelDelta" in e && (i = -e.wheelDelta / 120), "wheelDeltaY" in e && (i = -e.wheelDeltaY / 120), "wheelDeltaX" in e && (n = -e.wheelDeltaX / 120), "axis" in e && e.axis === e.HORIZONTAL_AXIS && (n = i, i = 0), r = n * O, t = i * O, "deltaY" in e && (t = e.deltaY), "deltaX" in e && (r = e.deltaX), (r || t) && e.deltaMode && (e.deltaMode == 1 ? (r *= I2, t *= I2) : (r *= P2, t *= P2)), r && !n && (n = r < 1 ? -1 : 1), t && !i && (i = t < 1 ? -1 : 1), { spinX: n, spinY: i, pixelX: r, pixelY: t };
|
|
}
|
|
T.getEventType = function() {
|
|
return A.firefox() ? "DOMMouseScroll" : b("wheel") ? "wheel" : "mousewheel";
|
|
};
|
|
var Y = T;
|
|
|
|
// node_modules/element-plus/es/directives/mousewheel/index.mjs
|
|
var mousewheel = function(element, callback) {
|
|
if (element && element.addEventListener) {
|
|
const fn2 = function(event) {
|
|
const normalized = Y(event);
|
|
callback && Reflect.apply(callback, this, [event, normalized]);
|
|
};
|
|
element.addEventListener("wheel", fn2, { passive: true });
|
|
}
|
|
};
|
|
var Mousewheel = {
|
|
beforeMount(el, binding) {
|
|
mousewheel(el, binding.value);
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table/src/util.mjs
|
|
var getCell = function(event) {
|
|
var _a2;
|
|
return (_a2 = event.target) == null ? void 0 : _a2.closest("td");
|
|
};
|
|
var orderBy2 = function(array4, sortKey, reverse2, sortMethod, sortBy2) {
|
|
if (!sortKey && !sortMethod && (!sortBy2 || isArray(sortBy2) && !sortBy2.length)) {
|
|
return array4;
|
|
}
|
|
if (isString(reverse2)) {
|
|
reverse2 = reverse2 === "descending" ? -1 : 1;
|
|
} else {
|
|
reverse2 = reverse2 && reverse2 < 0 ? -1 : 1;
|
|
}
|
|
const getKey = sortMethod ? null : function(value, index) {
|
|
if (sortBy2) {
|
|
if (!isArray(sortBy2)) {
|
|
sortBy2 = [sortBy2];
|
|
}
|
|
return sortBy2.map((by) => {
|
|
if (isString(by)) {
|
|
return get_default(value, by);
|
|
} else {
|
|
return by(value, index, array4);
|
|
}
|
|
});
|
|
}
|
|
if (sortKey !== "$key") {
|
|
if (isObject(value) && "$value" in value)
|
|
value = value.$value;
|
|
}
|
|
return [isObject(value) ? get_default(value, sortKey) : value];
|
|
};
|
|
const compare = function(a2, b2) {
|
|
if (sortMethod) {
|
|
return sortMethod(a2.value, b2.value);
|
|
}
|
|
for (let i = 0, len = a2.key.length; i < len; i++) {
|
|
if (a2.key[i] < b2.key[i]) {
|
|
return -1;
|
|
}
|
|
if (a2.key[i] > b2.key[i]) {
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
};
|
|
return array4.map((value, index) => {
|
|
return {
|
|
value,
|
|
index,
|
|
key: getKey ? getKey(value, index) : null
|
|
};
|
|
}).sort((a2, b2) => {
|
|
let order = compare(a2, b2);
|
|
if (!order) {
|
|
order = a2.index - b2.index;
|
|
}
|
|
return order * +reverse2;
|
|
}).map((item) => item.value);
|
|
};
|
|
var getColumnById = function(table, columnId) {
|
|
let column2 = null;
|
|
table.columns.forEach((item) => {
|
|
if (item.id === columnId) {
|
|
column2 = item;
|
|
}
|
|
});
|
|
return column2;
|
|
};
|
|
var getColumnByKey = function(table, columnKey) {
|
|
let column2 = null;
|
|
for (let i = 0; i < table.columns.length; i++) {
|
|
const item = table.columns[i];
|
|
if (item.columnKey === columnKey) {
|
|
column2 = item;
|
|
break;
|
|
}
|
|
}
|
|
if (!column2)
|
|
throwError("ElTable", `No column matching with column-key: ${columnKey}`);
|
|
return column2;
|
|
};
|
|
var getColumnByCell = function(table, cell, namespace) {
|
|
const matches2 = (cell.className || "").match(new RegExp(`${namespace}-table_[^\\s]+`, "gm"));
|
|
if (matches2) {
|
|
return getColumnById(table, matches2[0]);
|
|
}
|
|
return null;
|
|
};
|
|
var getRowIdentity = (row, rowKey2) => {
|
|
if (!row)
|
|
throw new Error("Row is required when get row identity");
|
|
if (isString(rowKey2)) {
|
|
if (!rowKey2.includes(".")) {
|
|
return `${row[rowKey2]}`;
|
|
}
|
|
const key = rowKey2.split(".");
|
|
let current = row;
|
|
for (const element of key) {
|
|
current = current[element];
|
|
}
|
|
return `${current}`;
|
|
} else if (isFunction(rowKey2)) {
|
|
return rowKey2.call(null, row);
|
|
}
|
|
};
|
|
var getKeysMap = function(array4, rowKey2, flatten2 = false, childrenKey = "children") {
|
|
const data = array4 || [];
|
|
const arrayMap2 = {};
|
|
data.forEach((row, index) => {
|
|
arrayMap2[getRowIdentity(row, rowKey2)] = { row, index };
|
|
if (flatten2) {
|
|
const children = row[childrenKey];
|
|
if (isArray(children)) {
|
|
Object.assign(arrayMap2, getKeysMap(children, rowKey2, true, childrenKey));
|
|
}
|
|
}
|
|
});
|
|
return arrayMap2;
|
|
};
|
|
function mergeOptions(defaults2, config) {
|
|
const options = {};
|
|
let key;
|
|
for (key in defaults2) {
|
|
options[key] = defaults2[key];
|
|
}
|
|
for (key in config) {
|
|
if (hasOwn(config, key)) {
|
|
const value = config[key];
|
|
if (!isUndefined2(value)) {
|
|
options[key] = value;
|
|
}
|
|
}
|
|
}
|
|
return options;
|
|
}
|
|
function parseWidth(width) {
|
|
if (width === "")
|
|
return width;
|
|
if (!isUndefined2(width)) {
|
|
width = Number.parseInt(width, 10);
|
|
if (Number.isNaN(width)) {
|
|
width = "";
|
|
}
|
|
}
|
|
return width;
|
|
}
|
|
function parseMinWidth(minWidth) {
|
|
if (minWidth === "")
|
|
return minWidth;
|
|
if (!isUndefined2(minWidth)) {
|
|
minWidth = parseWidth(minWidth);
|
|
if (Number.isNaN(minWidth)) {
|
|
minWidth = 80;
|
|
}
|
|
}
|
|
return minWidth;
|
|
}
|
|
function parseHeight(height) {
|
|
if (isNumber2(height)) {
|
|
return height;
|
|
}
|
|
if (isString(height)) {
|
|
if (/^\d+(?:px)?$/.test(height)) {
|
|
return Number.parseInt(height, 10);
|
|
} else {
|
|
return height;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
function compose(...funcs) {
|
|
if (funcs.length === 0) {
|
|
return (arg) => arg;
|
|
}
|
|
if (funcs.length === 1) {
|
|
return funcs[0];
|
|
}
|
|
return funcs.reduce((a2, b2) => (...args) => a2(b2(...args)));
|
|
}
|
|
function toggleRowStatus(statusArr, row, newVal, tableTreeProps, selectable, rowIndex) {
|
|
let _rowIndex = rowIndex != null ? rowIndex : 0;
|
|
let changed = false;
|
|
const index = statusArr.indexOf(row);
|
|
const included = index !== -1;
|
|
const isRowSelectable = selectable == null ? void 0 : selectable.call(null, row, _rowIndex);
|
|
const toggleStatus = (type4) => {
|
|
if (type4 === "add") {
|
|
statusArr.push(row);
|
|
} else {
|
|
statusArr.splice(index, 1);
|
|
}
|
|
changed = true;
|
|
};
|
|
const getChildrenCount = (row2) => {
|
|
let count = 0;
|
|
const children = (tableTreeProps == null ? void 0 : tableTreeProps.children) && row2[tableTreeProps.children];
|
|
if (children && isArray(children)) {
|
|
count += children.length;
|
|
children.forEach((item) => {
|
|
count += getChildrenCount(item);
|
|
});
|
|
}
|
|
return count;
|
|
};
|
|
if (!selectable || isRowSelectable) {
|
|
if (isBoolean2(newVal)) {
|
|
if (newVal && !included) {
|
|
toggleStatus("add");
|
|
} else if (!newVal && included) {
|
|
toggleStatus("remove");
|
|
}
|
|
} else {
|
|
included ? toggleStatus("remove") : toggleStatus("add");
|
|
}
|
|
}
|
|
if (!(tableTreeProps == null ? void 0 : tableTreeProps.checkStrictly) && (tableTreeProps == null ? void 0 : tableTreeProps.children) && isArray(row[tableTreeProps.children])) {
|
|
row[tableTreeProps.children].forEach((item) => {
|
|
const childChanged = toggleRowStatus(statusArr, item, newVal != null ? newVal : !included, tableTreeProps, selectable, _rowIndex + 1);
|
|
_rowIndex += getChildrenCount(item) + 1;
|
|
if (childChanged) {
|
|
changed = childChanged;
|
|
}
|
|
});
|
|
}
|
|
return changed;
|
|
}
|
|
function walkTreeNode(root2, cb, childrenKey = "children", lazyKey = "hasChildren") {
|
|
const isNil2 = (array4) => !(isArray(array4) && array4.length);
|
|
function _walker(parent2, children, level) {
|
|
cb(parent2, children, level);
|
|
children.forEach((item) => {
|
|
if (item[lazyKey]) {
|
|
cb(item, null, level + 1);
|
|
return;
|
|
}
|
|
const children2 = item[childrenKey];
|
|
if (!isNil2(children2)) {
|
|
_walker(item, children2, level + 1);
|
|
}
|
|
});
|
|
}
|
|
root2.forEach((item) => {
|
|
if (item[lazyKey]) {
|
|
cb(item, null, 0);
|
|
return;
|
|
}
|
|
const children = item[childrenKey];
|
|
if (!isNil2(children)) {
|
|
_walker(item, children, 0);
|
|
}
|
|
});
|
|
}
|
|
var getTableOverflowTooltipProps = (props2, innerText, row, column2) => {
|
|
const popperOptions = {
|
|
strategy: "fixed",
|
|
...props2.popperOptions
|
|
};
|
|
const tooltipFormatterContent = isFunction(column2.tooltipFormatter) ? column2.tooltipFormatter({
|
|
row,
|
|
column: column2,
|
|
cellValue: getProp(row, column2.property).value
|
|
}) : void 0;
|
|
if (isVNode(tooltipFormatterContent)) {
|
|
return {
|
|
slotContent: tooltipFormatterContent,
|
|
content: null,
|
|
...props2,
|
|
popperOptions
|
|
};
|
|
}
|
|
return {
|
|
slotContent: null,
|
|
content: tooltipFormatterContent != null ? tooltipFormatterContent : innerText,
|
|
...props2,
|
|
popperOptions
|
|
};
|
|
};
|
|
var removePopper = null;
|
|
function createTablePopper(props2, popperContent, row, column2, trigger, table) {
|
|
const tableOverflowTooltipProps = getTableOverflowTooltipProps(props2, popperContent, row, column2);
|
|
const mergedProps = {
|
|
...tableOverflowTooltipProps,
|
|
slotContent: void 0
|
|
};
|
|
if ((removePopper == null ? void 0 : removePopper.trigger) === trigger) {
|
|
const comp = removePopper.vm.component;
|
|
merge_default(comp.props, mergedProps);
|
|
if (tableOverflowTooltipProps.slotContent) {
|
|
comp.slots.content = () => [tableOverflowTooltipProps.slotContent];
|
|
}
|
|
return;
|
|
}
|
|
removePopper == null ? void 0 : removePopper();
|
|
const parentNode = table == null ? void 0 : table.refs.tableWrapper;
|
|
const ns = parentNode == null ? void 0 : parentNode.dataset.prefix;
|
|
const vm = createVNode(ElTooltip, {
|
|
virtualTriggering: true,
|
|
virtualRef: trigger,
|
|
appendTo: parentNode,
|
|
placement: "top",
|
|
transition: "none",
|
|
offset: 0,
|
|
hideAfter: 0,
|
|
...mergedProps
|
|
}, tableOverflowTooltipProps.slotContent ? {
|
|
content: () => tableOverflowTooltipProps.slotContent
|
|
} : void 0);
|
|
vm.appContext = { ...table.appContext, ...table };
|
|
const container = document.createElement("div");
|
|
render(vm, container);
|
|
vm.component.exposed.onOpen();
|
|
const scrollContainer = parentNode == null ? void 0 : parentNode.querySelector(`.${ns}-scrollbar__wrap`);
|
|
removePopper = () => {
|
|
render(null, container);
|
|
scrollContainer == null ? void 0 : scrollContainer.removeEventListener("scroll", removePopper);
|
|
removePopper = null;
|
|
};
|
|
removePopper.trigger = trigger;
|
|
removePopper.vm = vm;
|
|
scrollContainer == null ? void 0 : scrollContainer.addEventListener("scroll", removePopper);
|
|
}
|
|
function getCurrentColumns(column2) {
|
|
if (column2.children) {
|
|
return flatMap_default(column2.children, getCurrentColumns);
|
|
} else {
|
|
return [column2];
|
|
}
|
|
}
|
|
function getColSpan(colSpan, column2) {
|
|
return colSpan + column2.colSpan;
|
|
}
|
|
var isFixedColumn = (index, fixed, store, realColumns) => {
|
|
let start = 0;
|
|
let after2 = index;
|
|
const columns2 = store.states.columns.value;
|
|
if (realColumns) {
|
|
const curColumns = getCurrentColumns(realColumns[index]);
|
|
const preColumns = columns2.slice(0, columns2.indexOf(curColumns[0]));
|
|
start = preColumns.reduce(getColSpan, 0);
|
|
after2 = start + curColumns.reduce(getColSpan, 0) - 1;
|
|
} else {
|
|
start = index;
|
|
}
|
|
let fixedLayout;
|
|
switch (fixed) {
|
|
case "left":
|
|
if (after2 < store.states.fixedLeafColumnsLength.value) {
|
|
fixedLayout = "left";
|
|
}
|
|
break;
|
|
case "right":
|
|
if (start >= columns2.length - store.states.rightFixedLeafColumnsLength.value) {
|
|
fixedLayout = "right";
|
|
}
|
|
break;
|
|
default:
|
|
if (after2 < store.states.fixedLeafColumnsLength.value) {
|
|
fixedLayout = "left";
|
|
} else if (start >= columns2.length - store.states.rightFixedLeafColumnsLength.value) {
|
|
fixedLayout = "right";
|
|
}
|
|
}
|
|
return fixedLayout ? {
|
|
direction: fixedLayout,
|
|
start,
|
|
after: after2
|
|
} : {};
|
|
};
|
|
var getFixedColumnsClass = (namespace, index, fixed, store, realColumns, offset3 = 0) => {
|
|
const classes = [];
|
|
const { direction: direction2, start, after: after2 } = isFixedColumn(index, fixed, store, realColumns);
|
|
if (direction2) {
|
|
const isLeft = direction2 === "left";
|
|
classes.push(`${namespace}-fixed-column--${direction2}`);
|
|
if (isLeft && after2 + offset3 === store.states.fixedLeafColumnsLength.value - 1) {
|
|
classes.push("is-last-column");
|
|
} else if (!isLeft && start - offset3 === store.states.columns.value.length - store.states.rightFixedLeafColumnsLength.value) {
|
|
classes.push("is-first-column");
|
|
}
|
|
}
|
|
return classes;
|
|
};
|
|
function getOffset(offset3, column2) {
|
|
return offset3 + (isNull_default(column2.realWidth) || Number.isNaN(column2.realWidth) ? Number(column2.width) : column2.realWidth);
|
|
}
|
|
var getFixedColumnOffset = (index, fixed, store, realColumns) => {
|
|
const {
|
|
direction: direction2,
|
|
start = 0,
|
|
after: after2 = 0
|
|
} = isFixedColumn(index, fixed, store, realColumns);
|
|
if (!direction2) {
|
|
return;
|
|
}
|
|
const styles = {};
|
|
const isLeft = direction2 === "left";
|
|
const columns2 = store.states.columns.value;
|
|
if (isLeft) {
|
|
styles.left = columns2.slice(0, start).reduce(getOffset, 0);
|
|
} else {
|
|
styles.right = columns2.slice(after2 + 1).reverse().reduce(getOffset, 0);
|
|
}
|
|
return styles;
|
|
};
|
|
var ensurePosition = (style, key) => {
|
|
if (!style)
|
|
return;
|
|
if (!Number.isNaN(style[key])) {
|
|
style[key] = `${style[key]}px`;
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table/src/store/expand.mjs
|
|
function useExpand(watcherData) {
|
|
const instance = getCurrentInstance();
|
|
const defaultExpandAll = ref(false);
|
|
const expandRows = ref([]);
|
|
const updateExpandRows = () => {
|
|
const data = watcherData.data.value || [];
|
|
const rowKey2 = watcherData.rowKey.value;
|
|
if (defaultExpandAll.value) {
|
|
expandRows.value = data.slice();
|
|
} else if (rowKey2) {
|
|
const expandRowsMap = getKeysMap(expandRows.value, rowKey2);
|
|
expandRows.value = data.reduce((prev, row) => {
|
|
const rowId = getRowIdentity(row, rowKey2);
|
|
const rowInfo = expandRowsMap[rowId];
|
|
if (rowInfo) {
|
|
prev.push(row);
|
|
}
|
|
return prev;
|
|
}, []);
|
|
} else {
|
|
expandRows.value = [];
|
|
}
|
|
};
|
|
const toggleRowExpansion = (row, expanded) => {
|
|
const changed = toggleRowStatus(expandRows.value, row, expanded);
|
|
if (changed) {
|
|
instance.emit("expand-change", row, expandRows.value.slice());
|
|
}
|
|
};
|
|
const setExpandRowKeys = (rowKeys) => {
|
|
instance.store.assertRowKey();
|
|
const data = watcherData.data.value || [];
|
|
const rowKey2 = watcherData.rowKey.value;
|
|
const keysMap = getKeysMap(data, rowKey2);
|
|
expandRows.value = rowKeys.reduce((prev, cur) => {
|
|
const info = keysMap[cur];
|
|
if (info) {
|
|
prev.push(info.row);
|
|
}
|
|
return prev;
|
|
}, []);
|
|
};
|
|
const isRowExpanded = (row) => {
|
|
const rowKey2 = watcherData.rowKey.value;
|
|
if (rowKey2) {
|
|
const expandMap = getKeysMap(expandRows.value, rowKey2);
|
|
return !!expandMap[getRowIdentity(row, rowKey2)];
|
|
}
|
|
return expandRows.value.includes(row);
|
|
};
|
|
return {
|
|
updateExpandRows,
|
|
toggleRowExpansion,
|
|
setExpandRowKeys,
|
|
isRowExpanded,
|
|
states: {
|
|
expandRows,
|
|
defaultExpandAll
|
|
}
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/store/current.mjs
|
|
function useCurrent(watcherData) {
|
|
const instance = getCurrentInstance();
|
|
const _currentRowKey = ref(null);
|
|
const currentRow = ref(null);
|
|
const setCurrentRowKey = (key) => {
|
|
instance.store.assertRowKey();
|
|
_currentRowKey.value = key;
|
|
setCurrentRowByKey(key);
|
|
};
|
|
const restoreCurrentRowKey = () => {
|
|
_currentRowKey.value = null;
|
|
};
|
|
const setCurrentRowByKey = (key) => {
|
|
const { data, rowKey: rowKey2 } = watcherData;
|
|
let _currentRow = null;
|
|
if (rowKey2.value) {
|
|
_currentRow = (unref(data) || []).find((item) => getRowIdentity(item, rowKey2.value) === key);
|
|
}
|
|
currentRow.value = _currentRow;
|
|
instance.emit("current-change", currentRow.value, null);
|
|
};
|
|
const updateCurrentRow = (_currentRow) => {
|
|
const oldCurrentRow = currentRow.value;
|
|
if (_currentRow && _currentRow !== oldCurrentRow) {
|
|
currentRow.value = _currentRow;
|
|
instance.emit("current-change", currentRow.value, oldCurrentRow);
|
|
return;
|
|
}
|
|
if (!_currentRow && oldCurrentRow) {
|
|
currentRow.value = null;
|
|
instance.emit("current-change", null, oldCurrentRow);
|
|
}
|
|
};
|
|
const updateCurrentRowData = () => {
|
|
const rowKey2 = watcherData.rowKey.value;
|
|
const data = watcherData.data.value || [];
|
|
const oldCurrentRow = currentRow.value;
|
|
if (!data.includes(oldCurrentRow) && oldCurrentRow) {
|
|
if (rowKey2) {
|
|
const currentRowKey = getRowIdentity(oldCurrentRow, rowKey2);
|
|
setCurrentRowByKey(currentRowKey);
|
|
} else {
|
|
currentRow.value = null;
|
|
}
|
|
if (isNull_default(currentRow.value)) {
|
|
instance.emit("current-change", null, oldCurrentRow);
|
|
}
|
|
} else if (_currentRowKey.value) {
|
|
setCurrentRowByKey(_currentRowKey.value);
|
|
restoreCurrentRowKey();
|
|
}
|
|
};
|
|
return {
|
|
setCurrentRowKey,
|
|
restoreCurrentRowKey,
|
|
setCurrentRowByKey,
|
|
updateCurrentRow,
|
|
updateCurrentRowData,
|
|
states: {
|
|
_currentRowKey,
|
|
currentRow
|
|
}
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/store/tree.mjs
|
|
function useTree(watcherData) {
|
|
const expandRowKeys = ref([]);
|
|
const treeData = ref({});
|
|
const indent = ref(16);
|
|
const lazy = ref(false);
|
|
const lazyTreeNodeMap = ref({});
|
|
const lazyColumnIdentifier = ref("hasChildren");
|
|
const childrenColumnName = ref("children");
|
|
const checkStrictly = ref(false);
|
|
const instance = getCurrentInstance();
|
|
const normalizedData = computed(() => {
|
|
if (!watcherData.rowKey.value)
|
|
return {};
|
|
const data = watcherData.data.value || [];
|
|
return normalize(data);
|
|
});
|
|
const normalizedLazyNode = computed(() => {
|
|
const rowKey2 = watcherData.rowKey.value;
|
|
const keys3 = Object.keys(lazyTreeNodeMap.value);
|
|
const res = {};
|
|
if (!keys3.length)
|
|
return res;
|
|
keys3.forEach((key) => {
|
|
if (lazyTreeNodeMap.value[key].length) {
|
|
const item = { children: [] };
|
|
lazyTreeNodeMap.value[key].forEach((row) => {
|
|
const currentRowKey = getRowIdentity(row, rowKey2);
|
|
item.children.push(currentRowKey);
|
|
if (row[lazyColumnIdentifier.value] && !res[currentRowKey]) {
|
|
res[currentRowKey] = { children: [] };
|
|
}
|
|
});
|
|
res[key] = item;
|
|
}
|
|
});
|
|
return res;
|
|
});
|
|
const normalize = (data) => {
|
|
const rowKey2 = watcherData.rowKey.value;
|
|
const res = {};
|
|
walkTreeNode(data, (parent2, children, level) => {
|
|
const parentId = getRowIdentity(parent2, rowKey2);
|
|
if (isArray(children)) {
|
|
res[parentId] = {
|
|
children: children.map((row) => getRowIdentity(row, rowKey2)),
|
|
level
|
|
};
|
|
} else if (lazy.value) {
|
|
res[parentId] = {
|
|
children: [],
|
|
lazy: true,
|
|
level
|
|
};
|
|
}
|
|
}, childrenColumnName.value, lazyColumnIdentifier.value);
|
|
return res;
|
|
};
|
|
const updateTreeData = (ifChangeExpandRowKeys = false, ifExpandAll = ((_a2) => (_a2 = instance.store) == null ? void 0 : _a2.states.defaultExpandAll.value)()) => {
|
|
var _a2;
|
|
const nested = normalizedData.value;
|
|
const normalizedLazyNode_ = normalizedLazyNode.value;
|
|
const keys3 = Object.keys(nested);
|
|
const newTreeData = {};
|
|
if (keys3.length) {
|
|
const oldTreeData = unref(treeData);
|
|
const rootLazyRowKeys = [];
|
|
const getExpanded = (oldValue, key) => {
|
|
if (ifChangeExpandRowKeys) {
|
|
if (expandRowKeys.value) {
|
|
return ifExpandAll || expandRowKeys.value.includes(key);
|
|
} else {
|
|
return !!(ifExpandAll || (oldValue == null ? void 0 : oldValue.expanded));
|
|
}
|
|
} else {
|
|
const included = ifExpandAll || expandRowKeys.value && expandRowKeys.value.includes(key);
|
|
return !!((oldValue == null ? void 0 : oldValue.expanded) || included);
|
|
}
|
|
};
|
|
keys3.forEach((key) => {
|
|
const oldValue = oldTreeData[key];
|
|
const newValue = { ...nested[key] };
|
|
newValue.expanded = getExpanded(oldValue, key);
|
|
if (newValue.lazy) {
|
|
const { loaded = false, loading = false } = oldValue || {};
|
|
newValue.loaded = !!loaded;
|
|
newValue.loading = !!loading;
|
|
rootLazyRowKeys.push(key);
|
|
}
|
|
newTreeData[key] = newValue;
|
|
});
|
|
const lazyKeys = Object.keys(normalizedLazyNode_);
|
|
if (lazy.value && lazyKeys.length && rootLazyRowKeys.length) {
|
|
lazyKeys.forEach((key) => {
|
|
const oldValue = oldTreeData[key];
|
|
const lazyNodeChildren = normalizedLazyNode_[key].children;
|
|
if (rootLazyRowKeys.includes(key)) {
|
|
if (newTreeData[key].children.length !== 0) {
|
|
throw new Error("[ElTable]children must be an empty array.");
|
|
}
|
|
newTreeData[key].children = lazyNodeChildren;
|
|
} else {
|
|
const { loaded = false, loading = false } = oldValue || {};
|
|
newTreeData[key] = {
|
|
lazy: true,
|
|
loaded: !!loaded,
|
|
loading: !!loading,
|
|
expanded: getExpanded(oldValue, key),
|
|
children: lazyNodeChildren,
|
|
level: ""
|
|
};
|
|
}
|
|
});
|
|
}
|
|
}
|
|
treeData.value = newTreeData;
|
|
(_a2 = instance.store) == null ? void 0 : _a2.updateTableScrollY();
|
|
};
|
|
watch(() => expandRowKeys.value, () => {
|
|
updateTreeData(true);
|
|
});
|
|
watch(() => normalizedData.value, () => {
|
|
updateTreeData();
|
|
});
|
|
watch(() => normalizedLazyNode.value, () => {
|
|
updateTreeData();
|
|
});
|
|
const updateTreeExpandKeys = (value) => {
|
|
expandRowKeys.value = value;
|
|
updateTreeData();
|
|
};
|
|
const isUseLazy = (data) => {
|
|
return lazy.value && data && "loaded" in data && !data.loaded;
|
|
};
|
|
const toggleTreeExpansion = (row, expanded) => {
|
|
instance.store.assertRowKey();
|
|
const rowKey2 = watcherData.rowKey.value;
|
|
const id = getRowIdentity(row, rowKey2);
|
|
const data = id && treeData.value[id];
|
|
if (id && data && "expanded" in data) {
|
|
const oldExpanded = data.expanded;
|
|
expanded = isUndefined2(expanded) ? !data.expanded : expanded;
|
|
treeData.value[id].expanded = expanded;
|
|
if (oldExpanded !== expanded) {
|
|
instance.emit("expand-change", row, expanded);
|
|
}
|
|
isUseLazy(data) && loadData(row, id, data);
|
|
instance.store.updateTableScrollY();
|
|
}
|
|
};
|
|
const loadOrToggle = (row) => {
|
|
instance.store.assertRowKey();
|
|
const rowKey2 = watcherData.rowKey.value;
|
|
const id = getRowIdentity(row, rowKey2);
|
|
const data = treeData.value[id];
|
|
if (isUseLazy(data)) {
|
|
loadData(row, id, data);
|
|
} else {
|
|
toggleTreeExpansion(row, void 0);
|
|
}
|
|
};
|
|
const loadData = (row, key, treeNode) => {
|
|
const { load } = instance.props;
|
|
if (load && !treeData.value[key].loaded) {
|
|
treeData.value[key].loading = true;
|
|
load(row, treeNode, (data) => {
|
|
if (!isArray(data)) {
|
|
throw new TypeError("[ElTable] data must be an array");
|
|
}
|
|
treeData.value[key].loading = false;
|
|
treeData.value[key].loaded = true;
|
|
treeData.value[key].expanded = true;
|
|
if (data.length) {
|
|
lazyTreeNodeMap.value[key] = data;
|
|
}
|
|
instance.emit("expand-change", row, true);
|
|
});
|
|
}
|
|
};
|
|
const updateKeyChildren = (key, data) => {
|
|
const { lazy: lazy2, rowKey: rowKey2 } = instance.props;
|
|
if (!lazy2)
|
|
return;
|
|
if (!rowKey2)
|
|
throw new Error("[Table] rowKey is required in updateKeyChild");
|
|
if (lazyTreeNodeMap.value[key]) {
|
|
lazyTreeNodeMap.value[key] = data;
|
|
}
|
|
};
|
|
return {
|
|
loadData,
|
|
loadOrToggle,
|
|
toggleTreeExpansion,
|
|
updateTreeExpandKeys,
|
|
updateTreeData,
|
|
updateKeyChildren,
|
|
normalize,
|
|
states: {
|
|
expandRowKeys,
|
|
treeData,
|
|
indent,
|
|
lazy,
|
|
lazyTreeNodeMap,
|
|
lazyColumnIdentifier,
|
|
childrenColumnName,
|
|
checkStrictly
|
|
}
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/store/watcher.mjs
|
|
var sortData = (data, states) => {
|
|
const sortingColumn = states.sortingColumn;
|
|
if (!sortingColumn || isString(sortingColumn.sortable)) {
|
|
return data;
|
|
}
|
|
return orderBy2(data, states.sortProp, states.sortOrder, sortingColumn.sortMethod, sortingColumn.sortBy);
|
|
};
|
|
var doFlattenColumns = (columns2) => {
|
|
const result2 = [];
|
|
columns2.forEach((column2) => {
|
|
if (column2.children && column2.children.length > 0) {
|
|
result2.push.apply(result2, doFlattenColumns(column2.children));
|
|
} else {
|
|
result2.push(column2);
|
|
}
|
|
});
|
|
return result2;
|
|
};
|
|
function useWatcher() {
|
|
var _a2;
|
|
const instance = getCurrentInstance();
|
|
const { size: tableSize } = toRefs((_a2 = instance.proxy) == null ? void 0 : _a2.$props);
|
|
const rowKey2 = ref(null);
|
|
const data = ref([]);
|
|
const _data = ref([]);
|
|
const isComplex = ref(false);
|
|
const _columns = ref([]);
|
|
const originColumns = ref([]);
|
|
const columns2 = ref([]);
|
|
const fixedColumns = ref([]);
|
|
const rightFixedColumns = ref([]);
|
|
const leafColumns = ref([]);
|
|
const fixedLeafColumns = ref([]);
|
|
const rightFixedLeafColumns = ref([]);
|
|
const updateOrderFns = [];
|
|
const leafColumnsLength = ref(0);
|
|
const fixedLeafColumnsLength = ref(0);
|
|
const rightFixedLeafColumnsLength = ref(0);
|
|
const isAllSelected = ref(false);
|
|
const selection = ref([]);
|
|
const reserveSelection = ref(false);
|
|
const selectOnIndeterminate = ref(false);
|
|
const selectable = ref(null);
|
|
const filters = ref({});
|
|
const filteredData = ref(null);
|
|
const sortingColumn = ref(null);
|
|
const sortProp = ref(null);
|
|
const sortOrder = ref(null);
|
|
const hoverRow = ref(null);
|
|
const selectedMap = computed(() => {
|
|
return rowKey2.value ? getKeysMap(selection.value, rowKey2.value) : void 0;
|
|
});
|
|
watch(data, () => {
|
|
var _a22;
|
|
if (instance.state) {
|
|
scheduleLayout(false);
|
|
const needUpdateFixed = instance.props.tableLayout === "auto";
|
|
if (needUpdateFixed) {
|
|
(_a22 = instance.refs.tableHeaderRef) == null ? void 0 : _a22.updateFixedColumnStyle();
|
|
}
|
|
}
|
|
}, {
|
|
deep: true
|
|
});
|
|
const assertRowKey = () => {
|
|
if (!rowKey2.value)
|
|
throw new Error("[ElTable] prop row-key is required");
|
|
};
|
|
const updateChildFixed = (column2) => {
|
|
var _a22;
|
|
(_a22 = column2.children) == null ? void 0 : _a22.forEach((childColumn) => {
|
|
childColumn.fixed = column2.fixed;
|
|
updateChildFixed(childColumn);
|
|
});
|
|
};
|
|
const updateColumns = () => {
|
|
_columns.value.forEach((column2) => {
|
|
updateChildFixed(column2);
|
|
});
|
|
fixedColumns.value = _columns.value.filter((column2) => [true, "left"].includes(column2.fixed));
|
|
const selectColumn = _columns.value.find((column2) => column2.type === "selection");
|
|
let selectColFixLeft;
|
|
if (selectColumn && selectColumn.fixed !== "right" && !fixedColumns.value.includes(selectColumn)) {
|
|
const selectColumnIndex = _columns.value.indexOf(selectColumn);
|
|
if (selectColumnIndex === 0 && fixedColumns.value.length) {
|
|
fixedColumns.value.unshift(selectColumn);
|
|
selectColFixLeft = true;
|
|
}
|
|
}
|
|
rightFixedColumns.value = _columns.value.filter((column2) => column2.fixed === "right");
|
|
const notFixedColumns = _columns.value.filter((column2) => (selectColFixLeft ? column2.type !== "selection" : true) && !column2.fixed);
|
|
originColumns.value = [].concat(fixedColumns.value).concat(notFixedColumns).concat(rightFixedColumns.value);
|
|
const leafColumns2 = doFlattenColumns(notFixedColumns);
|
|
const fixedLeafColumns2 = doFlattenColumns(fixedColumns.value);
|
|
const rightFixedLeafColumns2 = doFlattenColumns(rightFixedColumns.value);
|
|
leafColumnsLength.value = leafColumns2.length;
|
|
fixedLeafColumnsLength.value = fixedLeafColumns2.length;
|
|
rightFixedLeafColumnsLength.value = rightFixedLeafColumns2.length;
|
|
columns2.value = [].concat(fixedLeafColumns2).concat(leafColumns2).concat(rightFixedLeafColumns2);
|
|
isComplex.value = fixedColumns.value.length > 0 || rightFixedColumns.value.length > 0;
|
|
};
|
|
const scheduleLayout = (needUpdateColumns, immediate = false) => {
|
|
if (needUpdateColumns) {
|
|
updateColumns();
|
|
}
|
|
if (immediate) {
|
|
instance.state.doLayout();
|
|
} else {
|
|
instance.state.debouncedUpdateLayout();
|
|
}
|
|
};
|
|
const isSelected = (row) => {
|
|
if (selectedMap.value) {
|
|
return !!selectedMap.value[getRowIdentity(row, rowKey2.value)];
|
|
} else {
|
|
return selection.value.includes(row);
|
|
}
|
|
};
|
|
const clearSelection = () => {
|
|
isAllSelected.value = false;
|
|
const oldSelection = selection.value;
|
|
selection.value = [];
|
|
if (oldSelection.length) {
|
|
instance.emit("selection-change", []);
|
|
}
|
|
};
|
|
const cleanSelection = () => {
|
|
var _a22, _b;
|
|
let deleted;
|
|
if (rowKey2.value) {
|
|
deleted = [];
|
|
const childrenKey = (_b = (_a22 = instance == null ? void 0 : instance.store) == null ? void 0 : _a22.states) == null ? void 0 : _b.childrenColumnName.value;
|
|
const dataMap = getKeysMap(data.value, rowKey2.value, true, childrenKey);
|
|
for (const key in selectedMap.value) {
|
|
if (hasOwn(selectedMap.value, key) && !dataMap[key]) {
|
|
deleted.push(selectedMap.value[key].row);
|
|
}
|
|
}
|
|
} else {
|
|
deleted = selection.value.filter((item) => !data.value.includes(item));
|
|
}
|
|
if (deleted.length) {
|
|
const newSelection = selection.value.filter((item) => !deleted.includes(item));
|
|
selection.value = newSelection;
|
|
instance.emit("selection-change", newSelection.slice());
|
|
}
|
|
};
|
|
const getSelectionRows = () => {
|
|
return (selection.value || []).slice();
|
|
};
|
|
const toggleRowSelection = (row, selected, emitChange = true, ignoreSelectable = false) => {
|
|
var _a22, _b, _c, _d;
|
|
const treeProps2 = {
|
|
children: (_b = (_a22 = instance == null ? void 0 : instance.store) == null ? void 0 : _a22.states) == null ? void 0 : _b.childrenColumnName.value,
|
|
checkStrictly: (_d = (_c = instance == null ? void 0 : instance.store) == null ? void 0 : _c.states) == null ? void 0 : _d.checkStrictly.value
|
|
};
|
|
const changed = toggleRowStatus(selection.value, row, selected, treeProps2, ignoreSelectable ? void 0 : selectable.value, data.value.indexOf(row));
|
|
if (changed) {
|
|
const newSelection = (selection.value || []).slice();
|
|
if (emitChange) {
|
|
instance.emit("select", newSelection, row);
|
|
}
|
|
instance.emit("selection-change", newSelection);
|
|
}
|
|
};
|
|
const _toggleAllSelection = () => {
|
|
var _a22, _b;
|
|
const value = selectOnIndeterminate.value ? !isAllSelected.value : !(isAllSelected.value || selection.value.length);
|
|
isAllSelected.value = value;
|
|
let selectionChanged = false;
|
|
let childrenCount = 0;
|
|
const rowKey22 = (_b = (_a22 = instance == null ? void 0 : instance.store) == null ? void 0 : _a22.states) == null ? void 0 : _b.rowKey.value;
|
|
const { childrenColumnName } = instance.store.states;
|
|
const treeProps2 = {
|
|
children: childrenColumnName.value,
|
|
checkStrictly: false
|
|
};
|
|
data.value.forEach((row, index) => {
|
|
const rowIndex = index + childrenCount;
|
|
if (toggleRowStatus(selection.value, row, value, treeProps2, selectable.value, rowIndex)) {
|
|
selectionChanged = true;
|
|
}
|
|
childrenCount += getChildrenCount(getRowIdentity(row, rowKey22));
|
|
});
|
|
if (selectionChanged) {
|
|
instance.emit("selection-change", selection.value ? selection.value.slice() : []);
|
|
}
|
|
instance.emit("select-all", (selection.value || []).slice());
|
|
};
|
|
const updateSelectionByRowKey = () => {
|
|
data.value.forEach((row) => {
|
|
const rowId = getRowIdentity(row, rowKey2.value);
|
|
const rowInfo = selectedMap.value[rowId];
|
|
if (rowInfo) {
|
|
selection.value[rowInfo.index] = row;
|
|
}
|
|
});
|
|
};
|
|
const updateAllSelected = () => {
|
|
var _a22;
|
|
if (((_a22 = data.value) == null ? void 0 : _a22.length) === 0) {
|
|
isAllSelected.value = false;
|
|
return;
|
|
}
|
|
const { childrenColumnName } = instance.store.states;
|
|
let rowIndex = 0;
|
|
let selectedCount = 0;
|
|
const checkSelectedStatus = (data2) => {
|
|
var _a3;
|
|
for (const row of data2) {
|
|
const isRowSelectable = selectable.value && selectable.value.call(null, row, rowIndex);
|
|
if (!isSelected(row)) {
|
|
if (!selectable.value || isRowSelectable) {
|
|
return false;
|
|
}
|
|
} else {
|
|
selectedCount++;
|
|
}
|
|
rowIndex++;
|
|
if (((_a3 = row[childrenColumnName.value]) == null ? void 0 : _a3.length) && !checkSelectedStatus(row[childrenColumnName.value])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
const isAllSelected_ = checkSelectedStatus(data.value || []);
|
|
isAllSelected.value = selectedCount === 0 ? false : isAllSelected_;
|
|
};
|
|
const getChildrenCount = (rowKey22) => {
|
|
var _a22;
|
|
if (!instance || !instance.store)
|
|
return 0;
|
|
const { treeData } = instance.store.states;
|
|
let count = 0;
|
|
const children = (_a22 = treeData.value[rowKey22]) == null ? void 0 : _a22.children;
|
|
if (children) {
|
|
count += children.length;
|
|
children.forEach((childKey) => {
|
|
count += getChildrenCount(childKey);
|
|
});
|
|
}
|
|
return count;
|
|
};
|
|
const updateFilters = (columns22, values2) => {
|
|
if (!isArray(columns22)) {
|
|
columns22 = [columns22];
|
|
}
|
|
const filters_ = {};
|
|
columns22.forEach((col) => {
|
|
filters.value[col.id] = values2;
|
|
filters_[col.columnKey || col.id] = values2;
|
|
});
|
|
return filters_;
|
|
};
|
|
const updateSort = (column2, prop, order) => {
|
|
if (sortingColumn.value && sortingColumn.value !== column2) {
|
|
sortingColumn.value.order = null;
|
|
}
|
|
sortingColumn.value = column2;
|
|
sortProp.value = prop;
|
|
sortOrder.value = order;
|
|
};
|
|
const execFilter = () => {
|
|
let sourceData = unref(_data);
|
|
Object.keys(filters.value).forEach((columnId) => {
|
|
const values2 = filters.value[columnId];
|
|
if (!values2 || values2.length === 0)
|
|
return;
|
|
const column2 = getColumnById({
|
|
columns: columns2.value
|
|
}, columnId);
|
|
if (column2 && column2.filterMethod) {
|
|
sourceData = sourceData.filter((row) => {
|
|
return values2.some((value) => column2.filterMethod.call(null, value, row, column2));
|
|
});
|
|
}
|
|
});
|
|
filteredData.value = sourceData;
|
|
};
|
|
const execSort = () => {
|
|
data.value = sortData(filteredData.value, {
|
|
sortingColumn: sortingColumn.value,
|
|
sortProp: sortProp.value,
|
|
sortOrder: sortOrder.value
|
|
});
|
|
};
|
|
const execQuery = (ignore = void 0) => {
|
|
if (!(ignore && ignore.filter)) {
|
|
execFilter();
|
|
}
|
|
execSort();
|
|
};
|
|
const clearFilter = (columnKeys) => {
|
|
const { tableHeaderRef } = instance.refs;
|
|
if (!tableHeaderRef)
|
|
return;
|
|
const panels = Object.assign({}, tableHeaderRef.filterPanels);
|
|
const keys3 = Object.keys(panels);
|
|
if (!keys3.length)
|
|
return;
|
|
if (isString(columnKeys)) {
|
|
columnKeys = [columnKeys];
|
|
}
|
|
if (isArray(columnKeys)) {
|
|
const columns_ = columnKeys.map((key) => getColumnByKey({
|
|
columns: columns2.value
|
|
}, key));
|
|
keys3.forEach((key) => {
|
|
const column2 = columns_.find((col) => col.id === key);
|
|
if (column2) {
|
|
column2.filteredValue = [];
|
|
}
|
|
});
|
|
instance.store.commit("filterChange", {
|
|
column: columns_,
|
|
values: [],
|
|
silent: true,
|
|
multi: true
|
|
});
|
|
} else {
|
|
keys3.forEach((key) => {
|
|
const column2 = columns2.value.find((col) => col.id === key);
|
|
if (column2) {
|
|
column2.filteredValue = [];
|
|
}
|
|
});
|
|
filters.value = {};
|
|
instance.store.commit("filterChange", {
|
|
column: {},
|
|
values: [],
|
|
silent: true
|
|
});
|
|
}
|
|
};
|
|
const clearSort = () => {
|
|
if (!sortingColumn.value)
|
|
return;
|
|
updateSort(null, null, null);
|
|
instance.store.commit("changeSortCondition", {
|
|
silent: true
|
|
});
|
|
};
|
|
const {
|
|
setExpandRowKeys,
|
|
toggleRowExpansion,
|
|
updateExpandRows,
|
|
states: expandStates,
|
|
isRowExpanded
|
|
} = useExpand({
|
|
data,
|
|
rowKey: rowKey2
|
|
});
|
|
const {
|
|
updateTreeExpandKeys,
|
|
toggleTreeExpansion,
|
|
updateTreeData,
|
|
updateKeyChildren,
|
|
loadOrToggle,
|
|
states: treeStates
|
|
} = useTree({
|
|
data,
|
|
rowKey: rowKey2
|
|
});
|
|
const {
|
|
updateCurrentRowData,
|
|
updateCurrentRow,
|
|
setCurrentRowKey,
|
|
states: currentData
|
|
} = useCurrent({
|
|
data,
|
|
rowKey: rowKey2
|
|
});
|
|
const setExpandRowKeysAdapter = (val) => {
|
|
setExpandRowKeys(val);
|
|
updateTreeExpandKeys(val);
|
|
};
|
|
const toggleRowExpansionAdapter = (row, expanded) => {
|
|
const hasExpandColumn = columns2.value.some(({ type: type4 }) => type4 === "expand");
|
|
if (hasExpandColumn) {
|
|
toggleRowExpansion(row, expanded);
|
|
} else {
|
|
toggleTreeExpansion(row, expanded);
|
|
}
|
|
};
|
|
return {
|
|
assertRowKey,
|
|
updateColumns,
|
|
scheduleLayout,
|
|
isSelected,
|
|
clearSelection,
|
|
cleanSelection,
|
|
getSelectionRows,
|
|
toggleRowSelection,
|
|
_toggleAllSelection,
|
|
toggleAllSelection: null,
|
|
updateSelectionByRowKey,
|
|
updateAllSelected,
|
|
updateFilters,
|
|
updateCurrentRow,
|
|
updateSort,
|
|
execFilter,
|
|
execSort,
|
|
execQuery,
|
|
clearFilter,
|
|
clearSort,
|
|
toggleRowExpansion,
|
|
setExpandRowKeysAdapter,
|
|
setCurrentRowKey,
|
|
toggleRowExpansionAdapter,
|
|
isRowExpanded,
|
|
updateExpandRows,
|
|
updateCurrentRowData,
|
|
loadOrToggle,
|
|
updateTreeData,
|
|
updateKeyChildren,
|
|
states: {
|
|
tableSize,
|
|
rowKey: rowKey2,
|
|
data,
|
|
_data,
|
|
isComplex,
|
|
_columns,
|
|
originColumns,
|
|
columns: columns2,
|
|
fixedColumns,
|
|
rightFixedColumns,
|
|
leafColumns,
|
|
fixedLeafColumns,
|
|
rightFixedLeafColumns,
|
|
updateOrderFns,
|
|
leafColumnsLength,
|
|
fixedLeafColumnsLength,
|
|
rightFixedLeafColumnsLength,
|
|
isAllSelected,
|
|
selection,
|
|
reserveSelection,
|
|
selectOnIndeterminate,
|
|
selectable,
|
|
filters,
|
|
filteredData,
|
|
sortingColumn,
|
|
sortProp,
|
|
sortOrder,
|
|
hoverRow,
|
|
...expandStates,
|
|
...treeStates,
|
|
...currentData
|
|
}
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/store/index.mjs
|
|
function replaceColumn(array4, column2) {
|
|
return array4.map((item) => {
|
|
var _a2;
|
|
if (item.id === column2.id) {
|
|
return column2;
|
|
} else if ((_a2 = item.children) == null ? void 0 : _a2.length) {
|
|
item.children = replaceColumn(item.children, column2);
|
|
}
|
|
return item;
|
|
});
|
|
}
|
|
function sortColumn(array4) {
|
|
array4.forEach((item) => {
|
|
var _a2, _b;
|
|
item.no = (_a2 = item.getColumnIndex) == null ? void 0 : _a2.call(item);
|
|
if ((_b = item.children) == null ? void 0 : _b.length) {
|
|
sortColumn(item.children);
|
|
}
|
|
});
|
|
array4.sort((cur, pre) => cur.no - pre.no);
|
|
}
|
|
function useStore() {
|
|
const instance = getCurrentInstance();
|
|
const watcher = useWatcher();
|
|
const ns = useNamespace("table");
|
|
const mutations = {
|
|
setData(states, data) {
|
|
const dataInstanceChanged = unref(states._data) !== data;
|
|
states.data.value = data;
|
|
states._data.value = data;
|
|
instance.store.execQuery();
|
|
instance.store.updateCurrentRowData();
|
|
instance.store.updateExpandRows();
|
|
instance.store.updateTreeData(instance.store.states.defaultExpandAll.value);
|
|
if (unref(states.reserveSelection)) {
|
|
instance.store.assertRowKey();
|
|
instance.store.updateSelectionByRowKey();
|
|
} else {
|
|
if (dataInstanceChanged) {
|
|
instance.store.clearSelection();
|
|
} else {
|
|
instance.store.cleanSelection();
|
|
}
|
|
}
|
|
instance.store.updateAllSelected();
|
|
if (instance.$ready) {
|
|
instance.store.scheduleLayout();
|
|
}
|
|
},
|
|
insertColumn(states, column2, parent2, updateColumnOrder) {
|
|
const array4 = unref(states._columns);
|
|
let newColumns = [];
|
|
if (!parent2) {
|
|
array4.push(column2);
|
|
newColumns = array4;
|
|
} else {
|
|
if (parent2 && !parent2.children) {
|
|
parent2.children = [];
|
|
}
|
|
parent2.children.push(column2);
|
|
newColumns = replaceColumn(array4, parent2);
|
|
}
|
|
sortColumn(newColumns);
|
|
states._columns.value = newColumns;
|
|
states.updateOrderFns.push(updateColumnOrder);
|
|
if (column2.type === "selection") {
|
|
states.selectable.value = column2.selectable;
|
|
states.reserveSelection.value = column2.reserveSelection;
|
|
}
|
|
if (instance.$ready) {
|
|
instance.store.updateColumns();
|
|
instance.store.scheduleLayout();
|
|
}
|
|
},
|
|
updateColumnOrder(states, column2) {
|
|
var _a2;
|
|
const newColumnIndex = (_a2 = column2.getColumnIndex) == null ? void 0 : _a2.call(column2);
|
|
if (newColumnIndex === column2.no)
|
|
return;
|
|
sortColumn(states._columns.value);
|
|
if (instance.$ready) {
|
|
instance.store.updateColumns();
|
|
}
|
|
},
|
|
removeColumn(states, column2, parent2, updateColumnOrder) {
|
|
const array4 = unref(states._columns) || [];
|
|
if (parent2) {
|
|
parent2.children.splice(parent2.children.findIndex((item) => item.id === column2.id), 1);
|
|
nextTick(() => {
|
|
var _a2;
|
|
if (((_a2 = parent2.children) == null ? void 0 : _a2.length) === 0) {
|
|
delete parent2.children;
|
|
}
|
|
});
|
|
states._columns.value = replaceColumn(array4, parent2);
|
|
} else {
|
|
const index = array4.indexOf(column2);
|
|
if (index > -1) {
|
|
array4.splice(index, 1);
|
|
states._columns.value = array4;
|
|
}
|
|
}
|
|
const updateFnIndex = states.updateOrderFns.indexOf(updateColumnOrder);
|
|
updateFnIndex > -1 && states.updateOrderFns.splice(updateFnIndex, 1);
|
|
if (instance.$ready) {
|
|
instance.store.updateColumns();
|
|
instance.store.scheduleLayout();
|
|
}
|
|
},
|
|
sort(states, options) {
|
|
const { prop, order, init } = options;
|
|
if (prop) {
|
|
const column2 = unref(states.columns).find((column22) => column22.property === prop);
|
|
if (column2) {
|
|
column2.order = order;
|
|
instance.store.updateSort(column2, prop, order);
|
|
instance.store.commit("changeSortCondition", { init });
|
|
}
|
|
}
|
|
},
|
|
changeSortCondition(states, options) {
|
|
const { sortingColumn, sortProp, sortOrder } = states;
|
|
const columnValue = unref(sortingColumn), propValue = unref(sortProp), orderValue = unref(sortOrder);
|
|
if (isNull_default(orderValue)) {
|
|
states.sortingColumn.value = null;
|
|
states.sortProp.value = null;
|
|
}
|
|
const ignore = { filter: true };
|
|
instance.store.execQuery(ignore);
|
|
if (!options || !(options.silent || options.init)) {
|
|
instance.emit("sort-change", {
|
|
column: columnValue,
|
|
prop: propValue,
|
|
order: orderValue
|
|
});
|
|
}
|
|
instance.store.updateTableScrollY();
|
|
},
|
|
filterChange(_states, options) {
|
|
const { column: column2, values: values2, silent } = options;
|
|
const newFilters = instance.store.updateFilters(column2, values2);
|
|
instance.store.execQuery();
|
|
if (!silent) {
|
|
instance.emit("filter-change", newFilters);
|
|
}
|
|
instance.store.updateTableScrollY();
|
|
},
|
|
toggleAllSelection() {
|
|
instance.store.toggleAllSelection();
|
|
},
|
|
rowSelectedChanged(_states, row) {
|
|
instance.store.toggleRowSelection(row);
|
|
instance.store.updateAllSelected();
|
|
},
|
|
setHoverRow(states, row) {
|
|
states.hoverRow.value = row;
|
|
},
|
|
setCurrentRow(_states, row) {
|
|
instance.store.updateCurrentRow(row);
|
|
}
|
|
};
|
|
const commit = function(name, ...args) {
|
|
const mutations2 = instance.store.mutations;
|
|
if (mutations2[name]) {
|
|
mutations2[name].apply(instance, [instance.store.states].concat(args));
|
|
} else {
|
|
throw new Error(`Action not found: ${name}`);
|
|
}
|
|
};
|
|
const updateTableScrollY = function() {
|
|
nextTick(() => instance.layout.updateScrollY.apply(instance.layout));
|
|
};
|
|
return {
|
|
ns,
|
|
...watcher,
|
|
mutations,
|
|
commit,
|
|
updateTableScrollY
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/store/helper.mjs
|
|
var InitialStateMap = {
|
|
rowKey: "rowKey",
|
|
defaultExpandAll: "defaultExpandAll",
|
|
selectOnIndeterminate: "selectOnIndeterminate",
|
|
indent: "indent",
|
|
lazy: "lazy",
|
|
data: "data",
|
|
["treeProps.hasChildren"]: {
|
|
key: "lazyColumnIdentifier",
|
|
default: "hasChildren"
|
|
},
|
|
["treeProps.children"]: {
|
|
key: "childrenColumnName",
|
|
default: "children"
|
|
},
|
|
["treeProps.checkStrictly"]: {
|
|
key: "checkStrictly",
|
|
default: false
|
|
}
|
|
};
|
|
function createStore(table, props2) {
|
|
if (!table) {
|
|
throw new Error("Table is required.");
|
|
}
|
|
const store = useStore();
|
|
store.toggleAllSelection = debounce_default(store._toggleAllSelection, 10);
|
|
Object.keys(InitialStateMap).forEach((key) => {
|
|
handleValue(getArrKeysValue(props2, key), key, store);
|
|
});
|
|
proxyTableProps(store, props2);
|
|
return store;
|
|
}
|
|
function proxyTableProps(store, props2) {
|
|
Object.keys(InitialStateMap).forEach((key) => {
|
|
watch(() => getArrKeysValue(props2, key), (value) => {
|
|
handleValue(value, key, store);
|
|
});
|
|
});
|
|
}
|
|
function handleValue(value, propsKey, store) {
|
|
let newVal = value;
|
|
let storeKey = InitialStateMap[propsKey];
|
|
if (isObject(InitialStateMap[propsKey])) {
|
|
storeKey = storeKey.key;
|
|
newVal = newVal || InitialStateMap[propsKey].default;
|
|
}
|
|
store.states[storeKey].value = newVal;
|
|
}
|
|
function getArrKeysValue(props2, keys3) {
|
|
if (keys3.includes(".")) {
|
|
const keyList = keys3.split(".");
|
|
let value = props2;
|
|
keyList.forEach((key) => {
|
|
value = value[key];
|
|
});
|
|
return value;
|
|
} else {
|
|
return props2[keys3];
|
|
}
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-layout.mjs
|
|
var TableLayout = class {
|
|
constructor(options) {
|
|
this.observers = [];
|
|
this.table = null;
|
|
this.store = null;
|
|
this.columns = [];
|
|
this.fit = true;
|
|
this.showHeader = true;
|
|
this.height = ref(null);
|
|
this.scrollX = ref(false);
|
|
this.scrollY = ref(false);
|
|
this.bodyWidth = ref(null);
|
|
this.fixedWidth = ref(null);
|
|
this.rightFixedWidth = ref(null);
|
|
this.gutterWidth = 0;
|
|
for (const name in options) {
|
|
if (hasOwn(options, name)) {
|
|
if (isRef(this[name])) {
|
|
this[name].value = options[name];
|
|
} else {
|
|
this[name] = options[name];
|
|
}
|
|
}
|
|
}
|
|
if (!this.table) {
|
|
throw new Error("Table is required for Table Layout");
|
|
}
|
|
if (!this.store) {
|
|
throw new Error("Store is required for Table Layout");
|
|
}
|
|
}
|
|
updateScrollY() {
|
|
const height = this.height.value;
|
|
if (isNull_default(height))
|
|
return false;
|
|
const scrollBarRef = this.table.refs.scrollBarRef;
|
|
if (this.table.vnode.el && (scrollBarRef == null ? void 0 : scrollBarRef.wrapRef)) {
|
|
let scrollY = true;
|
|
const prevScrollY = this.scrollY.value;
|
|
scrollY = scrollBarRef.wrapRef.scrollHeight > scrollBarRef.wrapRef.clientHeight;
|
|
this.scrollY.value = scrollY;
|
|
return prevScrollY !== scrollY;
|
|
}
|
|
return false;
|
|
}
|
|
setHeight(value, prop = "height") {
|
|
if (!isClient)
|
|
return;
|
|
const el = this.table.vnode.el;
|
|
value = parseHeight(value);
|
|
this.height.value = Number(value);
|
|
if (!el && (value || value === 0))
|
|
return nextTick(() => this.setHeight(value, prop));
|
|
if (isNumber2(value)) {
|
|
el.style[prop] = `${value}px`;
|
|
this.updateElsHeight();
|
|
} else if (isString(value)) {
|
|
el.style[prop] = value;
|
|
this.updateElsHeight();
|
|
}
|
|
}
|
|
setMaxHeight(value) {
|
|
this.setHeight(value, "max-height");
|
|
}
|
|
getFlattenColumns() {
|
|
const flattenColumns = [];
|
|
const columns2 = this.table.store.states.columns.value;
|
|
columns2.forEach((column2) => {
|
|
if (column2.isColumnGroup) {
|
|
flattenColumns.push.apply(flattenColumns, column2.columns);
|
|
} else {
|
|
flattenColumns.push(column2);
|
|
}
|
|
});
|
|
return flattenColumns;
|
|
}
|
|
updateElsHeight() {
|
|
this.updateScrollY();
|
|
this.notifyObservers("scrollable");
|
|
}
|
|
headerDisplayNone(elm) {
|
|
if (!elm)
|
|
return true;
|
|
let headerChild = elm;
|
|
while (headerChild.tagName !== "DIV") {
|
|
if (getComputedStyle(headerChild).display === "none") {
|
|
return true;
|
|
}
|
|
headerChild = headerChild.parentElement;
|
|
}
|
|
return false;
|
|
}
|
|
updateColumnsWidth() {
|
|
if (!isClient)
|
|
return;
|
|
const fit = this.fit;
|
|
const bodyWidth = this.table.vnode.el.clientWidth;
|
|
let bodyMinWidth = 0;
|
|
const flattenColumns = this.getFlattenColumns();
|
|
const flexColumns = flattenColumns.filter((column2) => !isNumber2(column2.width));
|
|
flattenColumns.forEach((column2) => {
|
|
if (isNumber2(column2.width) && column2.realWidth)
|
|
column2.realWidth = null;
|
|
});
|
|
if (flexColumns.length > 0 && fit) {
|
|
flattenColumns.forEach((column2) => {
|
|
bodyMinWidth += Number(column2.width || column2.minWidth || 80);
|
|
});
|
|
if (bodyMinWidth <= bodyWidth) {
|
|
this.scrollX.value = false;
|
|
const totalFlexWidth = bodyWidth - bodyMinWidth;
|
|
if (flexColumns.length === 1) {
|
|
flexColumns[0].realWidth = Number(flexColumns[0].minWidth || 80) + totalFlexWidth;
|
|
} else {
|
|
const allColumnsWidth = flexColumns.reduce((prev, column2) => prev + Number(column2.minWidth || 80), 0);
|
|
const flexWidthPerPixel = totalFlexWidth / allColumnsWidth;
|
|
let noneFirstWidth = 0;
|
|
flexColumns.forEach((column2, index) => {
|
|
if (index === 0)
|
|
return;
|
|
const flexWidth = Math.floor(Number(column2.minWidth || 80) * flexWidthPerPixel);
|
|
noneFirstWidth += flexWidth;
|
|
column2.realWidth = Number(column2.minWidth || 80) + flexWidth;
|
|
});
|
|
flexColumns[0].realWidth = Number(flexColumns[0].minWidth || 80) + totalFlexWidth - noneFirstWidth;
|
|
}
|
|
} else {
|
|
this.scrollX.value = true;
|
|
flexColumns.forEach((column2) => {
|
|
column2.realWidth = Number(column2.minWidth);
|
|
});
|
|
}
|
|
this.bodyWidth.value = Math.max(bodyMinWidth, bodyWidth);
|
|
this.table.state.resizeState.value.width = this.bodyWidth.value;
|
|
} else {
|
|
flattenColumns.forEach((column2) => {
|
|
if (!column2.width && !column2.minWidth) {
|
|
column2.realWidth = 80;
|
|
} else {
|
|
column2.realWidth = Number(column2.width || column2.minWidth);
|
|
}
|
|
bodyMinWidth += column2.realWidth;
|
|
});
|
|
this.scrollX.value = bodyMinWidth > bodyWidth;
|
|
this.bodyWidth.value = bodyMinWidth;
|
|
}
|
|
const fixedColumns = this.store.states.fixedColumns.value;
|
|
if (fixedColumns.length > 0) {
|
|
let fixedWidth = 0;
|
|
fixedColumns.forEach((column2) => {
|
|
fixedWidth += Number(column2.realWidth || column2.width);
|
|
});
|
|
this.fixedWidth.value = fixedWidth;
|
|
}
|
|
const rightFixedColumns = this.store.states.rightFixedColumns.value;
|
|
if (rightFixedColumns.length > 0) {
|
|
let rightFixedWidth = 0;
|
|
rightFixedColumns.forEach((column2) => {
|
|
rightFixedWidth += Number(column2.realWidth || column2.width);
|
|
});
|
|
this.rightFixedWidth.value = rightFixedWidth;
|
|
}
|
|
this.notifyObservers("columns");
|
|
}
|
|
addObserver(observer) {
|
|
this.observers.push(observer);
|
|
}
|
|
removeObserver(observer) {
|
|
const index = this.observers.indexOf(observer);
|
|
if (index !== -1) {
|
|
this.observers.splice(index, 1);
|
|
}
|
|
}
|
|
notifyObservers(event) {
|
|
const observers = this.observers;
|
|
observers.forEach((observer) => {
|
|
var _a2, _b;
|
|
switch (event) {
|
|
case "columns":
|
|
(_a2 = observer.state) == null ? void 0 : _a2.onColumnsChange(this);
|
|
break;
|
|
case "scrollable":
|
|
(_b = observer.state) == null ? void 0 : _b.onScrollableChange(this);
|
|
break;
|
|
default:
|
|
throw new Error(`Table Layout don't have event ${event}.`);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table/src/filter-panel.mjs
|
|
var { CheckboxGroup: ElCheckboxGroup2 } = ElCheckbox;
|
|
var _sfc_main124 = defineComponent({
|
|
name: "ElTableFilterPanel",
|
|
components: {
|
|
ElCheckbox,
|
|
ElCheckboxGroup: ElCheckboxGroup2,
|
|
ElScrollbar,
|
|
ElTooltip,
|
|
ElIcon,
|
|
ArrowDown: arrow_down_default,
|
|
ArrowUp: arrow_up_default
|
|
},
|
|
directives: { ClickOutside },
|
|
props: {
|
|
placement: {
|
|
type: String,
|
|
default: "bottom-start"
|
|
},
|
|
store: {
|
|
type: Object
|
|
},
|
|
column: {
|
|
type: Object
|
|
},
|
|
upDataColumn: {
|
|
type: Function
|
|
},
|
|
appendTo: useTooltipContentProps.appendTo
|
|
},
|
|
setup(props2) {
|
|
const instance = getCurrentInstance();
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("table-filter");
|
|
const parent2 = instance == null ? void 0 : instance.parent;
|
|
if (!parent2.filterPanels.value[props2.column.id]) {
|
|
parent2.filterPanels.value[props2.column.id] = instance;
|
|
}
|
|
const tooltipVisible = ref(false);
|
|
const tooltip = ref(null);
|
|
const filters = computed(() => {
|
|
return props2.column && props2.column.filters;
|
|
});
|
|
const filterClassName = computed(() => {
|
|
if (props2.column.filterClassName) {
|
|
return `${ns.b()} ${props2.column.filterClassName}`;
|
|
}
|
|
return ns.b();
|
|
});
|
|
const filterValue = computed({
|
|
get: () => {
|
|
var _a2;
|
|
return (((_a2 = props2.column) == null ? void 0 : _a2.filteredValue) || [])[0];
|
|
},
|
|
set: (value) => {
|
|
if (filteredValue.value) {
|
|
if (!isPropAbsent(value)) {
|
|
filteredValue.value.splice(0, 1, value);
|
|
} else {
|
|
filteredValue.value.splice(0, 1);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
const filteredValue = computed({
|
|
get() {
|
|
if (props2.column) {
|
|
return props2.column.filteredValue || [];
|
|
}
|
|
return [];
|
|
},
|
|
set(value) {
|
|
if (props2.column) {
|
|
props2.upDataColumn("filteredValue", value);
|
|
}
|
|
}
|
|
});
|
|
const multiple = computed(() => {
|
|
if (props2.column) {
|
|
return props2.column.filterMultiple;
|
|
}
|
|
return true;
|
|
});
|
|
const isActive = (filter2) => {
|
|
return filter2.value === filterValue.value;
|
|
};
|
|
const hidden = () => {
|
|
tooltipVisible.value = false;
|
|
};
|
|
const showFilterPanel = (e) => {
|
|
e.stopPropagation();
|
|
tooltipVisible.value = !tooltipVisible.value;
|
|
};
|
|
const hideFilterPanel = () => {
|
|
tooltipVisible.value = false;
|
|
};
|
|
const handleConfirm = () => {
|
|
confirmFilter(filteredValue.value);
|
|
hidden();
|
|
};
|
|
const handleReset = () => {
|
|
filteredValue.value = [];
|
|
confirmFilter(filteredValue.value);
|
|
hidden();
|
|
};
|
|
const handleSelect = (_filterValue) => {
|
|
filterValue.value = _filterValue;
|
|
if (!isPropAbsent(_filterValue)) {
|
|
confirmFilter(filteredValue.value);
|
|
} else {
|
|
confirmFilter([]);
|
|
}
|
|
hidden();
|
|
};
|
|
const confirmFilter = (filteredValue2) => {
|
|
props2.store.commit("filterChange", {
|
|
column: props2.column,
|
|
values: filteredValue2
|
|
});
|
|
props2.store.updateAllSelected();
|
|
};
|
|
watch(tooltipVisible, (value) => {
|
|
if (props2.column) {
|
|
props2.upDataColumn("filterOpened", value);
|
|
}
|
|
}, {
|
|
immediate: true
|
|
});
|
|
const popperPaneRef = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = tooltip.value) == null ? void 0 : _a2.popperRef) == null ? void 0 : _b.contentRef;
|
|
});
|
|
return {
|
|
tooltipVisible,
|
|
multiple,
|
|
filterClassName,
|
|
filteredValue,
|
|
filterValue,
|
|
filters,
|
|
handleConfirm,
|
|
handleReset,
|
|
handleSelect,
|
|
isPropAbsent,
|
|
isActive,
|
|
t,
|
|
ns,
|
|
showFilterPanel,
|
|
hideFilterPanel,
|
|
popperPaneRef,
|
|
tooltip
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render24(_ctx, _cache, $props, $setup, $data, $options) {
|
|
const _component_el_checkbox = resolveComponent("el-checkbox");
|
|
const _component_el_checkbox_group = resolveComponent("el-checkbox-group");
|
|
const _component_el_scrollbar = resolveComponent("el-scrollbar");
|
|
const _component_arrow_up = resolveComponent("arrow-up");
|
|
const _component_arrow_down = resolveComponent("arrow-down");
|
|
const _component_el_icon = resolveComponent("el-icon");
|
|
const _component_el_tooltip = resolveComponent("el-tooltip");
|
|
const _directive_click_outside = resolveDirective("click-outside");
|
|
return openBlock(), createBlock(_component_el_tooltip, {
|
|
ref: "tooltip",
|
|
visible: _ctx.tooltipVisible,
|
|
offset: 0,
|
|
placement: _ctx.placement,
|
|
"show-arrow": false,
|
|
"stop-popper-mouse-event": false,
|
|
teleported: "",
|
|
effect: "light",
|
|
pure: "",
|
|
"popper-class": _ctx.filterClassName,
|
|
persistent: "",
|
|
"append-to": _ctx.appendTo
|
|
}, {
|
|
content: withCtx(() => [
|
|
_ctx.multiple ? (openBlock(), createElementBlock("div", { key: 0 }, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.ns.e("content"))
|
|
}, [
|
|
createVNode(_component_el_scrollbar, {
|
|
"wrap-class": _ctx.ns.e("wrap")
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(_component_el_checkbox_group, {
|
|
modelValue: _ctx.filteredValue,
|
|
"onUpdate:modelValue": ($event) => _ctx.filteredValue = $event,
|
|
class: normalizeClass(_ctx.ns.e("checkbox-group"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.filters, (filter2) => {
|
|
return openBlock(), createBlock(_component_el_checkbox, {
|
|
key: filter2.value,
|
|
value: filter2.value
|
|
}, {
|
|
default: withCtx(() => [
|
|
createTextVNode(toDisplayString(filter2.text), 1)
|
|
]),
|
|
_: 2
|
|
}, 1032, ["value"]);
|
|
}), 128))
|
|
]),
|
|
_: 1
|
|
}, 8, ["modelValue", "onUpdate:modelValue", "class"])
|
|
]),
|
|
_: 1
|
|
}, 8, ["wrap-class"])
|
|
], 2),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.ns.e("bottom"))
|
|
}, [
|
|
createBaseVNode("button", {
|
|
class: normalizeClass({ [_ctx.ns.is("disabled")]: _ctx.filteredValue.length === 0 }),
|
|
disabled: _ctx.filteredValue.length === 0,
|
|
type: "button",
|
|
onClick: _ctx.handleConfirm
|
|
}, toDisplayString(_ctx.t("el.table.confirmFilter")), 11, ["disabled", "onClick"]),
|
|
createBaseVNode("button", {
|
|
type: "button",
|
|
onClick: _ctx.handleReset
|
|
}, toDisplayString(_ctx.t("el.table.resetFilter")), 9, ["onClick"])
|
|
], 2)
|
|
])) : (openBlock(), createElementBlock("ul", {
|
|
key: 1,
|
|
class: normalizeClass(_ctx.ns.e("list"))
|
|
}, [
|
|
createBaseVNode("li", {
|
|
class: normalizeClass([
|
|
_ctx.ns.e("list-item"),
|
|
{
|
|
[_ctx.ns.is("active")]: _ctx.isPropAbsent(_ctx.filterValue)
|
|
}
|
|
]),
|
|
onClick: ($event) => _ctx.handleSelect(null)
|
|
}, toDisplayString(_ctx.t("el.table.clearFilter")), 11, ["onClick"]),
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.filters, (filter2) => {
|
|
return openBlock(), createElementBlock("li", {
|
|
key: filter2.value,
|
|
class: normalizeClass([_ctx.ns.e("list-item"), _ctx.ns.is("active", _ctx.isActive(filter2))]),
|
|
label: filter2.value,
|
|
onClick: ($event) => _ctx.handleSelect(filter2.value)
|
|
}, toDisplayString(filter2.text), 11, ["label", "onClick"]);
|
|
}), 128))
|
|
], 2))
|
|
]),
|
|
default: withCtx(() => [
|
|
withDirectives((openBlock(), createElementBlock("span", {
|
|
class: normalizeClass([
|
|
`${_ctx.ns.namespace.value}-table__column-filter-trigger`,
|
|
`${_ctx.ns.namespace.value}-none-outline`
|
|
]),
|
|
onClick: _ctx.showFilterPanel
|
|
}, [
|
|
createVNode(_component_el_icon, null, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "filter-icon", {}, () => [
|
|
_ctx.column.filterOpened ? (openBlock(), createBlock(_component_arrow_up, { key: 0 })) : (openBlock(), createBlock(_component_arrow_down, { key: 1 }))
|
|
])
|
|
]),
|
|
_: 3
|
|
})
|
|
], 10, ["onClick"])), [
|
|
[_directive_click_outside, _ctx.hideFilterPanel, _ctx.popperPaneRef]
|
|
])
|
|
]),
|
|
_: 3
|
|
}, 8, ["visible", "placement", "popper-class", "append-to"]);
|
|
}
|
|
var FilterPanel = _export_sfc(_sfc_main124, [["render", _sfc_render24], ["__file", "filter-panel.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/table/src/layout-observer.mjs
|
|
function useLayoutObserver(root2) {
|
|
const instance = getCurrentInstance();
|
|
onBeforeMount(() => {
|
|
tableLayout.value.addObserver(instance);
|
|
});
|
|
onMounted(() => {
|
|
onColumnsChange(tableLayout.value);
|
|
onScrollableChange(tableLayout.value);
|
|
});
|
|
onUpdated(() => {
|
|
onColumnsChange(tableLayout.value);
|
|
onScrollableChange(tableLayout.value);
|
|
});
|
|
onUnmounted(() => {
|
|
tableLayout.value.removeObserver(instance);
|
|
});
|
|
const tableLayout = computed(() => {
|
|
const layout2 = root2.layout;
|
|
if (!layout2) {
|
|
throw new Error("Can not find table layout.");
|
|
}
|
|
return layout2;
|
|
});
|
|
const onColumnsChange = (layout2) => {
|
|
var _a2;
|
|
const cols = ((_a2 = root2.vnode.el) == null ? void 0 : _a2.querySelectorAll("colgroup > col")) || [];
|
|
if (!cols.length)
|
|
return;
|
|
const flattenColumns = layout2.getFlattenColumns();
|
|
const columnsMap = {};
|
|
flattenColumns.forEach((column2) => {
|
|
columnsMap[column2.id] = column2;
|
|
});
|
|
for (let i = 0, j = cols.length; i < j; i++) {
|
|
const col = cols[i];
|
|
const name = col.getAttribute("name");
|
|
const column2 = columnsMap[name];
|
|
if (column2) {
|
|
col.setAttribute("width", column2.realWidth || column2.width);
|
|
}
|
|
}
|
|
};
|
|
const onScrollableChange = (layout2) => {
|
|
var _a2, _b;
|
|
const cols = ((_a2 = root2.vnode.el) == null ? void 0 : _a2.querySelectorAll("colgroup > col[name=gutter]")) || [];
|
|
for (let i = 0, j = cols.length; i < j; i++) {
|
|
const col = cols[i];
|
|
col.setAttribute("width", layout2.scrollY.value ? layout2.gutterWidth : "0");
|
|
}
|
|
const ths = ((_b = root2.vnode.el) == null ? void 0 : _b.querySelectorAll("th.gutter")) || [];
|
|
for (let i = 0, j = ths.length; i < j; i++) {
|
|
const th = ths[i];
|
|
th.style.width = layout2.scrollY.value ? `${layout2.gutterWidth}px` : "0";
|
|
th.style.display = layout2.scrollY.value ? "" : "none";
|
|
}
|
|
};
|
|
return {
|
|
tableLayout: tableLayout.value,
|
|
onColumnsChange,
|
|
onScrollableChange
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/tokens.mjs
|
|
var TABLE_INJECTION_KEY = Symbol("ElTable");
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-header/event-helper.mjs
|
|
function useEvent(props2, emit) {
|
|
const instance = getCurrentInstance();
|
|
const parent2 = inject(TABLE_INJECTION_KEY);
|
|
const handleFilterClick = (event) => {
|
|
event.stopPropagation();
|
|
return;
|
|
};
|
|
const handleHeaderClick = (event, column2) => {
|
|
if (!column2.filters && column2.sortable) {
|
|
handleSortClick(event, column2, false);
|
|
} else if (column2.filterable && !column2.sortable) {
|
|
handleFilterClick(event);
|
|
}
|
|
parent2 == null ? void 0 : parent2.emit("header-click", column2, event);
|
|
};
|
|
const handleHeaderContextMenu = (event, column2) => {
|
|
parent2 == null ? void 0 : parent2.emit("header-contextmenu", column2, event);
|
|
};
|
|
const draggingColumn = ref(null);
|
|
const dragging = ref(false);
|
|
const dragState = ref({});
|
|
const handleMouseDown = (event, column2) => {
|
|
if (!isClient)
|
|
return;
|
|
if (column2.children && column2.children.length > 0)
|
|
return;
|
|
if (draggingColumn.value && props2.border) {
|
|
dragging.value = true;
|
|
const table = parent2;
|
|
emit("set-drag-visible", true);
|
|
const tableEl = table == null ? void 0 : table.vnode.el;
|
|
const tableLeft = tableEl.getBoundingClientRect().left;
|
|
const columnEl = instance.vnode.el.querySelector(`th.${column2.id}`);
|
|
const columnRect = columnEl.getBoundingClientRect();
|
|
const minLeft = columnRect.left - tableLeft + 30;
|
|
addClass(columnEl, "noclick");
|
|
dragState.value = {
|
|
startMouseLeft: event.clientX,
|
|
startLeft: columnRect.right - tableLeft,
|
|
startColumnLeft: columnRect.left - tableLeft,
|
|
tableLeft
|
|
};
|
|
const resizeProxy = table == null ? void 0 : table.refs.resizeProxy;
|
|
resizeProxy.style.left = `${dragState.value.startLeft}px`;
|
|
document.onselectstart = function() {
|
|
return false;
|
|
};
|
|
document.ondragstart = function() {
|
|
return false;
|
|
};
|
|
const handleMouseMove2 = (event2) => {
|
|
const deltaLeft = event2.clientX - dragState.value.startMouseLeft;
|
|
const proxyLeft = dragState.value.startLeft + deltaLeft;
|
|
resizeProxy.style.left = `${Math.max(minLeft, proxyLeft)}px`;
|
|
};
|
|
const handleMouseUp = () => {
|
|
if (dragging.value) {
|
|
const { startColumnLeft, startLeft } = dragState.value;
|
|
const finalLeft = Number.parseInt(resizeProxy.style.left, 10);
|
|
const columnWidth = finalLeft - startColumnLeft;
|
|
column2.width = column2.realWidth = columnWidth;
|
|
table == null ? void 0 : table.emit("header-dragend", column2.width, startLeft - startColumnLeft, column2, event);
|
|
requestAnimationFrame(() => {
|
|
props2.store.scheduleLayout(false, true);
|
|
});
|
|
document.body.style.cursor = "";
|
|
dragging.value = false;
|
|
draggingColumn.value = null;
|
|
dragState.value = {};
|
|
emit("set-drag-visible", false);
|
|
}
|
|
document.removeEventListener("mousemove", handleMouseMove2);
|
|
document.removeEventListener("mouseup", handleMouseUp);
|
|
document.onselectstart = null;
|
|
document.ondragstart = null;
|
|
setTimeout(() => {
|
|
removeClass(columnEl, "noclick");
|
|
}, 0);
|
|
};
|
|
document.addEventListener("mousemove", handleMouseMove2);
|
|
document.addEventListener("mouseup", handleMouseUp);
|
|
}
|
|
};
|
|
const handleMouseMove = (event, column2) => {
|
|
var _a2;
|
|
if (column2.children && column2.children.length > 0)
|
|
return;
|
|
const el = event.target;
|
|
if (!isElement2(el)) {
|
|
return;
|
|
}
|
|
const target2 = el == null ? void 0 : el.closest("th");
|
|
if (!column2 || !column2.resizable || !target2)
|
|
return;
|
|
if (!dragging.value && props2.border) {
|
|
const rect = target2.getBoundingClientRect();
|
|
const bodyStyle = document.body.style;
|
|
const isLastTh = ((_a2 = target2.parentNode) == null ? void 0 : _a2.lastElementChild) === target2;
|
|
const allowDarg = props2.allowDragLastColumn || !isLastTh;
|
|
if (rect.width > 12 && rect.right - event.clientX < 8 && allowDarg) {
|
|
bodyStyle.cursor = "col-resize";
|
|
if (hasClass(target2, "is-sortable")) {
|
|
target2.style.cursor = "col-resize";
|
|
}
|
|
draggingColumn.value = column2;
|
|
} else if (!dragging.value) {
|
|
bodyStyle.cursor = "";
|
|
if (hasClass(target2, "is-sortable")) {
|
|
target2.style.cursor = "pointer";
|
|
}
|
|
draggingColumn.value = null;
|
|
}
|
|
}
|
|
};
|
|
const handleMouseOut = () => {
|
|
if (!isClient)
|
|
return;
|
|
document.body.style.cursor = "";
|
|
};
|
|
const toggleOrder = ({ order, sortOrders }) => {
|
|
if (order === "")
|
|
return sortOrders[0];
|
|
const index = sortOrders.indexOf(order || null);
|
|
return sortOrders[index > sortOrders.length - 2 ? 0 : index + 1];
|
|
};
|
|
const handleSortClick = (event, column2, givenOrder) => {
|
|
var _a2;
|
|
event.stopPropagation();
|
|
const order = column2.order === givenOrder ? null : givenOrder || toggleOrder(column2);
|
|
const target2 = (_a2 = event.target) == null ? void 0 : _a2.closest("th");
|
|
if (target2) {
|
|
if (hasClass(target2, "noclick")) {
|
|
removeClass(target2, "noclick");
|
|
return;
|
|
}
|
|
}
|
|
if (!column2.sortable)
|
|
return;
|
|
const clickTarget = event.currentTarget;
|
|
if (["ascending", "descending"].some((str) => hasClass(clickTarget, str) && !column2.sortOrders.includes(str))) {
|
|
return;
|
|
}
|
|
const states = props2.store.states;
|
|
let sortProp = states.sortProp.value;
|
|
let sortOrder;
|
|
const sortingColumn = states.sortingColumn.value;
|
|
if (sortingColumn !== column2 || sortingColumn === column2 && isNull_default(sortingColumn.order)) {
|
|
if (sortingColumn) {
|
|
sortingColumn.order = null;
|
|
}
|
|
states.sortingColumn.value = column2;
|
|
sortProp = column2.property;
|
|
}
|
|
if (!order) {
|
|
sortOrder = column2.order = null;
|
|
} else {
|
|
sortOrder = column2.order = order;
|
|
}
|
|
states.sortProp.value = sortProp;
|
|
states.sortOrder.value = sortOrder;
|
|
parent2 == null ? void 0 : parent2.store.commit("changeSortCondition");
|
|
};
|
|
return {
|
|
handleHeaderClick,
|
|
handleHeaderContextMenu,
|
|
handleMouseDown,
|
|
handleMouseMove,
|
|
handleMouseOut,
|
|
handleSortClick,
|
|
handleFilterClick
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-header/style.helper.mjs
|
|
function useStyle(props2) {
|
|
const parent2 = inject(TABLE_INJECTION_KEY);
|
|
const ns = useNamespace("table");
|
|
const getHeaderRowStyle = (rowIndex) => {
|
|
const headerRowStyle = parent2 == null ? void 0 : parent2.props.headerRowStyle;
|
|
if (isFunction(headerRowStyle)) {
|
|
return headerRowStyle.call(null, { rowIndex });
|
|
}
|
|
return headerRowStyle;
|
|
};
|
|
const getHeaderRowClass = (rowIndex) => {
|
|
const classes = [];
|
|
const headerRowClassName = parent2 == null ? void 0 : parent2.props.headerRowClassName;
|
|
if (isString(headerRowClassName)) {
|
|
classes.push(headerRowClassName);
|
|
} else if (isFunction(headerRowClassName)) {
|
|
classes.push(headerRowClassName.call(null, { rowIndex }));
|
|
}
|
|
return classes.join(" ");
|
|
};
|
|
const getHeaderCellStyle = (rowIndex, columnIndex, row, column2) => {
|
|
var _a2;
|
|
let headerCellStyles = (_a2 = parent2 == null ? void 0 : parent2.props.headerCellStyle) != null ? _a2 : {};
|
|
if (isFunction(headerCellStyles)) {
|
|
headerCellStyles = headerCellStyles.call(null, {
|
|
rowIndex,
|
|
columnIndex,
|
|
row,
|
|
column: column2
|
|
});
|
|
}
|
|
const fixedStyle = getFixedColumnOffset(columnIndex, column2.fixed, props2.store, row);
|
|
ensurePosition(fixedStyle, "left");
|
|
ensurePosition(fixedStyle, "right");
|
|
return Object.assign({}, headerCellStyles, fixedStyle);
|
|
};
|
|
const getHeaderCellClass = (rowIndex, columnIndex, row, column2) => {
|
|
const fixedClasses = getFixedColumnsClass(ns.b(), columnIndex, column2.fixed, props2.store, row);
|
|
const classes = [
|
|
column2.id,
|
|
column2.order,
|
|
column2.headerAlign,
|
|
column2.className,
|
|
column2.labelClassName,
|
|
...fixedClasses
|
|
];
|
|
if (!column2.children) {
|
|
classes.push("is-leaf");
|
|
}
|
|
if (column2.sortable) {
|
|
classes.push("is-sortable");
|
|
}
|
|
const headerCellClassName = parent2 == null ? void 0 : parent2.props.headerCellClassName;
|
|
if (isString(headerCellClassName)) {
|
|
classes.push(headerCellClassName);
|
|
} else if (isFunction(headerCellClassName)) {
|
|
classes.push(headerCellClassName.call(null, {
|
|
rowIndex,
|
|
columnIndex,
|
|
row,
|
|
column: column2
|
|
}));
|
|
}
|
|
classes.push(ns.e("cell"));
|
|
return classes.filter((className) => Boolean(className)).join(" ");
|
|
};
|
|
return {
|
|
getHeaderRowStyle,
|
|
getHeaderRowClass,
|
|
getHeaderCellStyle,
|
|
getHeaderCellClass
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-header/utils-helper.mjs
|
|
var getAllColumns = (columns2) => {
|
|
const result2 = [];
|
|
columns2.forEach((column2) => {
|
|
if (column2.children) {
|
|
result2.push(column2);
|
|
result2.push.apply(result2, getAllColumns(column2.children));
|
|
} else {
|
|
result2.push(column2);
|
|
}
|
|
});
|
|
return result2;
|
|
};
|
|
var convertToRows = (originColumns) => {
|
|
let maxLevel = 1;
|
|
const traverse = (column2, parent2) => {
|
|
if (parent2) {
|
|
column2.level = parent2.level + 1;
|
|
if (maxLevel < column2.level) {
|
|
maxLevel = column2.level;
|
|
}
|
|
}
|
|
if (column2.children) {
|
|
let colSpan = 0;
|
|
column2.children.forEach((subColumn) => {
|
|
traverse(subColumn, column2);
|
|
colSpan += subColumn.colSpan;
|
|
});
|
|
column2.colSpan = colSpan;
|
|
} else {
|
|
column2.colSpan = 1;
|
|
}
|
|
};
|
|
originColumns.forEach((column2) => {
|
|
column2.level = 1;
|
|
traverse(column2, void 0);
|
|
});
|
|
const rows = [];
|
|
for (let i = 0; i < maxLevel; i++) {
|
|
rows.push([]);
|
|
}
|
|
const allColumns = getAllColumns(originColumns);
|
|
allColumns.forEach((column2) => {
|
|
if (!column2.children) {
|
|
column2.rowSpan = maxLevel - column2.level + 1;
|
|
} else {
|
|
column2.rowSpan = 1;
|
|
column2.children.forEach((col) => col.isSubColumn = true);
|
|
}
|
|
rows[column2.level - 1].push(column2);
|
|
});
|
|
return rows;
|
|
};
|
|
function useUtils(props2) {
|
|
const parent2 = inject(TABLE_INJECTION_KEY);
|
|
const columnRows = computed(() => {
|
|
return convertToRows(props2.store.states.originColumns.value);
|
|
});
|
|
const isGroup = computed(() => {
|
|
const result2 = columnRows.value.length > 1;
|
|
if (result2 && parent2) {
|
|
parent2.state.isGroup.value = true;
|
|
}
|
|
return result2;
|
|
});
|
|
const toggleAllSelection = (event) => {
|
|
event.stopPropagation();
|
|
parent2 == null ? void 0 : parent2.store.commit("toggleAllSelection");
|
|
};
|
|
return {
|
|
isGroup,
|
|
toggleAllSelection,
|
|
columnRows
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-header/index.mjs
|
|
var TableHeader = defineComponent({
|
|
name: "ElTableHeader",
|
|
components: {
|
|
ElCheckbox
|
|
},
|
|
props: {
|
|
fixed: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
store: {
|
|
required: true,
|
|
type: Object
|
|
},
|
|
border: Boolean,
|
|
defaultSort: {
|
|
type: Object,
|
|
default: () => {
|
|
return {
|
|
prop: "",
|
|
order: ""
|
|
};
|
|
}
|
|
},
|
|
appendFilterPanelTo: {
|
|
type: String
|
|
},
|
|
allowDragLastColumn: {
|
|
type: Boolean
|
|
}
|
|
},
|
|
setup(props2, { emit }) {
|
|
const instance = getCurrentInstance();
|
|
const parent2 = inject(TABLE_INJECTION_KEY);
|
|
const ns = useNamespace("table");
|
|
const filterPanels = ref({});
|
|
const { onColumnsChange, onScrollableChange } = useLayoutObserver(parent2);
|
|
const isTableLayoutAuto = (parent2 == null ? void 0 : parent2.props.tableLayout) === "auto";
|
|
const saveIndexSelection = reactive(new Map());
|
|
const theadRef = ref();
|
|
const updateFixedColumnStyle = () => {
|
|
setTimeout(() => {
|
|
if (saveIndexSelection.size > 0) {
|
|
saveIndexSelection.forEach((column2, key) => {
|
|
const el = theadRef.value.querySelector(`.${key.replace(/\s/g, ".")}`);
|
|
if (el) {
|
|
const width = el.getBoundingClientRect().width;
|
|
column2.width = width;
|
|
}
|
|
});
|
|
saveIndexSelection.clear();
|
|
}
|
|
});
|
|
};
|
|
watch(saveIndexSelection, updateFixedColumnStyle);
|
|
onMounted(async () => {
|
|
await nextTick();
|
|
await nextTick();
|
|
const { prop, order } = props2.defaultSort;
|
|
parent2 == null ? void 0 : parent2.store.commit("sort", { prop, order, init: true });
|
|
updateFixedColumnStyle();
|
|
});
|
|
const {
|
|
handleHeaderClick,
|
|
handleHeaderContextMenu,
|
|
handleMouseDown,
|
|
handleMouseMove,
|
|
handleMouseOut,
|
|
handleSortClick,
|
|
handleFilterClick
|
|
} = useEvent(props2, emit);
|
|
const {
|
|
getHeaderRowStyle,
|
|
getHeaderRowClass,
|
|
getHeaderCellStyle,
|
|
getHeaderCellClass
|
|
} = useStyle(props2);
|
|
const { isGroup, toggleAllSelection, columnRows } = useUtils(props2);
|
|
instance.state = {
|
|
onColumnsChange,
|
|
onScrollableChange
|
|
};
|
|
instance.filterPanels = filterPanels;
|
|
return {
|
|
ns,
|
|
filterPanels,
|
|
onColumnsChange,
|
|
onScrollableChange,
|
|
columnRows,
|
|
getHeaderRowClass,
|
|
getHeaderRowStyle,
|
|
getHeaderCellClass,
|
|
getHeaderCellStyle,
|
|
handleHeaderClick,
|
|
handleHeaderContextMenu,
|
|
handleMouseDown,
|
|
handleMouseMove,
|
|
handleMouseOut,
|
|
handleSortClick,
|
|
handleFilterClick,
|
|
isGroup,
|
|
toggleAllSelection,
|
|
saveIndexSelection,
|
|
isTableLayoutAuto,
|
|
theadRef,
|
|
updateFixedColumnStyle
|
|
};
|
|
},
|
|
render() {
|
|
const {
|
|
ns,
|
|
isGroup,
|
|
columnRows,
|
|
getHeaderCellStyle,
|
|
getHeaderCellClass,
|
|
getHeaderRowClass,
|
|
getHeaderRowStyle,
|
|
handleHeaderClick,
|
|
handleHeaderContextMenu,
|
|
handleMouseDown,
|
|
handleMouseMove,
|
|
handleSortClick,
|
|
handleMouseOut,
|
|
store,
|
|
$parent,
|
|
saveIndexSelection,
|
|
isTableLayoutAuto
|
|
} = this;
|
|
let rowSpan = 1;
|
|
return h("thead", {
|
|
ref: "theadRef",
|
|
class: { [ns.is("group")]: isGroup }
|
|
}, columnRows.map((subColumns, rowIndex) => h("tr", {
|
|
class: getHeaderRowClass(rowIndex),
|
|
key: rowIndex,
|
|
style: getHeaderRowStyle(rowIndex)
|
|
}, subColumns.map((column2, cellIndex) => {
|
|
if (column2.rowSpan > rowSpan) {
|
|
rowSpan = column2.rowSpan;
|
|
}
|
|
const _class = getHeaderCellClass(rowIndex, cellIndex, subColumns, column2);
|
|
if (isTableLayoutAuto && column2.fixed) {
|
|
saveIndexSelection.set(_class, column2);
|
|
}
|
|
return h("th", {
|
|
class: _class,
|
|
colspan: column2.colSpan,
|
|
key: `${column2.id}-thead`,
|
|
rowspan: column2.rowSpan,
|
|
style: getHeaderCellStyle(rowIndex, cellIndex, subColumns, column2),
|
|
onClick: ($event) => {
|
|
if ($event.currentTarget.classList.contains("noclick")) {
|
|
return;
|
|
}
|
|
handleHeaderClick($event, column2);
|
|
},
|
|
onContextmenu: ($event) => handleHeaderContextMenu($event, column2),
|
|
onMousedown: ($event) => handleMouseDown($event, column2),
|
|
onMousemove: ($event) => handleMouseMove($event, column2),
|
|
onMouseout: handleMouseOut
|
|
}, [
|
|
h("div", {
|
|
class: [
|
|
"cell",
|
|
column2.filteredValue && column2.filteredValue.length > 0 ? "highlight" : ""
|
|
]
|
|
}, [
|
|
column2.renderHeader ? column2.renderHeader({
|
|
column: column2,
|
|
$index: cellIndex,
|
|
store,
|
|
_self: $parent
|
|
}) : column2.label,
|
|
column2.sortable && h("span", {
|
|
onClick: ($event) => handleSortClick($event, column2),
|
|
class: "caret-wrapper"
|
|
}, [
|
|
h("i", {
|
|
onClick: ($event) => handleSortClick($event, column2, "ascending"),
|
|
class: "sort-caret ascending"
|
|
}),
|
|
h("i", {
|
|
onClick: ($event) => handleSortClick($event, column2, "descending"),
|
|
class: "sort-caret descending"
|
|
})
|
|
]),
|
|
column2.filterable && h(FilterPanel, {
|
|
store,
|
|
placement: column2.filterPlacement || "bottom-start",
|
|
appendTo: $parent.appendFilterPanelTo,
|
|
column: column2,
|
|
upDataColumn: (key, value) => {
|
|
column2[key] = value;
|
|
}
|
|
}, {
|
|
"filter-icon": () => column2.renderFilterIcon ? column2.renderFilterIcon({
|
|
filterOpened: column2.filterOpened
|
|
}) : null
|
|
})
|
|
])
|
|
]);
|
|
}))));
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-body/events-helper.mjs
|
|
function isGreaterThan(a2, b2, epsilon = 0.03) {
|
|
return a2 - b2 > epsilon;
|
|
}
|
|
function useEvents(props2) {
|
|
const parent2 = inject(TABLE_INJECTION_KEY);
|
|
const tooltipContent = ref("");
|
|
const tooltipTrigger = ref(h("div"));
|
|
const handleEvent = (event, row, name) => {
|
|
var _a2;
|
|
const table = parent2;
|
|
const cell = getCell(event);
|
|
let column2;
|
|
const namespace = (_a2 = table == null ? void 0 : table.vnode.el) == null ? void 0 : _a2.dataset.prefix;
|
|
if (cell) {
|
|
column2 = getColumnByCell({
|
|
columns: props2.store.states.columns.value
|
|
}, cell, namespace);
|
|
if (column2) {
|
|
table == null ? void 0 : table.emit(`cell-${name}`, row, column2, cell, event);
|
|
}
|
|
}
|
|
table == null ? void 0 : table.emit(`row-${name}`, row, column2, event);
|
|
};
|
|
const handleDoubleClick = (event, row) => {
|
|
handleEvent(event, row, "dblclick");
|
|
};
|
|
const handleClick = (event, row) => {
|
|
props2.store.commit("setCurrentRow", row);
|
|
handleEvent(event, row, "click");
|
|
};
|
|
const handleContextMenu = (event, row) => {
|
|
handleEvent(event, row, "contextmenu");
|
|
};
|
|
const handleMouseEnter = debounce_default((index) => {
|
|
props2.store.commit("setHoverRow", index);
|
|
}, 30);
|
|
const handleMouseLeave = debounce_default(() => {
|
|
props2.store.commit("setHoverRow", null);
|
|
}, 30);
|
|
const getPadding = (el) => {
|
|
const style = window.getComputedStyle(el, null);
|
|
const paddingLeft = Number.parseInt(style.paddingLeft, 10) || 0;
|
|
const paddingRight = Number.parseInt(style.paddingRight, 10) || 0;
|
|
const paddingTop = Number.parseInt(style.paddingTop, 10) || 0;
|
|
const paddingBottom = Number.parseInt(style.paddingBottom, 10) || 0;
|
|
return {
|
|
left: paddingLeft,
|
|
right: paddingRight,
|
|
top: paddingTop,
|
|
bottom: paddingBottom
|
|
};
|
|
};
|
|
const toggleRowClassByCell = (rowSpan, event, toggle) => {
|
|
let node = event.target.parentNode;
|
|
while (rowSpan > 1) {
|
|
node = node == null ? void 0 : node.nextSibling;
|
|
if (!node || node.nodeName !== "TR")
|
|
break;
|
|
toggle(node, "hover-row hover-fixed-row");
|
|
rowSpan--;
|
|
}
|
|
};
|
|
const handleCellMouseEnter = (event, row, tooltipOptions) => {
|
|
var _a2, _b, _c;
|
|
const table = parent2;
|
|
const cell = getCell(event);
|
|
const namespace = (_a2 = table == null ? void 0 : table.vnode.el) == null ? void 0 : _a2.dataset.prefix;
|
|
let column2;
|
|
if (cell) {
|
|
column2 = getColumnByCell({
|
|
columns: props2.store.states.columns.value
|
|
}, cell, namespace);
|
|
if (cell.rowSpan > 1) {
|
|
toggleRowClassByCell(cell.rowSpan, event, addClass);
|
|
}
|
|
const hoverState = table.hoverState = { cell, column: column2, row };
|
|
table == null ? void 0 : table.emit("cell-mouse-enter", hoverState.row, hoverState.column, hoverState.cell, event);
|
|
}
|
|
if (!tooltipOptions) {
|
|
return;
|
|
}
|
|
const cellChild = event.target.querySelector(".cell");
|
|
if (!(hasClass(cellChild, `${namespace}-tooltip`) && cellChild.childNodes.length)) {
|
|
return;
|
|
}
|
|
const range4 = document.createRange();
|
|
range4.setStart(cellChild, 0);
|
|
range4.setEnd(cellChild, cellChild.childNodes.length);
|
|
const { width: rangeWidth, height: rangeHeight } = range4.getBoundingClientRect();
|
|
const { width: cellChildWidth, height: cellChildHeight } = cellChild.getBoundingClientRect();
|
|
const { top, left, right, bottom } = getPadding(cellChild);
|
|
const horizontalPadding = left + right;
|
|
const verticalPadding = top + bottom;
|
|
if (isGreaterThan(rangeWidth + horizontalPadding, cellChildWidth) || isGreaterThan(rangeHeight + verticalPadding, cellChildHeight) || isGreaterThan(cellChild.scrollWidth, cellChildWidth)) {
|
|
createTablePopper(tooltipOptions, cell.innerText || cell.textContent, row, column2, cell, table);
|
|
} else if (((_b = removePopper) == null ? void 0 : _b.trigger) === cell) {
|
|
(_c = removePopper) == null ? void 0 : _c();
|
|
}
|
|
};
|
|
const handleCellMouseLeave = (event) => {
|
|
const cell = getCell(event);
|
|
if (!cell)
|
|
return;
|
|
if (cell.rowSpan > 1) {
|
|
toggleRowClassByCell(cell.rowSpan, event, removeClass);
|
|
}
|
|
const oldHoverState = parent2 == null ? void 0 : parent2.hoverState;
|
|
parent2 == null ? void 0 : parent2.emit("cell-mouse-leave", oldHoverState == null ? void 0 : oldHoverState.row, oldHoverState == null ? void 0 : oldHoverState.column, oldHoverState == null ? void 0 : oldHoverState.cell, event);
|
|
};
|
|
return {
|
|
handleDoubleClick,
|
|
handleClick,
|
|
handleContextMenu,
|
|
handleMouseEnter,
|
|
handleMouseLeave,
|
|
handleCellMouseEnter,
|
|
handleCellMouseLeave,
|
|
tooltipContent,
|
|
tooltipTrigger
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-body/styles-helper.mjs
|
|
function useStyles(props2) {
|
|
const parent2 = inject(TABLE_INJECTION_KEY);
|
|
const ns = useNamespace("table");
|
|
const getRowStyle = (row, rowIndex) => {
|
|
const rowStyle = parent2 == null ? void 0 : parent2.props.rowStyle;
|
|
if (isFunction(rowStyle)) {
|
|
return rowStyle.call(null, {
|
|
row,
|
|
rowIndex
|
|
});
|
|
}
|
|
return rowStyle || null;
|
|
};
|
|
const getRowClass = (row, rowIndex) => {
|
|
const classes = [ns.e("row")];
|
|
if ((parent2 == null ? void 0 : parent2.props.highlightCurrentRow) && row === props2.store.states.currentRow.value) {
|
|
classes.push("current-row");
|
|
}
|
|
if (props2.stripe && rowIndex % 2 === 1) {
|
|
classes.push(ns.em("row", "striped"));
|
|
}
|
|
const rowClassName = parent2 == null ? void 0 : parent2.props.rowClassName;
|
|
if (isString(rowClassName)) {
|
|
classes.push(rowClassName);
|
|
} else if (isFunction(rowClassName)) {
|
|
classes.push(rowClassName.call(null, {
|
|
row,
|
|
rowIndex
|
|
}));
|
|
}
|
|
return classes;
|
|
};
|
|
const getCellStyle = (rowIndex, columnIndex, row, column2) => {
|
|
const cellStyle = parent2 == null ? void 0 : parent2.props.cellStyle;
|
|
let cellStyles = cellStyle != null ? cellStyle : {};
|
|
if (isFunction(cellStyle)) {
|
|
cellStyles = cellStyle.call(null, {
|
|
rowIndex,
|
|
columnIndex,
|
|
row,
|
|
column: column2
|
|
});
|
|
}
|
|
const fixedStyle = getFixedColumnOffset(columnIndex, props2 == null ? void 0 : props2.fixed, props2.store);
|
|
ensurePosition(fixedStyle, "left");
|
|
ensurePosition(fixedStyle, "right");
|
|
return Object.assign({}, cellStyles, fixedStyle);
|
|
};
|
|
const getCellClass = (rowIndex, columnIndex, row, column2, offset3) => {
|
|
const fixedClasses = getFixedColumnsClass(ns.b(), columnIndex, props2 == null ? void 0 : props2.fixed, props2.store, void 0, offset3);
|
|
const classes = [column2.id, column2.align, column2.className, ...fixedClasses];
|
|
const cellClassName = parent2 == null ? void 0 : parent2.props.cellClassName;
|
|
if (isString(cellClassName)) {
|
|
classes.push(cellClassName);
|
|
} else if (isFunction(cellClassName)) {
|
|
classes.push(cellClassName.call(null, {
|
|
rowIndex,
|
|
columnIndex,
|
|
row,
|
|
column: column2
|
|
}));
|
|
}
|
|
classes.push(ns.e("cell"));
|
|
return classes.filter((className) => Boolean(className)).join(" ");
|
|
};
|
|
const getSpan = (row, column2, rowIndex, columnIndex) => {
|
|
let rowspan = 1;
|
|
let colspan = 1;
|
|
const fn2 = parent2 == null ? void 0 : parent2.props.spanMethod;
|
|
if (isFunction(fn2)) {
|
|
const result2 = fn2({
|
|
row,
|
|
column: column2,
|
|
rowIndex,
|
|
columnIndex
|
|
});
|
|
if (isArray(result2)) {
|
|
rowspan = result2[0];
|
|
colspan = result2[1];
|
|
} else if (isObject(result2)) {
|
|
rowspan = result2.rowspan;
|
|
colspan = result2.colspan;
|
|
}
|
|
}
|
|
return { rowspan, colspan };
|
|
};
|
|
const getColspanRealWidth = (columns2, colspan, index) => {
|
|
if (colspan < 1) {
|
|
return columns2[index].realWidth;
|
|
}
|
|
const widthArr = columns2.map(({ realWidth, width }) => realWidth || width).slice(index, index + colspan);
|
|
return Number(widthArr.reduce((acc, width) => Number(acc) + Number(width), -1));
|
|
};
|
|
return {
|
|
getRowStyle,
|
|
getRowClass,
|
|
getCellStyle,
|
|
getCellClass,
|
|
getSpan,
|
|
getColspanRealWidth
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-body/td-wrapper.mjs
|
|
var __default__90 = defineComponent({
|
|
name: "TableTdWrapper"
|
|
});
|
|
var _sfc_main125 = defineComponent({
|
|
...__default__90,
|
|
props: {
|
|
colspan: {
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
rowspan: {
|
|
type: Number,
|
|
default: 1
|
|
}
|
|
},
|
|
setup(__props) {
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("td", {
|
|
colspan: __props.colspan,
|
|
rowspan: __props.rowspan
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 8, ["colspan", "rowspan"]);
|
|
};
|
|
}
|
|
});
|
|
var TdWrapper = _export_sfc(_sfc_main125, [["__file", "td-wrapper.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-body/render-helper.mjs
|
|
function useRender(props2) {
|
|
const parent2 = inject(TABLE_INJECTION_KEY);
|
|
const ns = useNamespace("table");
|
|
const {
|
|
handleDoubleClick,
|
|
handleClick,
|
|
handleContextMenu,
|
|
handleMouseEnter,
|
|
handleMouseLeave,
|
|
handleCellMouseEnter,
|
|
handleCellMouseLeave,
|
|
tooltipContent,
|
|
tooltipTrigger
|
|
} = useEvents(props2);
|
|
const {
|
|
getRowStyle,
|
|
getRowClass,
|
|
getCellStyle,
|
|
getCellClass,
|
|
getSpan,
|
|
getColspanRealWidth
|
|
} = useStyles(props2);
|
|
const firstDefaultColumnIndex = computed(() => {
|
|
return props2.store.states.columns.value.findIndex(({ type: type4 }) => type4 === "default");
|
|
});
|
|
const getKeyOfRow = (row, index) => {
|
|
const rowKey2 = parent2.props.rowKey;
|
|
if (rowKey2) {
|
|
return getRowIdentity(row, rowKey2);
|
|
}
|
|
return index;
|
|
};
|
|
const rowRender = (row, $index, treeRowData, expanded = false) => {
|
|
const { tooltipEffect, tooltipOptions, store } = props2;
|
|
const { indent, columns: columns2 } = store.states;
|
|
const rowClasses = getRowClass(row, $index);
|
|
let display = true;
|
|
if (treeRowData) {
|
|
rowClasses.push(ns.em("row", `level-${treeRowData.level}`));
|
|
display = treeRowData.display;
|
|
}
|
|
const displayStyle = display ? null : { display: "none" };
|
|
return h("tr", {
|
|
style: [displayStyle, getRowStyle(row, $index)],
|
|
class: rowClasses,
|
|
key: getKeyOfRow(row, $index),
|
|
onDblclick: ($event) => handleDoubleClick($event, row),
|
|
onClick: ($event) => handleClick($event, row),
|
|
onContextmenu: ($event) => handleContextMenu($event, row),
|
|
onMouseenter: () => handleMouseEnter($index),
|
|
onMouseleave: handleMouseLeave
|
|
}, columns2.value.map((column2, cellIndex) => {
|
|
const { rowspan, colspan } = getSpan(row, column2, $index, cellIndex);
|
|
if (!rowspan || !colspan) {
|
|
return null;
|
|
}
|
|
const columnData = Object.assign({}, column2);
|
|
columnData.realWidth = getColspanRealWidth(columns2.value, colspan, cellIndex);
|
|
const data = {
|
|
store: props2.store,
|
|
_self: props2.context || parent2,
|
|
column: columnData,
|
|
row,
|
|
$index,
|
|
cellIndex,
|
|
expanded
|
|
};
|
|
if (cellIndex === firstDefaultColumnIndex.value && treeRowData) {
|
|
data.treeNode = {
|
|
indent: treeRowData.level * indent.value,
|
|
level: treeRowData.level
|
|
};
|
|
if (isBoolean2(treeRowData.expanded)) {
|
|
data.treeNode.expanded = treeRowData.expanded;
|
|
if ("loading" in treeRowData) {
|
|
data.treeNode.loading = treeRowData.loading;
|
|
}
|
|
if ("noLazyChildren" in treeRowData) {
|
|
data.treeNode.noLazyChildren = treeRowData.noLazyChildren;
|
|
}
|
|
}
|
|
}
|
|
const baseKey = `${getKeyOfRow(row, $index)},${cellIndex}`;
|
|
const patchKey = columnData.columnKey || columnData.rawColumnKey || "";
|
|
const mergedTooltipOptions = column2.showOverflowTooltip && merge_default({
|
|
effect: tooltipEffect
|
|
}, tooltipOptions, column2.showOverflowTooltip);
|
|
return h(TdWrapper, {
|
|
style: getCellStyle($index, cellIndex, row, column2),
|
|
class: getCellClass($index, cellIndex, row, column2, colspan - 1),
|
|
key: `${patchKey}${baseKey}`,
|
|
rowspan,
|
|
colspan,
|
|
onMouseenter: ($event) => handleCellMouseEnter($event, row, mergedTooltipOptions),
|
|
onMouseleave: handleCellMouseLeave
|
|
}, {
|
|
default: () => cellChildren(cellIndex, column2, data)
|
|
});
|
|
}));
|
|
};
|
|
const cellChildren = (cellIndex, column2, data) => {
|
|
return column2.renderCell(data);
|
|
};
|
|
const wrappedRowRender = (row, $index) => {
|
|
const store = props2.store;
|
|
const { isRowExpanded, assertRowKey } = store;
|
|
const { treeData, lazyTreeNodeMap, childrenColumnName, rowKey: rowKey2 } = store.states;
|
|
const columns2 = store.states.columns.value;
|
|
const hasExpandColumn = columns2.some(({ type: type4 }) => type4 === "expand");
|
|
if (hasExpandColumn) {
|
|
const expanded = isRowExpanded(row);
|
|
const tr = rowRender(row, $index, void 0, expanded);
|
|
const renderExpanded = parent2.renderExpanded;
|
|
if (!renderExpanded) {
|
|
console.error("[Element Error]renderExpanded is required.");
|
|
return tr;
|
|
}
|
|
const rows = [[tr]];
|
|
if (parent2.props.preserveExpandedContent || expanded) {
|
|
rows[0].push(h("tr", {
|
|
key: `expanded-row__${tr.key}`,
|
|
style: { display: expanded ? "" : "none" }
|
|
}, [
|
|
h("td", {
|
|
colspan: columns2.length,
|
|
class: `${ns.e("cell")} ${ns.e("expanded-cell")}`
|
|
}, [renderExpanded({ row, $index, store, expanded })])
|
|
]));
|
|
}
|
|
return rows;
|
|
} else if (Object.keys(treeData.value).length) {
|
|
assertRowKey();
|
|
const key = getRowIdentity(row, rowKey2.value);
|
|
let cur = treeData.value[key];
|
|
let treeRowData = null;
|
|
if (cur) {
|
|
treeRowData = {
|
|
expanded: cur.expanded,
|
|
level: cur.level,
|
|
display: true
|
|
};
|
|
if (isBoolean2(cur.lazy)) {
|
|
if (isBoolean2(cur.loaded) && cur.loaded) {
|
|
treeRowData.noLazyChildren = !(cur.children && cur.children.length);
|
|
}
|
|
treeRowData.loading = cur.loading;
|
|
}
|
|
}
|
|
const tmp = [rowRender(row, $index, treeRowData)];
|
|
if (cur) {
|
|
let i = 0;
|
|
const traverse = (children, parent22) => {
|
|
if (!(children && children.length && parent22))
|
|
return;
|
|
children.forEach((node) => {
|
|
const innerTreeRowData = {
|
|
display: parent22.display && parent22.expanded,
|
|
level: parent22.level + 1,
|
|
expanded: false,
|
|
noLazyChildren: false,
|
|
loading: false
|
|
};
|
|
const childKey = getRowIdentity(node, rowKey2.value);
|
|
if (isPropAbsent(childKey)) {
|
|
throw new Error("For nested data item, row-key is required.");
|
|
}
|
|
cur = { ...treeData.value[childKey] };
|
|
if (cur) {
|
|
innerTreeRowData.expanded = cur.expanded;
|
|
cur.level = cur.level || innerTreeRowData.level;
|
|
cur.display = !!(cur.expanded && innerTreeRowData.display);
|
|
if (isBoolean2(cur.lazy)) {
|
|
if (isBoolean2(cur.loaded) && cur.loaded) {
|
|
innerTreeRowData.noLazyChildren = !(cur.children && cur.children.length);
|
|
}
|
|
innerTreeRowData.loading = cur.loading;
|
|
}
|
|
}
|
|
i++;
|
|
tmp.push(rowRender(node, $index + i, innerTreeRowData));
|
|
if (cur) {
|
|
const nodes2 = lazyTreeNodeMap.value[childKey] || node[childrenColumnName.value];
|
|
traverse(nodes2, cur);
|
|
}
|
|
});
|
|
};
|
|
cur.display = true;
|
|
const nodes = lazyTreeNodeMap.value[key] || row[childrenColumnName.value];
|
|
traverse(nodes, cur);
|
|
}
|
|
return tmp;
|
|
} else {
|
|
return rowRender(row, $index, void 0);
|
|
}
|
|
};
|
|
return {
|
|
wrappedRowRender,
|
|
tooltipContent,
|
|
tooltipTrigger
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-body/defaults.mjs
|
|
var defaultProps2 = {
|
|
store: {
|
|
required: true,
|
|
type: Object
|
|
},
|
|
stripe: Boolean,
|
|
tooltipEffect: String,
|
|
tooltipOptions: {
|
|
type: Object
|
|
},
|
|
context: {
|
|
default: () => ({}),
|
|
type: Object
|
|
},
|
|
rowClassName: [String, Function],
|
|
rowStyle: [Object, Function],
|
|
fixed: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
highlight: Boolean
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-body/index.mjs
|
|
var TableBody = defineComponent({
|
|
name: "ElTableBody",
|
|
props: defaultProps2,
|
|
setup(props2) {
|
|
const instance = getCurrentInstance();
|
|
const parent2 = inject(TABLE_INJECTION_KEY);
|
|
const ns = useNamespace("table");
|
|
const { wrappedRowRender, tooltipContent, tooltipTrigger } = useRender(props2);
|
|
const { onColumnsChange, onScrollableChange } = useLayoutObserver(parent2);
|
|
const hoveredCellList = [];
|
|
watch(props2.store.states.hoverRow, (newVal, oldVal) => {
|
|
var _a2;
|
|
const el = instance == null ? void 0 : instance.vnode.el;
|
|
const rows = Array.from((el == null ? void 0 : el.children) || []).filter((e) => e == null ? void 0 : e.classList.contains(`${ns.e("row")}`));
|
|
let rowNum = newVal;
|
|
const childNodes = (_a2 = rows[rowNum]) == null ? void 0 : _a2.childNodes;
|
|
if (childNodes == null ? void 0 : childNodes.length) {
|
|
let control = 0;
|
|
const indexes = Array.from(childNodes).reduce((acc, item, index) => {
|
|
var _a22, _b;
|
|
if (((_a22 = childNodes[index]) == null ? void 0 : _a22.colSpan) > 1) {
|
|
control = (_b = childNodes[index]) == null ? void 0 : _b.colSpan;
|
|
}
|
|
if (item.nodeName !== "TD" && control === 0) {
|
|
acc.push(index);
|
|
}
|
|
control > 0 && control--;
|
|
return acc;
|
|
}, []);
|
|
indexes.forEach((rowIndex) => {
|
|
var _a22;
|
|
rowNum = newVal;
|
|
while (rowNum > 0) {
|
|
const preChildNodes = (_a22 = rows[rowNum - 1]) == null ? void 0 : _a22.childNodes;
|
|
if (preChildNodes[rowIndex] && preChildNodes[rowIndex].nodeName === "TD" && preChildNodes[rowIndex].rowSpan > 1) {
|
|
addClass(preChildNodes[rowIndex], "hover-cell");
|
|
hoveredCellList.push(preChildNodes[rowIndex]);
|
|
break;
|
|
}
|
|
rowNum--;
|
|
}
|
|
});
|
|
} else {
|
|
hoveredCellList.forEach((item) => removeClass(item, "hover-cell"));
|
|
hoveredCellList.length = 0;
|
|
}
|
|
if (!props2.store.states.isComplex.value || !isClient)
|
|
return;
|
|
rAF(() => {
|
|
const oldRow = rows[oldVal];
|
|
const newRow = rows[newVal];
|
|
if (oldRow && !oldRow.classList.contains("hover-fixed-row")) {
|
|
removeClass(oldRow, "hover-row");
|
|
}
|
|
if (newRow) {
|
|
addClass(newRow, "hover-row");
|
|
}
|
|
});
|
|
});
|
|
onUnmounted(() => {
|
|
var _a2;
|
|
(_a2 = removePopper) == null ? void 0 : _a2();
|
|
});
|
|
return {
|
|
ns,
|
|
onColumnsChange,
|
|
onScrollableChange,
|
|
wrappedRowRender,
|
|
tooltipContent,
|
|
tooltipTrigger
|
|
};
|
|
},
|
|
render() {
|
|
const { wrappedRowRender, store } = this;
|
|
const data = store.states.data.value || [];
|
|
return h("tbody", { tabIndex: -1 }, [
|
|
data.reduce((acc, row) => {
|
|
return acc.concat(wrappedRowRender(row, acc.length));
|
|
}, [])
|
|
]);
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-footer/mapState-helper.mjs
|
|
function useMapState() {
|
|
var _a2;
|
|
const table = inject(TABLE_INJECTION_KEY);
|
|
const store = table == null ? void 0 : table.store;
|
|
const leftFixedLeafCount = computed(() => {
|
|
var _a22;
|
|
return (_a22 = store == null ? void 0 : store.states.fixedLeafColumnsLength.value) != null ? _a22 : 0;
|
|
});
|
|
const rightFixedLeafCount = computed(() => {
|
|
var _a22;
|
|
return (_a22 = store == null ? void 0 : store.states.rightFixedColumns.value.length) != null ? _a22 : 0;
|
|
});
|
|
const columnsCount = computed(() => {
|
|
var _a22;
|
|
return (_a22 = store == null ? void 0 : store.states.columns.value.length) != null ? _a22 : 0;
|
|
});
|
|
const leftFixedCount = computed(() => {
|
|
var _a22;
|
|
return (_a22 = store == null ? void 0 : store.states.fixedColumns.value.length) != null ? _a22 : 0;
|
|
});
|
|
const rightFixedCount = computed(() => {
|
|
var _a22;
|
|
return (_a22 = store == null ? void 0 : store.states.rightFixedColumns.value.length) != null ? _a22 : 0;
|
|
});
|
|
return {
|
|
leftFixedLeafCount,
|
|
rightFixedLeafCount,
|
|
columnsCount,
|
|
leftFixedCount,
|
|
rightFixedCount,
|
|
columns: (_a2 = store == null ? void 0 : store.states.columns) != null ? _a2 : []
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-footer/style-helper.mjs
|
|
function useStyle2(props2) {
|
|
const { columns: columns2 } = useMapState();
|
|
const ns = useNamespace("table");
|
|
const getCellClasses = (columns22, cellIndex) => {
|
|
const column2 = columns22[cellIndex];
|
|
const classes = [
|
|
ns.e("cell"),
|
|
column2.id,
|
|
column2.align,
|
|
column2.labelClassName,
|
|
...getFixedColumnsClass(ns.b(), cellIndex, column2.fixed, props2.store)
|
|
];
|
|
if (column2.className) {
|
|
classes.push(column2.className);
|
|
}
|
|
if (!column2.children) {
|
|
classes.push(ns.is("leaf"));
|
|
}
|
|
return classes;
|
|
};
|
|
const getCellStyles = (column2, cellIndex) => {
|
|
const fixedStyle = getFixedColumnOffset(cellIndex, column2.fixed, props2.store);
|
|
ensurePosition(fixedStyle, "left");
|
|
ensurePosition(fixedStyle, "right");
|
|
return fixedStyle;
|
|
};
|
|
return {
|
|
getCellClasses,
|
|
getCellStyles,
|
|
columns: columns2
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-footer/index.mjs
|
|
var TableFooter = defineComponent({
|
|
name: "ElTableFooter",
|
|
props: {
|
|
fixed: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
store: {
|
|
required: true,
|
|
type: Object
|
|
},
|
|
summaryMethod: Function,
|
|
sumText: String,
|
|
border: Boolean,
|
|
defaultSort: {
|
|
type: Object,
|
|
default: () => {
|
|
return {
|
|
prop: "",
|
|
order: ""
|
|
};
|
|
}
|
|
}
|
|
},
|
|
setup(props2) {
|
|
const parent2 = inject(TABLE_INJECTION_KEY);
|
|
const ns = useNamespace("table");
|
|
const { getCellClasses, getCellStyles, columns: columns2 } = useStyle2(props2);
|
|
const { onScrollableChange, onColumnsChange } = useLayoutObserver(parent2);
|
|
return {
|
|
ns,
|
|
onScrollableChange,
|
|
onColumnsChange,
|
|
getCellClasses,
|
|
getCellStyles,
|
|
columns: columns2
|
|
};
|
|
},
|
|
render() {
|
|
const { columns: columns2, getCellStyles, getCellClasses, summaryMethod, sumText } = this;
|
|
const data = this.store.states.data.value;
|
|
let sums = [];
|
|
if (summaryMethod) {
|
|
sums = summaryMethod({
|
|
columns: columns2,
|
|
data
|
|
});
|
|
} else {
|
|
columns2.forEach((column2, index) => {
|
|
if (index === 0) {
|
|
sums[index] = sumText;
|
|
return;
|
|
}
|
|
const values2 = data.map((item) => Number(item[column2.property]));
|
|
const precisions = [];
|
|
let notNumber = true;
|
|
values2.forEach((value) => {
|
|
if (!Number.isNaN(+value)) {
|
|
notNumber = false;
|
|
const decimal = `${value}`.split(".")[1];
|
|
precisions.push(decimal ? decimal.length : 0);
|
|
}
|
|
});
|
|
const precision = Math.max.apply(null, precisions);
|
|
if (!notNumber) {
|
|
sums[index] = values2.reduce((prev, curr) => {
|
|
const value = Number(curr);
|
|
if (!Number.isNaN(+value)) {
|
|
return Number.parseFloat((prev + curr).toFixed(Math.min(precision, 20)));
|
|
} else {
|
|
return prev;
|
|
}
|
|
}, 0);
|
|
} else {
|
|
sums[index] = "";
|
|
}
|
|
});
|
|
}
|
|
return h(h("tfoot", [
|
|
h("tr", {}, [
|
|
...columns2.map((column2, cellIndex) => h("td", {
|
|
key: cellIndex,
|
|
colspan: column2.colSpan,
|
|
rowspan: column2.rowSpan,
|
|
class: getCellClasses(columns2, cellIndex),
|
|
style: getCellStyles(column2, cellIndex)
|
|
}, [
|
|
h("div", {
|
|
class: ["cell", column2.labelClassName]
|
|
}, [sums[cellIndex]])
|
|
]))
|
|
])
|
|
]));
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table/src/table/utils-helper.mjs
|
|
function useUtils2(store) {
|
|
const setCurrentRow = (row) => {
|
|
store.commit("setCurrentRow", row);
|
|
};
|
|
const getSelectionRows = () => {
|
|
return store.getSelectionRows();
|
|
};
|
|
const toggleRowSelection = (row, selected, ignoreSelectable = true) => {
|
|
store.toggleRowSelection(row, selected, false, ignoreSelectable);
|
|
store.updateAllSelected();
|
|
};
|
|
const clearSelection = () => {
|
|
store.clearSelection();
|
|
};
|
|
const clearFilter = (columnKeys) => {
|
|
store.clearFilter(columnKeys);
|
|
};
|
|
const toggleAllSelection = () => {
|
|
store.commit("toggleAllSelection");
|
|
};
|
|
const toggleRowExpansion = (row, expanded) => {
|
|
store.toggleRowExpansionAdapter(row, expanded);
|
|
};
|
|
const clearSort = () => {
|
|
store.clearSort();
|
|
};
|
|
const sort = (prop, order) => {
|
|
store.commit("sort", { prop, order });
|
|
};
|
|
const updateKeyChildren = (key, data) => {
|
|
store.updateKeyChildren(key, data);
|
|
};
|
|
return {
|
|
setCurrentRow,
|
|
getSelectionRows,
|
|
toggleRowSelection,
|
|
clearSelection,
|
|
clearFilter,
|
|
toggleAllSelection,
|
|
toggleRowExpansion,
|
|
clearSort,
|
|
sort,
|
|
updateKeyChildren
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/table/style-helper.mjs
|
|
function useStyle3(props2, layout2, store, table) {
|
|
const isHidden2 = ref(false);
|
|
const renderExpanded = ref(null);
|
|
const resizeProxyVisible = ref(false);
|
|
const setDragVisible = (visible) => {
|
|
resizeProxyVisible.value = visible;
|
|
};
|
|
const resizeState = ref({
|
|
width: null,
|
|
height: null,
|
|
headerHeight: null
|
|
});
|
|
const isGroup = ref(false);
|
|
const scrollbarViewStyle = {
|
|
display: "inline-block",
|
|
verticalAlign: "middle"
|
|
};
|
|
const tableWidth = ref();
|
|
const tableScrollHeight = ref(0);
|
|
const bodyScrollHeight = ref(0);
|
|
const headerScrollHeight = ref(0);
|
|
const footerScrollHeight = ref(0);
|
|
const appendScrollHeight = ref(0);
|
|
watchEffect(() => {
|
|
layout2.setHeight(props2.height);
|
|
});
|
|
watchEffect(() => {
|
|
layout2.setMaxHeight(props2.maxHeight);
|
|
});
|
|
watch(() => [props2.currentRowKey, store.states.rowKey], ([currentRowKey, rowKey2]) => {
|
|
if (!unref(rowKey2) || !unref(currentRowKey))
|
|
return;
|
|
store.setCurrentRowKey(`${currentRowKey}`);
|
|
}, {
|
|
immediate: true
|
|
});
|
|
watch(() => props2.data, (data) => {
|
|
table.store.commit("setData", data);
|
|
}, {
|
|
immediate: true,
|
|
deep: true
|
|
});
|
|
watchEffect(() => {
|
|
if (props2.expandRowKeys) {
|
|
store.setExpandRowKeysAdapter(props2.expandRowKeys);
|
|
}
|
|
});
|
|
const handleMouseLeave = () => {
|
|
table.store.commit("setHoverRow", null);
|
|
if (table.hoverState)
|
|
table.hoverState = null;
|
|
};
|
|
const handleHeaderFooterMousewheel = (event, data) => {
|
|
const { pixelX, pixelY } = data;
|
|
if (Math.abs(pixelX) >= Math.abs(pixelY)) {
|
|
table.refs.bodyWrapper.scrollLeft += data.pixelX / 5;
|
|
}
|
|
};
|
|
const shouldUpdateHeight = computed(() => {
|
|
return props2.height || props2.maxHeight || store.states.fixedColumns.value.length > 0 || store.states.rightFixedColumns.value.length > 0;
|
|
});
|
|
const tableBodyStyles = computed(() => {
|
|
return {
|
|
width: layout2.bodyWidth.value ? `${layout2.bodyWidth.value}px` : ""
|
|
};
|
|
});
|
|
const doLayout = () => {
|
|
if (shouldUpdateHeight.value) {
|
|
layout2.updateElsHeight();
|
|
}
|
|
layout2.updateColumnsWidth();
|
|
if (typeof window === "undefined")
|
|
return;
|
|
requestAnimationFrame(syncPosition);
|
|
};
|
|
onMounted(async () => {
|
|
await nextTick();
|
|
store.updateColumns();
|
|
bindEvents();
|
|
requestAnimationFrame(doLayout);
|
|
const el = table.vnode.el;
|
|
const tableHeader = table.refs.headerWrapper;
|
|
if (props2.flexible && el && el.parentElement) {
|
|
el.parentElement.style.minWidth = "0";
|
|
}
|
|
resizeState.value = {
|
|
width: tableWidth.value = el.offsetWidth,
|
|
height: el.offsetHeight,
|
|
headerHeight: props2.showHeader && tableHeader ? tableHeader.offsetHeight : null
|
|
};
|
|
store.states.columns.value.forEach((column2) => {
|
|
if (column2.filteredValue && column2.filteredValue.length) {
|
|
table.store.commit("filterChange", {
|
|
column: column2,
|
|
values: column2.filteredValue,
|
|
silent: true
|
|
});
|
|
}
|
|
});
|
|
table.$ready = true;
|
|
});
|
|
const setScrollClassByEl = (el, className) => {
|
|
if (!el)
|
|
return;
|
|
const classList = Array.from(el.classList).filter((item) => !item.startsWith("is-scrolling-"));
|
|
classList.push(layout2.scrollX.value ? className : "is-scrolling-none");
|
|
el.className = classList.join(" ");
|
|
};
|
|
const setScrollClass = (className) => {
|
|
const { tableWrapper } = table.refs;
|
|
setScrollClassByEl(tableWrapper, className);
|
|
};
|
|
const hasScrollClass = (className) => {
|
|
const { tableWrapper } = table.refs;
|
|
return !!(tableWrapper && tableWrapper.classList.contains(className));
|
|
};
|
|
const syncPosition = function() {
|
|
if (!table.refs.scrollBarRef)
|
|
return;
|
|
if (!layout2.scrollX.value) {
|
|
const scrollingNoneClass = "is-scrolling-none";
|
|
if (!hasScrollClass(scrollingNoneClass)) {
|
|
setScrollClass(scrollingNoneClass);
|
|
}
|
|
return;
|
|
}
|
|
const scrollContainer = table.refs.scrollBarRef.wrapRef;
|
|
if (!scrollContainer)
|
|
return;
|
|
const { scrollLeft, offsetWidth, scrollWidth } = scrollContainer;
|
|
const { headerWrapper, footerWrapper } = table.refs;
|
|
if (headerWrapper)
|
|
headerWrapper.scrollLeft = scrollLeft;
|
|
if (footerWrapper)
|
|
footerWrapper.scrollLeft = scrollLeft;
|
|
const maxScrollLeftPosition = scrollWidth - offsetWidth - 1;
|
|
if (scrollLeft >= maxScrollLeftPosition) {
|
|
setScrollClass("is-scrolling-right");
|
|
} else if (scrollLeft === 0) {
|
|
setScrollClass("is-scrolling-left");
|
|
} else {
|
|
setScrollClass("is-scrolling-middle");
|
|
}
|
|
};
|
|
const bindEvents = () => {
|
|
if (!table.refs.scrollBarRef)
|
|
return;
|
|
if (table.refs.scrollBarRef.wrapRef) {
|
|
useEventListener(table.refs.scrollBarRef.wrapRef, "scroll", syncPosition, {
|
|
passive: true
|
|
});
|
|
}
|
|
if (props2.fit) {
|
|
useResizeObserver(table.vnode.el, resizeListener);
|
|
} else {
|
|
useEventListener(window, "resize", resizeListener);
|
|
}
|
|
useResizeObserver(table.refs.bodyWrapper, () => {
|
|
var _a2, _b;
|
|
resizeListener();
|
|
(_b = (_a2 = table.refs) == null ? void 0 : _a2.scrollBarRef) == null ? void 0 : _b.update();
|
|
});
|
|
};
|
|
const resizeListener = () => {
|
|
var _a2, _b, _c, _d;
|
|
const el = table.vnode.el;
|
|
if (!table.$ready || !el)
|
|
return;
|
|
let shouldUpdateLayout = false;
|
|
const {
|
|
width: oldWidth,
|
|
height: oldHeight,
|
|
headerHeight: oldHeaderHeight
|
|
} = resizeState.value;
|
|
const width = tableWidth.value = el.offsetWidth;
|
|
if (oldWidth !== width) {
|
|
shouldUpdateLayout = true;
|
|
}
|
|
const height = el.offsetHeight;
|
|
if ((props2.height || shouldUpdateHeight.value) && oldHeight !== height) {
|
|
shouldUpdateLayout = true;
|
|
}
|
|
const tableHeader = props2.tableLayout === "fixed" ? table.refs.headerWrapper : (_a2 = table.refs.tableHeaderRef) == null ? void 0 : _a2.$el;
|
|
if (props2.showHeader && (tableHeader == null ? void 0 : tableHeader.offsetHeight) !== oldHeaderHeight) {
|
|
shouldUpdateLayout = true;
|
|
}
|
|
tableScrollHeight.value = ((_b = table.refs.tableWrapper) == null ? void 0 : _b.scrollHeight) || 0;
|
|
headerScrollHeight.value = (tableHeader == null ? void 0 : tableHeader.scrollHeight) || 0;
|
|
footerScrollHeight.value = ((_c = table.refs.footerWrapper) == null ? void 0 : _c.offsetHeight) || 0;
|
|
appendScrollHeight.value = ((_d = table.refs.appendWrapper) == null ? void 0 : _d.offsetHeight) || 0;
|
|
bodyScrollHeight.value = tableScrollHeight.value - headerScrollHeight.value - footerScrollHeight.value - appendScrollHeight.value;
|
|
if (shouldUpdateLayout) {
|
|
resizeState.value = {
|
|
width,
|
|
height,
|
|
headerHeight: props2.showHeader && (tableHeader == null ? void 0 : tableHeader.offsetHeight) || 0
|
|
};
|
|
doLayout();
|
|
}
|
|
};
|
|
const tableSize = useFormSize();
|
|
const bodyWidth = computed(() => {
|
|
const { bodyWidth: bodyWidth_, scrollY, gutterWidth } = layout2;
|
|
return bodyWidth_.value ? `${bodyWidth_.value - (scrollY.value ? gutterWidth : 0)}px` : "";
|
|
});
|
|
const tableLayout = computed(() => {
|
|
if (props2.maxHeight)
|
|
return "fixed";
|
|
return props2.tableLayout;
|
|
});
|
|
const emptyBlockStyle = computed(() => {
|
|
if (props2.data && props2.data.length)
|
|
return null;
|
|
let height = "100%";
|
|
if (props2.height && bodyScrollHeight.value) {
|
|
height = `${bodyScrollHeight.value}px`;
|
|
}
|
|
const width = tableWidth.value;
|
|
return {
|
|
width: width ? `${width}px` : "",
|
|
height
|
|
};
|
|
});
|
|
const scrollbarStyle = computed(() => {
|
|
if (props2.height) {
|
|
return {
|
|
height: "100%"
|
|
};
|
|
}
|
|
if (props2.maxHeight) {
|
|
if (!Number.isNaN(Number(props2.maxHeight))) {
|
|
return {
|
|
maxHeight: `${props2.maxHeight - headerScrollHeight.value - footerScrollHeight.value}px`
|
|
};
|
|
} else {
|
|
return {
|
|
maxHeight: `calc(${props2.maxHeight} - ${headerScrollHeight.value + footerScrollHeight.value}px)`
|
|
};
|
|
}
|
|
}
|
|
return {};
|
|
});
|
|
const handleFixedMousewheel = (event, data) => {
|
|
const bodyWrapper = table.refs.bodyWrapper;
|
|
if (Math.abs(data.spinY) > 0) {
|
|
const currentScrollTop = bodyWrapper.scrollTop;
|
|
if (data.pixelY < 0 && currentScrollTop !== 0) {
|
|
event.preventDefault();
|
|
}
|
|
if (data.pixelY > 0 && bodyWrapper.scrollHeight - bodyWrapper.clientHeight > currentScrollTop) {
|
|
event.preventDefault();
|
|
}
|
|
bodyWrapper.scrollTop += Math.ceil(data.pixelY / 5);
|
|
} else {
|
|
bodyWrapper.scrollLeft += Math.ceil(data.pixelX / 5);
|
|
}
|
|
};
|
|
return {
|
|
isHidden: isHidden2,
|
|
renderExpanded,
|
|
setDragVisible,
|
|
isGroup,
|
|
handleMouseLeave,
|
|
handleHeaderFooterMousewheel,
|
|
tableSize,
|
|
emptyBlockStyle,
|
|
handleFixedMousewheel,
|
|
resizeProxyVisible,
|
|
bodyWidth,
|
|
resizeState,
|
|
doLayout,
|
|
tableBodyStyles,
|
|
tableLayout,
|
|
scrollbarViewStyle,
|
|
scrollbarStyle
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/table/key-render-helper.mjs
|
|
function useKeyRender(table) {
|
|
const observer = ref();
|
|
const initWatchDom = () => {
|
|
const el = table.vnode.el;
|
|
const columnsWrapper = el.querySelector(".hidden-columns");
|
|
const config = { childList: true, subtree: true };
|
|
const updateOrderFns = table.store.states.updateOrderFns;
|
|
observer.value = new MutationObserver(() => {
|
|
updateOrderFns.forEach((fn2) => fn2());
|
|
});
|
|
observer.value.observe(columnsWrapper, config);
|
|
};
|
|
onMounted(() => {
|
|
initWatchDom();
|
|
});
|
|
onUnmounted(() => {
|
|
var _a2;
|
|
(_a2 = observer.value) == null ? void 0 : _a2.disconnect();
|
|
});
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/table/defaults.mjs
|
|
var defaultProps3 = {
|
|
data: {
|
|
type: Array,
|
|
default: () => []
|
|
},
|
|
size: useSizeProp,
|
|
width: [String, Number],
|
|
height: [String, Number],
|
|
maxHeight: [String, Number],
|
|
fit: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
stripe: Boolean,
|
|
border: Boolean,
|
|
rowKey: [String, Function],
|
|
showHeader: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
showSummary: Boolean,
|
|
sumText: String,
|
|
summaryMethod: Function,
|
|
rowClassName: [String, Function],
|
|
rowStyle: [Object, Function],
|
|
cellClassName: [String, Function],
|
|
cellStyle: [Object, Function],
|
|
headerRowClassName: [String, Function],
|
|
headerRowStyle: [Object, Function],
|
|
headerCellClassName: [String, Function],
|
|
headerCellStyle: [Object, Function],
|
|
highlightCurrentRow: Boolean,
|
|
currentRowKey: [String, Number],
|
|
emptyText: String,
|
|
expandRowKeys: Array,
|
|
defaultExpandAll: Boolean,
|
|
defaultSort: Object,
|
|
tooltipEffect: String,
|
|
tooltipOptions: Object,
|
|
spanMethod: Function,
|
|
selectOnIndeterminate: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
indent: {
|
|
type: Number,
|
|
default: 16
|
|
},
|
|
treeProps: {
|
|
type: Object,
|
|
default: () => {
|
|
return {
|
|
hasChildren: "hasChildren",
|
|
children: "children",
|
|
checkStrictly: false
|
|
};
|
|
}
|
|
},
|
|
lazy: Boolean,
|
|
load: Function,
|
|
style: {
|
|
type: Object,
|
|
default: () => ({})
|
|
},
|
|
className: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
tableLayout: {
|
|
type: String,
|
|
default: "fixed"
|
|
},
|
|
scrollbarAlwaysOn: Boolean,
|
|
flexible: Boolean,
|
|
showOverflowTooltip: [Boolean, Object],
|
|
tooltipFormatter: Function,
|
|
appendFilterPanelTo: String,
|
|
scrollbarTabindex: {
|
|
type: [Number, String],
|
|
default: void 0
|
|
},
|
|
allowDragLastColumn: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
preserveExpandedContent: {
|
|
type: Boolean,
|
|
default: false
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table/src/h-helper.mjs
|
|
function hColgroup(props2) {
|
|
const isAuto = props2.tableLayout === "auto";
|
|
let columns2 = props2.columns || [];
|
|
if (isAuto) {
|
|
if (columns2.every(({ width }) => isUndefined2(width))) {
|
|
columns2 = [];
|
|
}
|
|
}
|
|
const getPropsData = (column2) => {
|
|
const propsData = {
|
|
key: `${props2.tableLayout}_${column2.id}`,
|
|
style: {},
|
|
name: void 0
|
|
};
|
|
if (isAuto) {
|
|
propsData.style = {
|
|
width: `${column2.width}px`
|
|
};
|
|
} else {
|
|
propsData.name = column2.id;
|
|
}
|
|
return propsData;
|
|
};
|
|
return h("colgroup", {}, columns2.map((column2) => h("col", getPropsData(column2))));
|
|
}
|
|
hColgroup.props = ["columns", "tableLayout"];
|
|
|
|
// node_modules/element-plus/es/components/table/src/composables/use-scrollbar.mjs
|
|
var useScrollbar = () => {
|
|
const scrollBarRef = ref();
|
|
const scrollTo = (options, yCoord) => {
|
|
const scrollbar = scrollBarRef.value;
|
|
if (scrollbar) {
|
|
scrollbar.scrollTo(options, yCoord);
|
|
}
|
|
};
|
|
const setScrollPosition = (position, offset3) => {
|
|
const scrollbar = scrollBarRef.value;
|
|
if (scrollbar && isNumber2(offset3) && ["Top", "Left"].includes(position)) {
|
|
scrollbar[`setScroll${position}`](offset3);
|
|
}
|
|
};
|
|
const setScrollTop = (top) => setScrollPosition("Top", top);
|
|
const setScrollLeft = (left) => setScrollPosition("Left", left);
|
|
return {
|
|
scrollBarRef,
|
|
scrollTo,
|
|
setScrollTop,
|
|
setScrollLeft
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table/src/table.mjs
|
|
var tableIdSeed = 1;
|
|
var _sfc_main126 = defineComponent({
|
|
name: "ElTable",
|
|
directives: {
|
|
Mousewheel
|
|
},
|
|
components: {
|
|
TableHeader,
|
|
TableBody,
|
|
TableFooter,
|
|
ElScrollbar,
|
|
hColgroup
|
|
},
|
|
props: defaultProps3,
|
|
emits: [
|
|
"select",
|
|
"select-all",
|
|
"selection-change",
|
|
"cell-mouse-enter",
|
|
"cell-mouse-leave",
|
|
"cell-contextmenu",
|
|
"cell-click",
|
|
"cell-dblclick",
|
|
"row-click",
|
|
"row-contextmenu",
|
|
"row-dblclick",
|
|
"header-click",
|
|
"header-contextmenu",
|
|
"sort-change",
|
|
"filter-change",
|
|
"current-change",
|
|
"header-dragend",
|
|
"expand-change",
|
|
"scroll"
|
|
],
|
|
setup(props2) {
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("table");
|
|
const table = getCurrentInstance();
|
|
provide(TABLE_INJECTION_KEY, table);
|
|
const store = createStore(table, props2);
|
|
table.store = store;
|
|
const layout2 = new TableLayout({
|
|
store: table.store,
|
|
table,
|
|
fit: props2.fit,
|
|
showHeader: props2.showHeader
|
|
});
|
|
table.layout = layout2;
|
|
const isEmpty3 = computed(() => (store.states.data.value || []).length === 0);
|
|
const {
|
|
setCurrentRow,
|
|
getSelectionRows,
|
|
toggleRowSelection,
|
|
clearSelection,
|
|
clearFilter,
|
|
toggleAllSelection,
|
|
toggleRowExpansion,
|
|
clearSort,
|
|
sort,
|
|
updateKeyChildren
|
|
} = useUtils2(store);
|
|
const {
|
|
isHidden: isHidden2,
|
|
renderExpanded,
|
|
setDragVisible,
|
|
isGroup,
|
|
handleMouseLeave,
|
|
handleHeaderFooterMousewheel,
|
|
tableSize,
|
|
emptyBlockStyle,
|
|
handleFixedMousewheel,
|
|
resizeProxyVisible,
|
|
bodyWidth,
|
|
resizeState,
|
|
doLayout,
|
|
tableBodyStyles,
|
|
tableLayout,
|
|
scrollbarViewStyle,
|
|
scrollbarStyle
|
|
} = useStyle3(props2, layout2, store, table);
|
|
const { scrollBarRef, scrollTo, setScrollLeft, setScrollTop } = useScrollbar();
|
|
const debouncedUpdateLayout = debounce_default(doLayout, 50);
|
|
const tableId = `${ns.namespace.value}-table_${tableIdSeed++}`;
|
|
table.tableId = tableId;
|
|
table.state = {
|
|
isGroup,
|
|
resizeState,
|
|
doLayout,
|
|
debouncedUpdateLayout
|
|
};
|
|
const computedSumText = computed(() => {
|
|
var _a2;
|
|
return (_a2 = props2.sumText) != null ? _a2 : t("el.table.sumText");
|
|
});
|
|
const computedEmptyText = computed(() => {
|
|
var _a2;
|
|
return (_a2 = props2.emptyText) != null ? _a2 : t("el.table.emptyText");
|
|
});
|
|
const columns2 = computed(() => {
|
|
return convertToRows(store.states.originColumns.value)[0];
|
|
});
|
|
useKeyRender(table);
|
|
onBeforeUnmount(() => {
|
|
debouncedUpdateLayout.cancel();
|
|
});
|
|
return {
|
|
ns,
|
|
layout: layout2,
|
|
store,
|
|
columns: columns2,
|
|
handleHeaderFooterMousewheel,
|
|
handleMouseLeave,
|
|
tableId,
|
|
tableSize,
|
|
isHidden: isHidden2,
|
|
isEmpty: isEmpty3,
|
|
renderExpanded,
|
|
resizeProxyVisible,
|
|
resizeState,
|
|
isGroup,
|
|
bodyWidth,
|
|
tableBodyStyles,
|
|
emptyBlockStyle,
|
|
debouncedUpdateLayout,
|
|
handleFixedMousewheel,
|
|
setCurrentRow,
|
|
getSelectionRows,
|
|
toggleRowSelection,
|
|
clearSelection,
|
|
clearFilter,
|
|
toggleAllSelection,
|
|
toggleRowExpansion,
|
|
clearSort,
|
|
doLayout,
|
|
sort,
|
|
updateKeyChildren,
|
|
t,
|
|
setDragVisible,
|
|
context: table,
|
|
computedSumText,
|
|
computedEmptyText,
|
|
tableLayout,
|
|
scrollbarViewStyle,
|
|
scrollbarStyle,
|
|
scrollBarRef,
|
|
scrollTo,
|
|
setScrollLeft,
|
|
setScrollTop,
|
|
allowDragLastColumn: props2.allowDragLastColumn
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render25(_ctx, _cache, $props, $setup, $data, $options) {
|
|
const _component_hColgroup = resolveComponent("hColgroup");
|
|
const _component_table_header = resolveComponent("table-header");
|
|
const _component_table_body = resolveComponent("table-body");
|
|
const _component_table_footer = resolveComponent("table-footer");
|
|
const _component_el_scrollbar = resolveComponent("el-scrollbar");
|
|
const _directive_mousewheel = resolveDirective("mousewheel");
|
|
return openBlock(), createElementBlock("div", {
|
|
ref: "tableWrapper",
|
|
class: normalizeClass([
|
|
{
|
|
[_ctx.ns.m("fit")]: _ctx.fit,
|
|
[_ctx.ns.m("striped")]: _ctx.stripe,
|
|
[_ctx.ns.m("border")]: _ctx.border || _ctx.isGroup,
|
|
[_ctx.ns.m("hidden")]: _ctx.isHidden,
|
|
[_ctx.ns.m("group")]: _ctx.isGroup,
|
|
[_ctx.ns.m("fluid-height")]: _ctx.maxHeight,
|
|
[_ctx.ns.m("scrollable-x")]: _ctx.layout.scrollX.value,
|
|
[_ctx.ns.m("scrollable-y")]: _ctx.layout.scrollY.value,
|
|
[_ctx.ns.m("enable-row-hover")]: !_ctx.store.states.isComplex.value,
|
|
[_ctx.ns.m("enable-row-transition")]: (_ctx.store.states.data.value || []).length !== 0 && (_ctx.store.states.data.value || []).length < 100,
|
|
"has-footer": _ctx.showSummary
|
|
},
|
|
_ctx.ns.m(_ctx.tableSize),
|
|
_ctx.className,
|
|
_ctx.ns.b(),
|
|
_ctx.ns.m(`layout-${_ctx.tableLayout}`)
|
|
]),
|
|
style: normalizeStyle(_ctx.style),
|
|
"data-prefix": _ctx.ns.namespace.value,
|
|
onMouseleave: _ctx.handleMouseLeave
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.ns.e("inner-wrapper"))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
ref: "hiddenColumns",
|
|
class: "hidden-columns"
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 512),
|
|
_ctx.showHeader && _ctx.tableLayout === "fixed" ? withDirectives((openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
ref: "headerWrapper",
|
|
class: normalizeClass(_ctx.ns.e("header-wrapper"))
|
|
}, [
|
|
createBaseVNode("table", {
|
|
ref: "tableHeader",
|
|
class: normalizeClass(_ctx.ns.e("header")),
|
|
style: normalizeStyle(_ctx.tableBodyStyles),
|
|
border: "0",
|
|
cellpadding: "0",
|
|
cellspacing: "0"
|
|
}, [
|
|
createVNode(_component_hColgroup, {
|
|
columns: _ctx.store.states.columns.value,
|
|
"table-layout": _ctx.tableLayout
|
|
}, null, 8, ["columns", "table-layout"]),
|
|
createVNode(_component_table_header, {
|
|
ref: "tableHeaderRef",
|
|
border: _ctx.border,
|
|
"default-sort": _ctx.defaultSort,
|
|
store: _ctx.store,
|
|
"append-filter-panel-to": _ctx.appendFilterPanelTo,
|
|
"allow-drag-last-column": _ctx.allowDragLastColumn,
|
|
onSetDragVisible: _ctx.setDragVisible
|
|
}, null, 8, ["border", "default-sort", "store", "append-filter-panel-to", "allow-drag-last-column", "onSetDragVisible"])
|
|
], 6)
|
|
], 2)), [
|
|
[_directive_mousewheel, _ctx.handleHeaderFooterMousewheel]
|
|
]) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
ref: "bodyWrapper",
|
|
class: normalizeClass(_ctx.ns.e("body-wrapper"))
|
|
}, [
|
|
createVNode(_component_el_scrollbar, {
|
|
ref: "scrollBarRef",
|
|
"view-style": _ctx.scrollbarViewStyle,
|
|
"wrap-style": _ctx.scrollbarStyle,
|
|
always: _ctx.scrollbarAlwaysOn,
|
|
tabindex: _ctx.scrollbarTabindex,
|
|
onScroll: ($event) => _ctx.$emit("scroll", $event)
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("table", {
|
|
ref: "tableBody",
|
|
class: normalizeClass(_ctx.ns.e("body")),
|
|
cellspacing: "0",
|
|
cellpadding: "0",
|
|
border: "0",
|
|
style: normalizeStyle({
|
|
width: _ctx.bodyWidth,
|
|
tableLayout: _ctx.tableLayout
|
|
})
|
|
}, [
|
|
createVNode(_component_hColgroup, {
|
|
columns: _ctx.store.states.columns.value,
|
|
"table-layout": _ctx.tableLayout
|
|
}, null, 8, ["columns", "table-layout"]),
|
|
_ctx.showHeader && _ctx.tableLayout === "auto" ? (openBlock(), createBlock(_component_table_header, {
|
|
key: 0,
|
|
ref: "tableHeaderRef",
|
|
class: normalizeClass(_ctx.ns.e("body-header")),
|
|
border: _ctx.border,
|
|
"default-sort": _ctx.defaultSort,
|
|
store: _ctx.store,
|
|
"append-filter-panel-to": _ctx.appendFilterPanelTo,
|
|
onSetDragVisible: _ctx.setDragVisible
|
|
}, null, 8, ["class", "border", "default-sort", "store", "append-filter-panel-to", "onSetDragVisible"])) : createCommentVNode("v-if", true),
|
|
createVNode(_component_table_body, {
|
|
context: _ctx.context,
|
|
highlight: _ctx.highlightCurrentRow,
|
|
"row-class-name": _ctx.rowClassName,
|
|
"tooltip-effect": _ctx.tooltipEffect,
|
|
"tooltip-options": _ctx.tooltipOptions,
|
|
"row-style": _ctx.rowStyle,
|
|
store: _ctx.store,
|
|
stripe: _ctx.stripe
|
|
}, null, 8, ["context", "highlight", "row-class-name", "tooltip-effect", "tooltip-options", "row-style", "store", "stripe"]),
|
|
_ctx.showSummary && _ctx.tableLayout === "auto" ? (openBlock(), createBlock(_component_table_footer, {
|
|
key: 1,
|
|
class: normalizeClass(_ctx.ns.e("body-footer")),
|
|
border: _ctx.border,
|
|
"default-sort": _ctx.defaultSort,
|
|
store: _ctx.store,
|
|
"sum-text": _ctx.computedSumText,
|
|
"summary-method": _ctx.summaryMethod
|
|
}, null, 8, ["class", "border", "default-sort", "store", "sum-text", "summary-method"])) : createCommentVNode("v-if", true)
|
|
], 6),
|
|
_ctx.isEmpty ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
ref: "emptyBlock",
|
|
style: normalizeStyle(_ctx.emptyBlockStyle),
|
|
class: normalizeClass(_ctx.ns.e("empty-block"))
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(_ctx.ns.e("empty-text"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "empty", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.computedEmptyText), 1)
|
|
])
|
|
], 2)
|
|
], 6)) : createCommentVNode("v-if", true),
|
|
_ctx.$slots.append ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
ref: "appendWrapper",
|
|
class: normalizeClass(_ctx.ns.e("append-wrapper"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "append")
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 8, ["view-style", "wrap-style", "always", "tabindex", "onScroll"])
|
|
], 2),
|
|
_ctx.showSummary && _ctx.tableLayout === "fixed" ? withDirectives((openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
ref: "footerWrapper",
|
|
class: normalizeClass(_ctx.ns.e("footer-wrapper"))
|
|
}, [
|
|
createBaseVNode("table", {
|
|
class: normalizeClass(_ctx.ns.e("footer")),
|
|
cellspacing: "0",
|
|
cellpadding: "0",
|
|
border: "0",
|
|
style: normalizeStyle(_ctx.tableBodyStyles)
|
|
}, [
|
|
createVNode(_component_hColgroup, {
|
|
columns: _ctx.store.states.columns.value,
|
|
"table-layout": _ctx.tableLayout
|
|
}, null, 8, ["columns", "table-layout"]),
|
|
createVNode(_component_table_footer, {
|
|
border: _ctx.border,
|
|
"default-sort": _ctx.defaultSort,
|
|
store: _ctx.store,
|
|
"sum-text": _ctx.computedSumText,
|
|
"summary-method": _ctx.summaryMethod
|
|
}, null, 8, ["border", "default-sort", "store", "sum-text", "summary-method"])
|
|
], 6)
|
|
], 2)), [
|
|
[vShow, !_ctx.isEmpty],
|
|
[_directive_mousewheel, _ctx.handleHeaderFooterMousewheel]
|
|
]) : createCommentVNode("v-if", true),
|
|
_ctx.border || _ctx.isGroup ? (openBlock(), createElementBlock("div", {
|
|
key: 2,
|
|
class: normalizeClass(_ctx.ns.e("border-left-patch"))
|
|
}, null, 2)) : createCommentVNode("v-if", true)
|
|
], 2),
|
|
withDirectives(createBaseVNode("div", {
|
|
ref: "resizeProxy",
|
|
class: normalizeClass(_ctx.ns.e("column-resize-proxy"))
|
|
}, null, 2), [
|
|
[vShow, _ctx.resizeProxyVisible]
|
|
])
|
|
], 46, ["data-prefix", "onMouseleave"]);
|
|
}
|
|
var Table = _export_sfc(_sfc_main126, [["render", _sfc_render25], ["__file", "table.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/table/src/config.mjs
|
|
var defaultClassNames = {
|
|
selection: "table-column--selection",
|
|
expand: "table__expand-column"
|
|
};
|
|
var cellStarts = {
|
|
default: {
|
|
order: ""
|
|
},
|
|
selection: {
|
|
width: 48,
|
|
minWidth: 48,
|
|
realWidth: 48,
|
|
order: ""
|
|
},
|
|
expand: {
|
|
width: 48,
|
|
minWidth: 48,
|
|
realWidth: 48,
|
|
order: ""
|
|
},
|
|
index: {
|
|
width: 48,
|
|
minWidth: 48,
|
|
realWidth: 48,
|
|
order: ""
|
|
}
|
|
};
|
|
var getDefaultClassName = (type4) => {
|
|
return defaultClassNames[type4] || "";
|
|
};
|
|
var cellForced = {
|
|
selection: {
|
|
renderHeader({ store, column: column2 }) {
|
|
function isDisabled() {
|
|
return store.states.data.value && store.states.data.value.length === 0;
|
|
}
|
|
return h(ElCheckbox, {
|
|
disabled: isDisabled(),
|
|
size: store.states.tableSize.value,
|
|
indeterminate: store.states.selection.value.length > 0 && !store.states.isAllSelected.value,
|
|
"onUpdate:modelValue": store.toggleAllSelection,
|
|
modelValue: store.states.isAllSelected.value,
|
|
ariaLabel: column2.label
|
|
});
|
|
},
|
|
renderCell({
|
|
row,
|
|
column: column2,
|
|
store,
|
|
$index
|
|
}) {
|
|
return h(ElCheckbox, {
|
|
disabled: column2.selectable ? !column2.selectable.call(null, row, $index) : false,
|
|
size: store.states.tableSize.value,
|
|
onChange: () => {
|
|
store.commit("rowSelectedChanged", row);
|
|
},
|
|
onClick: (event) => event.stopPropagation(),
|
|
modelValue: store.isSelected(row),
|
|
ariaLabel: column2.label
|
|
});
|
|
},
|
|
sortable: false,
|
|
resizable: false
|
|
},
|
|
index: {
|
|
renderHeader({ column: column2 }) {
|
|
return column2.label || "#";
|
|
},
|
|
renderCell({
|
|
column: column2,
|
|
$index
|
|
}) {
|
|
let i = $index + 1;
|
|
const index = column2.index;
|
|
if (isNumber2(index)) {
|
|
i = $index + index;
|
|
} else if (isFunction(index)) {
|
|
i = index($index);
|
|
}
|
|
return h("div", {}, [i]);
|
|
},
|
|
sortable: false
|
|
},
|
|
expand: {
|
|
renderHeader({ column: column2 }) {
|
|
return column2.label || "";
|
|
},
|
|
renderCell({
|
|
row,
|
|
store,
|
|
expanded
|
|
}) {
|
|
const { ns } = store;
|
|
const classes = [ns.e("expand-icon")];
|
|
if (expanded) {
|
|
classes.push(ns.em("expand-icon", "expanded"));
|
|
}
|
|
const callback = function(e) {
|
|
e.stopPropagation();
|
|
store.toggleRowExpansion(row);
|
|
};
|
|
return h("div", {
|
|
class: classes,
|
|
onClick: callback
|
|
}, {
|
|
default: () => {
|
|
return [
|
|
h(ElIcon, null, {
|
|
default: () => {
|
|
return [h(arrow_right_default)];
|
|
}
|
|
})
|
|
];
|
|
}
|
|
});
|
|
},
|
|
sortable: false,
|
|
resizable: false
|
|
}
|
|
};
|
|
function defaultRenderCell({
|
|
row,
|
|
column: column2,
|
|
$index
|
|
}) {
|
|
var _a2;
|
|
const property2 = column2.property;
|
|
const value = property2 && getProp(row, property2).value;
|
|
if (column2 && column2.formatter) {
|
|
return column2.formatter(row, column2, value, $index);
|
|
}
|
|
return ((_a2 = value == null ? void 0 : value.toString) == null ? void 0 : _a2.call(value)) || "";
|
|
}
|
|
function treeCellPrefix({
|
|
row,
|
|
treeNode,
|
|
store
|
|
}, createPlaceholder = false) {
|
|
const { ns } = store;
|
|
if (!treeNode) {
|
|
if (createPlaceholder) {
|
|
return [
|
|
h("span", {
|
|
class: ns.e("placeholder")
|
|
})
|
|
];
|
|
}
|
|
return null;
|
|
}
|
|
const ele = [];
|
|
const callback = function(e) {
|
|
e.stopPropagation();
|
|
if (treeNode.loading) {
|
|
return;
|
|
}
|
|
store.loadOrToggle(row);
|
|
};
|
|
if (treeNode.indent) {
|
|
ele.push(h("span", {
|
|
class: ns.e("indent"),
|
|
style: { "padding-left": `${treeNode.indent}px` }
|
|
}));
|
|
}
|
|
if (isBoolean2(treeNode.expanded) && !treeNode.noLazyChildren) {
|
|
const expandClasses = [
|
|
ns.e("expand-icon"),
|
|
treeNode.expanded ? ns.em("expand-icon", "expanded") : ""
|
|
];
|
|
let icon = arrow_right_default;
|
|
if (treeNode.loading) {
|
|
icon = loading_default;
|
|
}
|
|
ele.push(h("div", {
|
|
class: expandClasses,
|
|
onClick: callback
|
|
}, {
|
|
default: () => {
|
|
return [
|
|
h(ElIcon, { class: { [ns.is("loading")]: treeNode.loading } }, {
|
|
default: () => [h(icon)]
|
|
})
|
|
];
|
|
}
|
|
}));
|
|
} else {
|
|
ele.push(h("span", {
|
|
class: ns.e("placeholder")
|
|
}));
|
|
}
|
|
return ele;
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-column/watcher-helper.mjs
|
|
function getAllAliases(props2, aliases) {
|
|
return props2.reduce((prev, cur) => {
|
|
prev[cur] = cur;
|
|
return prev;
|
|
}, aliases);
|
|
}
|
|
function useWatcher2(owner, props_) {
|
|
const instance = getCurrentInstance();
|
|
const registerComplexWatchers = () => {
|
|
const props2 = ["fixed"];
|
|
const aliases = {
|
|
realWidth: "width",
|
|
realMinWidth: "minWidth"
|
|
};
|
|
const allAliases = getAllAliases(props2, aliases);
|
|
Object.keys(allAliases).forEach((key) => {
|
|
const columnKey = aliases[key];
|
|
if (hasOwn(props_, columnKey)) {
|
|
watch(() => props_[columnKey], (newVal) => {
|
|
let value = newVal;
|
|
if (columnKey === "width" && key === "realWidth") {
|
|
value = parseWidth(newVal);
|
|
}
|
|
if (columnKey === "minWidth" && key === "realMinWidth") {
|
|
value = parseMinWidth(newVal);
|
|
}
|
|
instance.columnConfig.value[columnKey] = value;
|
|
instance.columnConfig.value[key] = value;
|
|
const updateColumns = columnKey === "fixed";
|
|
owner.value.store.scheduleLayout(updateColumns);
|
|
});
|
|
}
|
|
});
|
|
};
|
|
const registerNormalWatchers = () => {
|
|
const props2 = [
|
|
"label",
|
|
"filters",
|
|
"filterMultiple",
|
|
"filteredValue",
|
|
"sortable",
|
|
"index",
|
|
"formatter",
|
|
"className",
|
|
"labelClassName",
|
|
"filterClassName",
|
|
"showOverflowTooltip",
|
|
"tooltipFormatter"
|
|
];
|
|
const aliases = {
|
|
property: "prop",
|
|
align: "realAlign",
|
|
headerAlign: "realHeaderAlign"
|
|
};
|
|
const allAliases = getAllAliases(props2, aliases);
|
|
Object.keys(allAliases).forEach((key) => {
|
|
const columnKey = aliases[key];
|
|
if (hasOwn(props_, columnKey)) {
|
|
watch(() => props_[columnKey], (newVal) => {
|
|
instance.columnConfig.value[key] = newVal;
|
|
});
|
|
}
|
|
});
|
|
};
|
|
return {
|
|
registerComplexWatchers,
|
|
registerNormalWatchers
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-column/render-helper.mjs
|
|
function useRender2(props2, slots, owner) {
|
|
const instance = getCurrentInstance();
|
|
const columnId = ref("");
|
|
const isSubColumn = ref(false);
|
|
const realAlign = ref();
|
|
const realHeaderAlign = ref();
|
|
const ns = useNamespace("table");
|
|
watchEffect(() => {
|
|
realAlign.value = props2.align ? `is-${props2.align}` : null;
|
|
realAlign.value;
|
|
});
|
|
watchEffect(() => {
|
|
realHeaderAlign.value = props2.headerAlign ? `is-${props2.headerAlign}` : realAlign.value;
|
|
realHeaderAlign.value;
|
|
});
|
|
const columnOrTableParent = computed(() => {
|
|
let parent2 = instance.vnode.vParent || instance.parent;
|
|
while (parent2 && !parent2.tableId && !parent2.columnId) {
|
|
parent2 = parent2.vnode.vParent || parent2.parent;
|
|
}
|
|
return parent2;
|
|
});
|
|
const hasTreeColumn = computed(() => {
|
|
const { store } = instance.parent;
|
|
if (!store)
|
|
return false;
|
|
const { treeData } = store.states;
|
|
const treeDataValue = treeData.value;
|
|
return treeDataValue && Object.keys(treeDataValue).length > 0;
|
|
});
|
|
const realWidth = ref(parseWidth(props2.width));
|
|
const realMinWidth = ref(parseMinWidth(props2.minWidth));
|
|
const setColumnWidth = (column2) => {
|
|
if (realWidth.value)
|
|
column2.width = realWidth.value;
|
|
if (realMinWidth.value) {
|
|
column2.minWidth = realMinWidth.value;
|
|
}
|
|
if (!realWidth.value && realMinWidth.value) {
|
|
column2.width = void 0;
|
|
}
|
|
if (!column2.minWidth) {
|
|
column2.minWidth = 80;
|
|
}
|
|
column2.realWidth = Number(isUndefined2(column2.width) ? column2.minWidth : column2.width);
|
|
return column2;
|
|
};
|
|
const setColumnForcedProps = (column2) => {
|
|
const type4 = column2.type;
|
|
const source = cellForced[type4] || {};
|
|
Object.keys(source).forEach((prop) => {
|
|
const value = source[prop];
|
|
if (prop !== "className" && !isUndefined2(value)) {
|
|
column2[prop] = value;
|
|
}
|
|
});
|
|
const className = getDefaultClassName(type4);
|
|
if (className) {
|
|
const forceClass = `${unref(ns.namespace)}-${className}`;
|
|
column2.className = column2.className ? `${column2.className} ${forceClass}` : forceClass;
|
|
}
|
|
return column2;
|
|
};
|
|
const checkSubColumn = (children) => {
|
|
if (isArray(children)) {
|
|
children.forEach((child) => check(child));
|
|
} else {
|
|
check(children);
|
|
}
|
|
function check(item) {
|
|
var _a2;
|
|
if (((_a2 = item == null ? void 0 : item.type) == null ? void 0 : _a2.name) === "ElTableColumn") {
|
|
item.vParent = instance;
|
|
}
|
|
}
|
|
};
|
|
const setColumnRenders = (column2) => {
|
|
if (props2.renderHeader) {
|
|
debugWarn("TableColumn", "Comparing to render-header, scoped-slot header is easier to use. We recommend users to use scoped-slot header.");
|
|
} else if (column2.type !== "selection") {
|
|
column2.renderHeader = (scope) => {
|
|
instance.columnConfig.value["label"];
|
|
return renderSlot(slots, "header", scope, () => [column2.label]);
|
|
};
|
|
}
|
|
if (slots["filter-icon"]) {
|
|
column2.renderFilterIcon = (scope) => {
|
|
return renderSlot(slots, "filter-icon", scope);
|
|
};
|
|
}
|
|
let originRenderCell = column2.renderCell;
|
|
if (column2.type === "expand") {
|
|
column2.renderCell = (data) => h("div", {
|
|
class: "cell"
|
|
}, [originRenderCell(data)]);
|
|
owner.value.renderExpanded = (data) => {
|
|
return slots.default ? slots.default(data) : slots.default;
|
|
};
|
|
} else {
|
|
originRenderCell = originRenderCell || defaultRenderCell;
|
|
column2.renderCell = (data) => {
|
|
let children = null;
|
|
if (slots.default) {
|
|
const vnodes = slots.default(data);
|
|
children = vnodes.some((v2) => v2.type !== Comment) ? vnodes : originRenderCell(data);
|
|
} else {
|
|
children = originRenderCell(data);
|
|
}
|
|
const { columns: columns2 } = owner.value.store.states;
|
|
const firstUserColumnIndex = columns2.value.findIndex((item) => item.type === "default");
|
|
const shouldCreatePlaceholder = hasTreeColumn.value && data.cellIndex === firstUserColumnIndex;
|
|
const prefix = treeCellPrefix(data, shouldCreatePlaceholder);
|
|
const props22 = {
|
|
class: "cell",
|
|
style: {}
|
|
};
|
|
if (column2.showOverflowTooltip) {
|
|
props22.class = `${props22.class} ${unref(ns.namespace)}-tooltip`;
|
|
props22.style = {
|
|
width: `${(data.column.realWidth || Number(data.column.width)) - 1}px`
|
|
};
|
|
}
|
|
checkSubColumn(children);
|
|
return h("div", props22, [prefix, children]);
|
|
};
|
|
}
|
|
return column2;
|
|
};
|
|
const getPropsData = (...propsKey) => {
|
|
return propsKey.reduce((prev, cur) => {
|
|
if (isArray(cur)) {
|
|
cur.forEach((key) => {
|
|
prev[key] = props2[key];
|
|
});
|
|
}
|
|
return prev;
|
|
}, {});
|
|
};
|
|
const getColumnElIndex = (children, child) => {
|
|
return Array.prototype.indexOf.call(children, child);
|
|
};
|
|
const updateColumnOrder = () => {
|
|
owner.value.store.commit("updateColumnOrder", instance.columnConfig.value);
|
|
};
|
|
return {
|
|
columnId,
|
|
realAlign,
|
|
isSubColumn,
|
|
realHeaderAlign,
|
|
columnOrTableParent,
|
|
setColumnWidth,
|
|
setColumnForcedProps,
|
|
setColumnRenders,
|
|
getPropsData,
|
|
getColumnElIndex,
|
|
updateColumnOrder
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-column/defaults.mjs
|
|
var defaultProps4 = {
|
|
type: {
|
|
type: String,
|
|
default: "default"
|
|
},
|
|
label: String,
|
|
className: String,
|
|
labelClassName: String,
|
|
property: String,
|
|
prop: String,
|
|
width: {
|
|
type: [String, Number],
|
|
default: ""
|
|
},
|
|
minWidth: {
|
|
type: [String, Number],
|
|
default: ""
|
|
},
|
|
renderHeader: Function,
|
|
sortable: {
|
|
type: [Boolean, String],
|
|
default: false
|
|
},
|
|
sortMethod: Function,
|
|
sortBy: [String, Function, Array],
|
|
resizable: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
columnKey: String,
|
|
align: String,
|
|
headerAlign: String,
|
|
showOverflowTooltip: {
|
|
type: [Boolean, Object],
|
|
default: void 0
|
|
},
|
|
tooltipFormatter: Function,
|
|
fixed: [Boolean, String],
|
|
formatter: Function,
|
|
selectable: Function,
|
|
reserveSelection: Boolean,
|
|
filterMethod: Function,
|
|
filteredValue: Array,
|
|
filters: Array,
|
|
filterPlacement: String,
|
|
filterMultiple: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
filterClassName: String,
|
|
index: [Number, Function],
|
|
sortOrders: {
|
|
type: Array,
|
|
default: () => {
|
|
return ["ascending", "descending", null];
|
|
},
|
|
validator: (val) => {
|
|
return val.every((order) => ["ascending", "descending", null].includes(order));
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-column/index.mjs
|
|
var columnIdSeed = 1;
|
|
var ElTableColumn = defineComponent({
|
|
name: "ElTableColumn",
|
|
components: {
|
|
ElCheckbox
|
|
},
|
|
props: defaultProps4,
|
|
setup(props2, { slots }) {
|
|
const instance = getCurrentInstance();
|
|
const columnConfig = ref({});
|
|
const owner = computed(() => {
|
|
let parent22 = instance.parent;
|
|
while (parent22 && !parent22.tableId) {
|
|
parent22 = parent22.parent;
|
|
}
|
|
return parent22;
|
|
});
|
|
const { registerNormalWatchers, registerComplexWatchers } = useWatcher2(owner, props2);
|
|
const {
|
|
columnId,
|
|
isSubColumn,
|
|
realHeaderAlign,
|
|
columnOrTableParent,
|
|
setColumnWidth,
|
|
setColumnForcedProps,
|
|
setColumnRenders,
|
|
getPropsData,
|
|
getColumnElIndex,
|
|
realAlign,
|
|
updateColumnOrder
|
|
} = useRender2(props2, slots, owner);
|
|
const parent2 = columnOrTableParent.value;
|
|
columnId.value = `${parent2.tableId || parent2.columnId}_column_${columnIdSeed++}`;
|
|
onBeforeMount(() => {
|
|
isSubColumn.value = owner.value !== parent2;
|
|
const type4 = props2.type || "default";
|
|
const sortable = props2.sortable === "" ? true : props2.sortable;
|
|
const showOverflowTooltip = type4 === "selection" ? false : isUndefined2(props2.showOverflowTooltip) ? parent2.props.showOverflowTooltip : props2.showOverflowTooltip;
|
|
const tooltipFormatter = isUndefined2(props2.tooltipFormatter) ? parent2.props.tooltipFormatter : props2.tooltipFormatter;
|
|
const defaults2 = {
|
|
...cellStarts[type4],
|
|
id: columnId.value,
|
|
type: type4,
|
|
property: props2.prop || props2.property,
|
|
align: realAlign,
|
|
headerAlign: realHeaderAlign,
|
|
showOverflowTooltip,
|
|
tooltipFormatter,
|
|
filterable: props2.filters || props2.filterMethod,
|
|
filteredValue: [],
|
|
filterPlacement: "",
|
|
filterClassName: "",
|
|
isColumnGroup: false,
|
|
isSubColumn: false,
|
|
filterOpened: false,
|
|
sortable,
|
|
index: props2.index,
|
|
rawColumnKey: instance.vnode.key
|
|
};
|
|
const basicProps = [
|
|
"columnKey",
|
|
"label",
|
|
"className",
|
|
"labelClassName",
|
|
"type",
|
|
"renderHeader",
|
|
"formatter",
|
|
"fixed",
|
|
"resizable"
|
|
];
|
|
const sortProps = ["sortMethod", "sortBy", "sortOrders"];
|
|
const selectProps = ["selectable", "reserveSelection"];
|
|
const filterProps = [
|
|
"filterMethod",
|
|
"filters",
|
|
"filterMultiple",
|
|
"filterOpened",
|
|
"filteredValue",
|
|
"filterPlacement",
|
|
"filterClassName"
|
|
];
|
|
let column2 = getPropsData(basicProps, sortProps, selectProps, filterProps);
|
|
column2 = mergeOptions(defaults2, column2);
|
|
const chains = compose(setColumnRenders, setColumnWidth, setColumnForcedProps);
|
|
column2 = chains(column2);
|
|
columnConfig.value = column2;
|
|
registerNormalWatchers();
|
|
registerComplexWatchers();
|
|
});
|
|
onMounted(() => {
|
|
var _a2;
|
|
const parent22 = columnOrTableParent.value;
|
|
const children = isSubColumn.value ? parent22.vnode.el.children : (_a2 = parent22.refs.hiddenColumns) == null ? void 0 : _a2.children;
|
|
const getColumnIndex = () => getColumnElIndex(children || [], instance.vnode.el);
|
|
columnConfig.value.getColumnIndex = getColumnIndex;
|
|
const columnIndex = getColumnIndex();
|
|
columnIndex > -1 && owner.value.store.commit("insertColumn", columnConfig.value, isSubColumn.value ? parent22.columnConfig.value : null, updateColumnOrder);
|
|
});
|
|
onBeforeUnmount(() => {
|
|
const getColumnIndex = columnConfig.value.getColumnIndex;
|
|
const columnIndex = getColumnIndex ? getColumnIndex() : -1;
|
|
columnIndex > -1 && owner.value.store.commit("removeColumn", columnConfig.value, isSubColumn.value ? parent2.columnConfig.value : null, updateColumnOrder);
|
|
});
|
|
instance.columnId = columnId.value;
|
|
instance.columnConfig = columnConfig;
|
|
return;
|
|
},
|
|
render() {
|
|
var _a2, _b, _c;
|
|
try {
|
|
const renderDefault = (_b = (_a2 = this.$slots).default) == null ? void 0 : _b.call(_a2, {
|
|
row: {},
|
|
column: {},
|
|
$index: -1
|
|
});
|
|
const children = [];
|
|
if (isArray(renderDefault)) {
|
|
for (const childNode of renderDefault) {
|
|
if (((_c = childNode.type) == null ? void 0 : _c.name) === "ElTableColumn" || childNode.shapeFlag & 2) {
|
|
children.push(childNode);
|
|
} else if (childNode.type === Fragment && isArray(childNode.children)) {
|
|
childNode.children.forEach((vnode2) => {
|
|
if ((vnode2 == null ? void 0 : vnode2.patchFlag) !== 1024 && !isString(vnode2 == null ? void 0 : vnode2.children)) {
|
|
children.push(vnode2);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
const vnode = h("div", children);
|
|
return vnode;
|
|
} catch (e) {
|
|
return h("div", []);
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table/index.mjs
|
|
var ElTable = withInstall(Table, {
|
|
TableColumn: ElTableColumn
|
|
});
|
|
var ElTableColumn2 = withNoopInstall(ElTableColumn);
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/constants.mjs
|
|
var SortOrder = ((SortOrder2) => {
|
|
SortOrder2["ASC"] = "asc";
|
|
SortOrder2["DESC"] = "desc";
|
|
return SortOrder2;
|
|
})(SortOrder || {});
|
|
var Alignment = ((Alignment2) => {
|
|
Alignment2["CENTER"] = "center";
|
|
Alignment2["RIGHT"] = "right";
|
|
return Alignment2;
|
|
})(Alignment || {});
|
|
var FixedDir = ((FixedDir2) => {
|
|
FixedDir2["LEFT"] = "left";
|
|
FixedDir2["RIGHT"] = "right";
|
|
return FixedDir2;
|
|
})(FixedDir || {});
|
|
var oppositeOrderMap = {
|
|
["asc"]: "desc",
|
|
["desc"]: "asc"
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/private.mjs
|
|
var placeholderSign = Symbol("placeholder");
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/common.mjs
|
|
var classType = String;
|
|
var columns = {
|
|
type: definePropType(Array),
|
|
required: true
|
|
};
|
|
var column = {
|
|
type: definePropType(Object)
|
|
};
|
|
var fixedDataType = {
|
|
type: definePropType(Array)
|
|
};
|
|
var dataType = {
|
|
...fixedDataType,
|
|
required: true
|
|
};
|
|
var expandColumnKey = String;
|
|
var expandKeys = {
|
|
type: definePropType(Array),
|
|
default: () => mutable([])
|
|
};
|
|
var requiredNumber = {
|
|
type: Number,
|
|
required: true
|
|
};
|
|
var rowKey = {
|
|
type: definePropType([String, Number, Symbol]),
|
|
default: "id"
|
|
};
|
|
var styleType = {
|
|
type: definePropType(Object)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/row.mjs
|
|
var tableV2RowProps = buildProps({
|
|
class: String,
|
|
columns,
|
|
columnsStyles: {
|
|
type: definePropType(Object),
|
|
required: true
|
|
},
|
|
depth: Number,
|
|
expandColumnKey,
|
|
estimatedRowHeight: {
|
|
...virtualizedGridProps.estimatedRowHeight,
|
|
default: void 0
|
|
},
|
|
isScrolling: Boolean,
|
|
onRowExpand: {
|
|
type: definePropType(Function)
|
|
},
|
|
onRowHover: {
|
|
type: definePropType(Function)
|
|
},
|
|
onRowHeightChange: {
|
|
type: definePropType(Function)
|
|
},
|
|
rowData: {
|
|
type: definePropType(Object),
|
|
required: true
|
|
},
|
|
rowEventHandlers: {
|
|
type: definePropType(Object)
|
|
},
|
|
rowIndex: {
|
|
type: Number,
|
|
required: true
|
|
},
|
|
rowKey,
|
|
style: {
|
|
type: definePropType(Object)
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/header.mjs
|
|
var requiredNumberType = {
|
|
type: Number,
|
|
required: true
|
|
};
|
|
var tableV2HeaderProps = buildProps({
|
|
class: String,
|
|
columns,
|
|
fixedHeaderData: {
|
|
type: definePropType(Array)
|
|
},
|
|
headerData: {
|
|
type: definePropType(Array),
|
|
required: true
|
|
},
|
|
headerHeight: {
|
|
type: definePropType([Number, Array]),
|
|
default: 50
|
|
},
|
|
rowWidth: requiredNumberType,
|
|
rowHeight: {
|
|
type: Number,
|
|
default: 50
|
|
},
|
|
height: requiredNumberType,
|
|
width: requiredNumberType
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/grid.mjs
|
|
var tableV2GridProps = buildProps({
|
|
columns,
|
|
data: dataType,
|
|
fixedData: fixedDataType,
|
|
estimatedRowHeight: tableV2RowProps.estimatedRowHeight,
|
|
width: requiredNumber,
|
|
height: requiredNumber,
|
|
headerWidth: requiredNumber,
|
|
headerHeight: tableV2HeaderProps.headerHeight,
|
|
bodyWidth: requiredNumber,
|
|
rowHeight: requiredNumber,
|
|
cache: virtualizedListProps.cache,
|
|
useIsScrolling: Boolean,
|
|
scrollbarAlwaysOn: virtualizedGridProps.scrollbarAlwaysOn,
|
|
scrollbarStartGap: virtualizedGridProps.scrollbarStartGap,
|
|
scrollbarEndGap: virtualizedGridProps.scrollbarEndGap,
|
|
class: classType,
|
|
style: styleType,
|
|
containerStyle: styleType,
|
|
getRowHeight: {
|
|
type: definePropType(Function),
|
|
required: true
|
|
},
|
|
rowKey: tableV2RowProps.rowKey,
|
|
onRowsRendered: {
|
|
type: definePropType(Function)
|
|
},
|
|
onScroll: {
|
|
type: definePropType(Function)
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/table.mjs
|
|
var tableV2Props = buildProps({
|
|
cache: tableV2GridProps.cache,
|
|
estimatedRowHeight: tableV2RowProps.estimatedRowHeight,
|
|
rowKey,
|
|
headerClass: {
|
|
type: definePropType([
|
|
String,
|
|
Function
|
|
])
|
|
},
|
|
headerProps: {
|
|
type: definePropType([
|
|
Object,
|
|
Function
|
|
])
|
|
},
|
|
headerCellProps: {
|
|
type: definePropType([
|
|
Object,
|
|
Function
|
|
])
|
|
},
|
|
headerHeight: tableV2HeaderProps.headerHeight,
|
|
footerHeight: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
rowClass: {
|
|
type: definePropType([String, Function])
|
|
},
|
|
rowProps: {
|
|
type: definePropType([Object, Function])
|
|
},
|
|
rowHeight: {
|
|
type: Number,
|
|
default: 50
|
|
},
|
|
cellProps: {
|
|
type: definePropType([
|
|
Object,
|
|
Function
|
|
])
|
|
},
|
|
columns,
|
|
data: dataType,
|
|
dataGetter: {
|
|
type: definePropType(Function)
|
|
},
|
|
fixedData: fixedDataType,
|
|
expandColumnKey: tableV2RowProps.expandColumnKey,
|
|
expandedRowKeys: expandKeys,
|
|
defaultExpandedRowKeys: expandKeys,
|
|
class: classType,
|
|
fixed: Boolean,
|
|
style: {
|
|
type: definePropType(Object)
|
|
},
|
|
width: requiredNumber,
|
|
height: requiredNumber,
|
|
maxHeight: Number,
|
|
useIsScrolling: Boolean,
|
|
indentSize: {
|
|
type: Number,
|
|
default: 12
|
|
},
|
|
iconSize: {
|
|
type: Number,
|
|
default: 12
|
|
},
|
|
hScrollbarSize: virtualizedGridProps.hScrollbarSize,
|
|
vScrollbarSize: virtualizedGridProps.vScrollbarSize,
|
|
scrollbarAlwaysOn: virtualizedScrollbarProps.alwaysOn,
|
|
sortBy: {
|
|
type: definePropType(Object),
|
|
default: () => ({})
|
|
},
|
|
sortState: {
|
|
type: definePropType(Object),
|
|
default: void 0
|
|
},
|
|
onColumnSort: {
|
|
type: definePropType(Function)
|
|
},
|
|
onExpandedRowsChange: {
|
|
type: definePropType(Function)
|
|
},
|
|
onEndReached: {
|
|
type: definePropType(Function)
|
|
},
|
|
onRowExpand: tableV2RowProps.onRowExpand,
|
|
onScroll: tableV2GridProps.onScroll,
|
|
onRowsRendered: tableV2GridProps.onRowsRendered,
|
|
rowEventHandlers: tableV2RowProps.rowEventHandlers
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/virtual-list/src/hooks/use-grid-wheel.mjs
|
|
var useGridWheel = ({ atXEndEdge, atXStartEdge, atYEndEdge, atYStartEdge }, onWheelDelta) => {
|
|
let frameHandle = null;
|
|
let xOffset = 0;
|
|
let yOffset = 0;
|
|
const hasReachedEdge = (x2, y) => {
|
|
const xEdgeReached = x2 <= 0 && atXStartEdge.value || x2 >= 0 && atXEndEdge.value;
|
|
const yEdgeReached = y <= 0 && atYStartEdge.value || y >= 0 && atYEndEdge.value;
|
|
return xEdgeReached && yEdgeReached;
|
|
};
|
|
const onWheel = (e) => {
|
|
cAF(frameHandle);
|
|
let x2 = e.deltaX;
|
|
let y = e.deltaY;
|
|
if (Math.abs(x2) > Math.abs(y)) {
|
|
y = 0;
|
|
} else {
|
|
x2 = 0;
|
|
}
|
|
if (e.shiftKey && y !== 0) {
|
|
x2 = y;
|
|
y = 0;
|
|
}
|
|
if (hasReachedEdge(xOffset, yOffset) && hasReachedEdge(xOffset + x2, yOffset + y))
|
|
return;
|
|
xOffset += x2;
|
|
yOffset += y;
|
|
e.preventDefault();
|
|
frameHandle = rAF(() => {
|
|
onWheelDelta(xOffset, yOffset);
|
|
xOffset = 0;
|
|
yOffset = 0;
|
|
});
|
|
};
|
|
return {
|
|
hasReachedEdge,
|
|
onWheel
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/virtual-list/src/builders/build-grid.mjs
|
|
var createGrid = ({
|
|
name,
|
|
clearCache,
|
|
getColumnPosition,
|
|
getColumnStartIndexForOffset,
|
|
getColumnStopIndexForStartIndex,
|
|
getEstimatedTotalHeight: getEstimatedTotalHeight2,
|
|
getEstimatedTotalWidth: getEstimatedTotalWidth2,
|
|
getColumnOffset,
|
|
getRowOffset,
|
|
getRowPosition,
|
|
getRowStartIndexForOffset,
|
|
getRowStopIndexForStartIndex,
|
|
initCache,
|
|
injectToInstance,
|
|
validateProps
|
|
}) => {
|
|
return defineComponent({
|
|
name: name != null ? name : "ElVirtualList",
|
|
props: virtualizedGridProps,
|
|
emits: [ITEM_RENDER_EVT, SCROLL_EVT],
|
|
setup(props2, { emit, expose, slots }) {
|
|
const ns = useNamespace("vl");
|
|
validateProps(props2);
|
|
const instance = getCurrentInstance();
|
|
const cache2 = ref(initCache(props2, instance));
|
|
injectToInstance == null ? void 0 : injectToInstance(instance, cache2);
|
|
const windowRef = ref();
|
|
const hScrollbar = ref();
|
|
const vScrollbar = ref();
|
|
const innerRef = ref(null);
|
|
const states = ref({
|
|
isScrolling: false,
|
|
scrollLeft: isNumber2(props2.initScrollLeft) ? props2.initScrollLeft : 0,
|
|
scrollTop: isNumber2(props2.initScrollTop) ? props2.initScrollTop : 0,
|
|
updateRequested: false,
|
|
xAxisScrollDir: FORWARD,
|
|
yAxisScrollDir: FORWARD
|
|
});
|
|
const getItemStyleCache = useCache();
|
|
const parsedHeight = computed(() => Number.parseInt(`${props2.height}`, 10));
|
|
const parsedWidth = computed(() => Number.parseInt(`${props2.width}`, 10));
|
|
const columnsToRender = computed(() => {
|
|
const { totalColumn, totalRow, columnCache } = props2;
|
|
const { isScrolling, xAxisScrollDir, scrollLeft } = unref(states);
|
|
if (totalColumn === 0 || totalRow === 0) {
|
|
return [0, 0, 0, 0];
|
|
}
|
|
const startIndex = getColumnStartIndexForOffset(props2, scrollLeft, unref(cache2));
|
|
const stopIndex = getColumnStopIndexForStartIndex(props2, startIndex, scrollLeft, unref(cache2));
|
|
const cacheBackward = !isScrolling || xAxisScrollDir === BACKWARD ? Math.max(1, columnCache) : 1;
|
|
const cacheForward = !isScrolling || xAxisScrollDir === FORWARD ? Math.max(1, columnCache) : 1;
|
|
return [
|
|
Math.max(0, startIndex - cacheBackward),
|
|
Math.max(0, Math.min(totalColumn - 1, stopIndex + cacheForward)),
|
|
startIndex,
|
|
stopIndex
|
|
];
|
|
});
|
|
const rowsToRender = computed(() => {
|
|
const { totalColumn, totalRow, rowCache } = props2;
|
|
const { isScrolling, yAxisScrollDir, scrollTop } = unref(states);
|
|
if (totalColumn === 0 || totalRow === 0) {
|
|
return [0, 0, 0, 0];
|
|
}
|
|
const startIndex = getRowStartIndexForOffset(props2, scrollTop, unref(cache2));
|
|
const stopIndex = getRowStopIndexForStartIndex(props2, startIndex, scrollTop, unref(cache2));
|
|
const cacheBackward = !isScrolling || yAxisScrollDir === BACKWARD ? Math.max(1, rowCache) : 1;
|
|
const cacheForward = !isScrolling || yAxisScrollDir === FORWARD ? Math.max(1, rowCache) : 1;
|
|
return [
|
|
Math.max(0, startIndex - cacheBackward),
|
|
Math.max(0, Math.min(totalRow - 1, stopIndex + cacheForward)),
|
|
startIndex,
|
|
stopIndex
|
|
];
|
|
});
|
|
const estimatedTotalHeight = computed(() => getEstimatedTotalHeight2(props2, unref(cache2)));
|
|
const estimatedTotalWidth = computed(() => getEstimatedTotalWidth2(props2, unref(cache2)));
|
|
const windowStyle = computed(() => {
|
|
var _a2;
|
|
return [
|
|
{
|
|
position: "relative",
|
|
overflow: "hidden",
|
|
WebkitOverflowScrolling: "touch",
|
|
willChange: "transform"
|
|
},
|
|
{
|
|
direction: props2.direction,
|
|
height: isNumber2(props2.height) ? `${props2.height}px` : props2.height,
|
|
width: isNumber2(props2.width) ? `${props2.width}px` : props2.width
|
|
},
|
|
(_a2 = props2.style) != null ? _a2 : {}
|
|
];
|
|
});
|
|
const innerStyle = computed(() => {
|
|
const width = `${unref(estimatedTotalWidth)}px`;
|
|
const height = `${unref(estimatedTotalHeight)}px`;
|
|
return {
|
|
height,
|
|
pointerEvents: unref(states).isScrolling ? "none" : void 0,
|
|
width
|
|
};
|
|
});
|
|
const emitEvents = () => {
|
|
const { totalColumn, totalRow } = props2;
|
|
if (totalColumn > 0 && totalRow > 0) {
|
|
const [
|
|
columnCacheStart,
|
|
columnCacheEnd,
|
|
columnVisibleStart,
|
|
columnVisibleEnd
|
|
] = unref(columnsToRender);
|
|
const [rowCacheStart, rowCacheEnd, rowVisibleStart, rowVisibleEnd] = unref(rowsToRender);
|
|
emit(ITEM_RENDER_EVT, {
|
|
columnCacheStart,
|
|
columnCacheEnd,
|
|
rowCacheStart,
|
|
rowCacheEnd,
|
|
columnVisibleStart,
|
|
columnVisibleEnd,
|
|
rowVisibleStart,
|
|
rowVisibleEnd
|
|
});
|
|
}
|
|
const {
|
|
scrollLeft,
|
|
scrollTop,
|
|
updateRequested,
|
|
xAxisScrollDir,
|
|
yAxisScrollDir
|
|
} = unref(states);
|
|
emit(SCROLL_EVT, {
|
|
xAxisScrollDir,
|
|
scrollLeft,
|
|
yAxisScrollDir,
|
|
scrollTop,
|
|
updateRequested
|
|
});
|
|
};
|
|
const onScroll = (e) => {
|
|
const {
|
|
clientHeight,
|
|
clientWidth,
|
|
scrollHeight,
|
|
scrollLeft,
|
|
scrollTop,
|
|
scrollWidth
|
|
} = e.currentTarget;
|
|
const _states = unref(states);
|
|
if (_states.scrollTop === scrollTop && _states.scrollLeft === scrollLeft) {
|
|
return;
|
|
}
|
|
let _scrollLeft = scrollLeft;
|
|
if (isRTL(props2.direction)) {
|
|
switch (getRTLOffsetType()) {
|
|
case RTL_OFFSET_NAG:
|
|
_scrollLeft = -scrollLeft;
|
|
break;
|
|
case RTL_OFFSET_POS_DESC:
|
|
_scrollLeft = scrollWidth - clientWidth - scrollLeft;
|
|
break;
|
|
}
|
|
}
|
|
states.value = {
|
|
..._states,
|
|
isScrolling: true,
|
|
scrollLeft: _scrollLeft,
|
|
scrollTop: Math.max(0, Math.min(scrollTop, scrollHeight - clientHeight)),
|
|
updateRequested: true,
|
|
xAxisScrollDir: getScrollDir(_states.scrollLeft, _scrollLeft),
|
|
yAxisScrollDir: getScrollDir(_states.scrollTop, scrollTop)
|
|
};
|
|
nextTick(() => resetIsScrolling());
|
|
onUpdated2();
|
|
emitEvents();
|
|
};
|
|
const onVerticalScroll = (distance, totalSteps) => {
|
|
const height = unref(parsedHeight);
|
|
const offset3 = (estimatedTotalHeight.value - height) / totalSteps * distance;
|
|
scrollTo({
|
|
scrollTop: Math.min(estimatedTotalHeight.value - height, offset3)
|
|
});
|
|
};
|
|
const onHorizontalScroll = (distance, totalSteps) => {
|
|
const width = unref(parsedWidth);
|
|
const offset3 = (estimatedTotalWidth.value - width) / totalSteps * distance;
|
|
scrollTo({
|
|
scrollLeft: Math.min(estimatedTotalWidth.value - width, offset3)
|
|
});
|
|
};
|
|
const { onWheel } = useGridWheel({
|
|
atXStartEdge: computed(() => states.value.scrollLeft <= 0),
|
|
atXEndEdge: computed(() => states.value.scrollLeft >= estimatedTotalWidth.value - unref(parsedWidth)),
|
|
atYStartEdge: computed(() => states.value.scrollTop <= 0),
|
|
atYEndEdge: computed(() => states.value.scrollTop >= estimatedTotalHeight.value - unref(parsedHeight))
|
|
}, (x2, y) => {
|
|
var _a2, _b, _c, _d;
|
|
(_b = (_a2 = hScrollbar.value) == null ? void 0 : _a2.onMouseUp) == null ? void 0 : _b.call(_a2);
|
|
(_d = (_c = vScrollbar.value) == null ? void 0 : _c.onMouseUp) == null ? void 0 : _d.call(_c);
|
|
const width = unref(parsedWidth);
|
|
const height = unref(parsedHeight);
|
|
scrollTo({
|
|
scrollLeft: Math.min(states.value.scrollLeft + x2, estimatedTotalWidth.value - width),
|
|
scrollTop: Math.min(states.value.scrollTop + y, estimatedTotalHeight.value - height)
|
|
});
|
|
});
|
|
useEventListener(windowRef, "wheel", onWheel, {
|
|
passive: false
|
|
});
|
|
const scrollTo = ({
|
|
scrollLeft = states.value.scrollLeft,
|
|
scrollTop = states.value.scrollTop
|
|
}) => {
|
|
scrollLeft = Math.max(scrollLeft, 0);
|
|
scrollTop = Math.max(scrollTop, 0);
|
|
const _states = unref(states);
|
|
if (scrollTop === _states.scrollTop && scrollLeft === _states.scrollLeft) {
|
|
return;
|
|
}
|
|
states.value = {
|
|
..._states,
|
|
xAxisScrollDir: getScrollDir(_states.scrollLeft, scrollLeft),
|
|
yAxisScrollDir: getScrollDir(_states.scrollTop, scrollTop),
|
|
scrollLeft,
|
|
scrollTop,
|
|
updateRequested: true
|
|
};
|
|
nextTick(() => resetIsScrolling());
|
|
onUpdated2();
|
|
emitEvents();
|
|
};
|
|
const scrollToItem = (rowIndex = 0, columnIdx = 0, alignment = AUTO_ALIGNMENT) => {
|
|
const _states = unref(states);
|
|
columnIdx = Math.max(0, Math.min(columnIdx, props2.totalColumn - 1));
|
|
rowIndex = Math.max(0, Math.min(rowIndex, props2.totalRow - 1));
|
|
const scrollBarWidth2 = getScrollBarWidth(ns.namespace.value);
|
|
const _cache = unref(cache2);
|
|
const estimatedHeight = getEstimatedTotalHeight2(props2, _cache);
|
|
const estimatedWidth = getEstimatedTotalWidth2(props2, _cache);
|
|
scrollTo({
|
|
scrollLeft: getColumnOffset(props2, columnIdx, alignment, _states.scrollLeft, _cache, estimatedWidth > props2.width ? scrollBarWidth2 : 0),
|
|
scrollTop: getRowOffset(props2, rowIndex, alignment, _states.scrollTop, _cache, estimatedHeight > props2.height ? scrollBarWidth2 : 0)
|
|
});
|
|
};
|
|
const getItemStyle = (rowIndex, columnIndex) => {
|
|
const { columnWidth, direction: direction2, rowHeight } = props2;
|
|
const itemStyleCache = getItemStyleCache.value(clearCache && columnWidth, clearCache && rowHeight, clearCache && direction2);
|
|
const key = `${rowIndex},${columnIndex}`;
|
|
if (hasOwn(itemStyleCache, key)) {
|
|
return itemStyleCache[key];
|
|
} else {
|
|
const [, left] = getColumnPosition(props2, columnIndex, unref(cache2));
|
|
const _cache = unref(cache2);
|
|
const rtl = isRTL(direction2);
|
|
const [height, top] = getRowPosition(props2, rowIndex, _cache);
|
|
const [width] = getColumnPosition(props2, columnIndex, _cache);
|
|
itemStyleCache[key] = {
|
|
position: "absolute",
|
|
left: rtl ? void 0 : `${left}px`,
|
|
right: rtl ? `${left}px` : void 0,
|
|
top: `${top}px`,
|
|
height: `${height}px`,
|
|
width: `${width}px`
|
|
};
|
|
return itemStyleCache[key];
|
|
}
|
|
};
|
|
const resetIsScrolling = () => {
|
|
states.value.isScrolling = false;
|
|
nextTick(() => {
|
|
getItemStyleCache.value(-1, null, null);
|
|
});
|
|
};
|
|
onMounted(() => {
|
|
if (!isClient)
|
|
return;
|
|
const { initScrollLeft, initScrollTop } = props2;
|
|
const windowElement = unref(windowRef);
|
|
if (windowElement) {
|
|
if (isNumber2(initScrollLeft)) {
|
|
windowElement.scrollLeft = initScrollLeft;
|
|
}
|
|
if (isNumber2(initScrollTop)) {
|
|
windowElement.scrollTop = initScrollTop;
|
|
}
|
|
}
|
|
emitEvents();
|
|
});
|
|
const onUpdated2 = () => {
|
|
const { direction: direction2 } = props2;
|
|
const { scrollLeft, scrollTop, updateRequested } = unref(states);
|
|
const windowElement = unref(windowRef);
|
|
if (updateRequested && windowElement) {
|
|
if (direction2 === RTL) {
|
|
switch (getRTLOffsetType()) {
|
|
case RTL_OFFSET_NAG: {
|
|
windowElement.scrollLeft = -scrollLeft;
|
|
break;
|
|
}
|
|
case RTL_OFFSET_POS_ASC: {
|
|
windowElement.scrollLeft = scrollLeft;
|
|
break;
|
|
}
|
|
default: {
|
|
const { clientWidth, scrollWidth } = windowElement;
|
|
windowElement.scrollLeft = scrollWidth - clientWidth - scrollLeft;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
windowElement.scrollLeft = Math.max(0, scrollLeft);
|
|
}
|
|
windowElement.scrollTop = Math.max(0, scrollTop);
|
|
}
|
|
};
|
|
const { resetAfterColumnIndex, resetAfterRowIndex, resetAfter } = instance.proxy;
|
|
expose({
|
|
windowRef,
|
|
innerRef,
|
|
getItemStyleCache,
|
|
scrollTo,
|
|
scrollToItem,
|
|
states,
|
|
resetAfterColumnIndex,
|
|
resetAfterRowIndex,
|
|
resetAfter
|
|
});
|
|
const renderScrollbars = () => {
|
|
const {
|
|
scrollbarAlwaysOn,
|
|
scrollbarStartGap,
|
|
scrollbarEndGap,
|
|
totalColumn,
|
|
totalRow
|
|
} = props2;
|
|
const width = unref(parsedWidth);
|
|
const height = unref(parsedHeight);
|
|
const estimatedWidth = unref(estimatedTotalWidth);
|
|
const estimatedHeight = unref(estimatedTotalHeight);
|
|
const { scrollLeft, scrollTop } = unref(states);
|
|
const horizontalScrollbar = h(ScrollBar, {
|
|
ref: hScrollbar,
|
|
alwaysOn: scrollbarAlwaysOn,
|
|
startGap: scrollbarStartGap,
|
|
endGap: scrollbarEndGap,
|
|
class: ns.e("horizontal"),
|
|
clientSize: width,
|
|
layout: "horizontal",
|
|
onScroll: onHorizontalScroll,
|
|
ratio: width * 100 / estimatedWidth,
|
|
scrollFrom: scrollLeft / (estimatedWidth - width),
|
|
total: totalRow,
|
|
visible: true
|
|
});
|
|
const verticalScrollbar = h(ScrollBar, {
|
|
ref: vScrollbar,
|
|
alwaysOn: scrollbarAlwaysOn,
|
|
startGap: scrollbarStartGap,
|
|
endGap: scrollbarEndGap,
|
|
class: ns.e("vertical"),
|
|
clientSize: height,
|
|
layout: "vertical",
|
|
onScroll: onVerticalScroll,
|
|
ratio: height * 100 / estimatedHeight,
|
|
scrollFrom: scrollTop / (estimatedHeight - height),
|
|
total: totalColumn,
|
|
visible: true
|
|
});
|
|
return {
|
|
horizontalScrollbar,
|
|
verticalScrollbar
|
|
};
|
|
};
|
|
const renderItems = () => {
|
|
var _a2;
|
|
const [columnStart, columnEnd] = unref(columnsToRender);
|
|
const [rowStart, rowEnd] = unref(rowsToRender);
|
|
const { data, totalColumn, totalRow, useIsScrolling, itemKey } = props2;
|
|
const children = [];
|
|
if (totalRow > 0 && totalColumn > 0) {
|
|
for (let row = rowStart; row <= rowEnd; row++) {
|
|
for (let column2 = columnStart; column2 <= columnEnd; column2++) {
|
|
const key = itemKey({ columnIndex: column2, data, rowIndex: row });
|
|
children.push(h(Fragment, { key }, (_a2 = slots.default) == null ? void 0 : _a2.call(slots, {
|
|
columnIndex: column2,
|
|
data,
|
|
isScrolling: useIsScrolling ? unref(states).isScrolling : void 0,
|
|
style: getItemStyle(row, column2),
|
|
rowIndex: row
|
|
})));
|
|
}
|
|
}
|
|
}
|
|
return children;
|
|
};
|
|
const renderInner = () => {
|
|
const Inner = resolveDynamicComponent(props2.innerElement);
|
|
const children = renderItems();
|
|
return [
|
|
h(Inner, {
|
|
style: unref(innerStyle),
|
|
ref: innerRef
|
|
}, !isString(Inner) ? {
|
|
default: () => children
|
|
} : children)
|
|
];
|
|
};
|
|
const renderWindow = () => {
|
|
const Container2 = resolveDynamicComponent(props2.containerElement);
|
|
const { horizontalScrollbar, verticalScrollbar } = renderScrollbars();
|
|
const Inner = renderInner();
|
|
return h("div", {
|
|
key: 0,
|
|
class: ns.e("wrapper"),
|
|
role: props2.role
|
|
}, [
|
|
h(Container2, {
|
|
class: props2.className,
|
|
style: unref(windowStyle),
|
|
onScroll,
|
|
ref: windowRef
|
|
}, !isString(Container2) ? { default: () => Inner } : Inner),
|
|
horizontalScrollbar,
|
|
verticalScrollbar
|
|
]);
|
|
};
|
|
return renderWindow;
|
|
}
|
|
});
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/virtual-list/src/components/dynamic-size-grid.mjs
|
|
var { max: max2, min: min2, floor: floor2 } = Math;
|
|
var SCOPE7 = "ElDynamicSizeGrid";
|
|
var ACCESS_SIZER_KEY_MAP = {
|
|
column: "columnWidth",
|
|
row: "rowHeight"
|
|
};
|
|
var ACCESS_LAST_VISITED_KEY_MAP = {
|
|
column: "lastVisitedColumnIndex",
|
|
row: "lastVisitedRowIndex"
|
|
};
|
|
var getItemFromCache2 = (props2, index, gridCache, type4) => {
|
|
const [cachedItems, sizer, lastVisited] = [
|
|
gridCache[type4],
|
|
props2[ACCESS_SIZER_KEY_MAP[type4]],
|
|
gridCache[ACCESS_LAST_VISITED_KEY_MAP[type4]]
|
|
];
|
|
if (index > lastVisited) {
|
|
let offset3 = 0;
|
|
if (lastVisited >= 0) {
|
|
const item = cachedItems[lastVisited];
|
|
offset3 = item.offset + item.size;
|
|
}
|
|
for (let i = lastVisited + 1; i <= index; i++) {
|
|
const size3 = sizer(i);
|
|
cachedItems[i] = {
|
|
offset: offset3,
|
|
size: size3
|
|
};
|
|
offset3 += size3;
|
|
}
|
|
gridCache[ACCESS_LAST_VISITED_KEY_MAP[type4]] = index;
|
|
}
|
|
return cachedItems[index];
|
|
};
|
|
var bs2 = (props2, gridCache, low, high, offset3, type4) => {
|
|
while (low <= high) {
|
|
const mid = low + floor2((high - low) / 2);
|
|
const currentOffset = getItemFromCache2(props2, mid, gridCache, type4).offset;
|
|
if (currentOffset === offset3) {
|
|
return mid;
|
|
} else if (currentOffset < offset3) {
|
|
low = mid + 1;
|
|
} else {
|
|
high = mid - 1;
|
|
}
|
|
}
|
|
return max2(0, low - 1);
|
|
};
|
|
var es2 = (props2, gridCache, idx, offset3, type4) => {
|
|
const total2 = type4 === "column" ? props2.totalColumn : props2.totalRow;
|
|
let exponent = 1;
|
|
while (idx < total2 && getItemFromCache2(props2, idx, gridCache, type4).offset < offset3) {
|
|
idx += exponent;
|
|
exponent *= 2;
|
|
}
|
|
return bs2(props2, gridCache, floor2(idx / 2), min2(idx, total2 - 1), offset3, type4);
|
|
};
|
|
var findItem2 = (props2, gridCache, offset3, type4) => {
|
|
const [cache2, lastVisitedIndex] = [
|
|
gridCache[type4],
|
|
gridCache[ACCESS_LAST_VISITED_KEY_MAP[type4]]
|
|
];
|
|
const lastVisitedItemOffset = lastVisitedIndex > 0 ? cache2[lastVisitedIndex].offset : 0;
|
|
if (lastVisitedItemOffset >= offset3) {
|
|
return bs2(props2, gridCache, 0, lastVisitedIndex, offset3, type4);
|
|
}
|
|
return es2(props2, gridCache, max2(0, lastVisitedIndex), offset3, type4);
|
|
};
|
|
var getEstimatedTotalHeight = ({ totalRow }, { estimatedRowHeight, lastVisitedRowIndex, row }) => {
|
|
let sizeOfVisitedRows = 0;
|
|
if (lastVisitedRowIndex >= totalRow) {
|
|
lastVisitedRowIndex = totalRow - 1;
|
|
}
|
|
if (lastVisitedRowIndex >= 0) {
|
|
const item = row[lastVisitedRowIndex];
|
|
sizeOfVisitedRows = item.offset + item.size;
|
|
}
|
|
const unvisitedItems = totalRow - lastVisitedRowIndex - 1;
|
|
const sizeOfUnvisitedItems = unvisitedItems * estimatedRowHeight;
|
|
return sizeOfVisitedRows + sizeOfUnvisitedItems;
|
|
};
|
|
var getEstimatedTotalWidth = ({ totalColumn }, { column: column2, estimatedColumnWidth, lastVisitedColumnIndex }) => {
|
|
let sizeOfVisitedColumns = 0;
|
|
if (lastVisitedColumnIndex > totalColumn) {
|
|
lastVisitedColumnIndex = totalColumn - 1;
|
|
}
|
|
if (lastVisitedColumnIndex >= 0) {
|
|
const item = column2[lastVisitedColumnIndex];
|
|
sizeOfVisitedColumns = item.offset + item.size;
|
|
}
|
|
const unvisitedItems = totalColumn - lastVisitedColumnIndex - 1;
|
|
const sizeOfUnvisitedItems = unvisitedItems * estimatedColumnWidth;
|
|
return sizeOfVisitedColumns + sizeOfUnvisitedItems;
|
|
};
|
|
var ACCESS_ESTIMATED_SIZE_KEY_MAP = {
|
|
column: getEstimatedTotalWidth,
|
|
row: getEstimatedTotalHeight
|
|
};
|
|
var getOffset2 = (props2, index, alignment, scrollOffset, cache2, type4, scrollBarWidth2) => {
|
|
const [size3, estimatedSizeAssociates] = [
|
|
type4 === "row" ? props2.height : props2.width,
|
|
ACCESS_ESTIMATED_SIZE_KEY_MAP[type4]
|
|
];
|
|
const item = getItemFromCache2(props2, index, cache2, type4);
|
|
const estimatedSize = estimatedSizeAssociates(props2, cache2);
|
|
const maxOffset = max2(0, min2(estimatedSize - size3, item.offset));
|
|
const minOffset = max2(0, item.offset - size3 + scrollBarWidth2 + item.size);
|
|
if (alignment === SMART_ALIGNMENT) {
|
|
if (scrollOffset >= minOffset - size3 && scrollOffset <= maxOffset + size3) {
|
|
alignment = AUTO_ALIGNMENT;
|
|
} else {
|
|
alignment = CENTERED_ALIGNMENT;
|
|
}
|
|
}
|
|
switch (alignment) {
|
|
case START_ALIGNMENT: {
|
|
return maxOffset;
|
|
}
|
|
case END_ALIGNMENT: {
|
|
return minOffset;
|
|
}
|
|
case CENTERED_ALIGNMENT: {
|
|
return Math.round(minOffset + (maxOffset - minOffset) / 2);
|
|
}
|
|
case AUTO_ALIGNMENT:
|
|
default: {
|
|
if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
|
|
return scrollOffset;
|
|
} else if (minOffset > maxOffset) {
|
|
return minOffset;
|
|
} else if (scrollOffset < minOffset) {
|
|
return minOffset;
|
|
} else {
|
|
return maxOffset;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var DynamicSizeGrid = createGrid({
|
|
name: "ElDynamicSizeGrid",
|
|
getColumnPosition: (props2, idx, cache2) => {
|
|
const item = getItemFromCache2(props2, idx, cache2, "column");
|
|
return [item.size, item.offset];
|
|
},
|
|
getRowPosition: (props2, idx, cache2) => {
|
|
const item = getItemFromCache2(props2, idx, cache2, "row");
|
|
return [item.size, item.offset];
|
|
},
|
|
getColumnOffset: (props2, columnIndex, alignment, scrollLeft, cache2, scrollBarWidth2) => getOffset2(props2, columnIndex, alignment, scrollLeft, cache2, "column", scrollBarWidth2),
|
|
getRowOffset: (props2, rowIndex, alignment, scrollTop, cache2, scrollBarWidth2) => getOffset2(props2, rowIndex, alignment, scrollTop, cache2, "row", scrollBarWidth2),
|
|
getColumnStartIndexForOffset: (props2, scrollLeft, cache2) => findItem2(props2, cache2, scrollLeft, "column"),
|
|
getColumnStopIndexForStartIndex: (props2, startIndex, scrollLeft, cache2) => {
|
|
const item = getItemFromCache2(props2, startIndex, cache2, "column");
|
|
const maxOffset = scrollLeft + props2.width;
|
|
let offset3 = item.offset + item.size;
|
|
let stopIndex = startIndex;
|
|
while (stopIndex < props2.totalColumn - 1 && offset3 < maxOffset) {
|
|
stopIndex++;
|
|
offset3 += getItemFromCache2(props2, startIndex, cache2, "column").size;
|
|
}
|
|
return stopIndex;
|
|
},
|
|
getEstimatedTotalHeight,
|
|
getEstimatedTotalWidth,
|
|
getRowStartIndexForOffset: (props2, scrollTop, cache2) => findItem2(props2, cache2, scrollTop, "row"),
|
|
getRowStopIndexForStartIndex: (props2, startIndex, scrollTop, cache2) => {
|
|
const { totalRow, height } = props2;
|
|
const item = getItemFromCache2(props2, startIndex, cache2, "row");
|
|
const maxOffset = scrollTop + height;
|
|
let offset3 = item.size + item.offset;
|
|
let stopIndex = startIndex;
|
|
while (stopIndex < totalRow - 1 && offset3 < maxOffset) {
|
|
stopIndex++;
|
|
offset3 += getItemFromCache2(props2, stopIndex, cache2, "row").size;
|
|
}
|
|
return stopIndex;
|
|
},
|
|
injectToInstance: (instance, cache2) => {
|
|
const resetAfter = ({ columnIndex, rowIndex }, forceUpdate) => {
|
|
var _a2, _b;
|
|
forceUpdate = isUndefined2(forceUpdate) ? true : forceUpdate;
|
|
if (isNumber2(columnIndex)) {
|
|
cache2.value.lastVisitedColumnIndex = Math.min(cache2.value.lastVisitedColumnIndex, columnIndex - 1);
|
|
}
|
|
if (isNumber2(rowIndex)) {
|
|
cache2.value.lastVisitedRowIndex = Math.min(cache2.value.lastVisitedRowIndex, rowIndex - 1);
|
|
}
|
|
(_a2 = instance.exposed) == null ? void 0 : _a2.getItemStyleCache.value(-1, null, null);
|
|
if (forceUpdate)
|
|
(_b = instance.proxy) == null ? void 0 : _b.$forceUpdate();
|
|
};
|
|
const resetAfterColumnIndex = (columnIndex, forceUpdate) => {
|
|
resetAfter({
|
|
columnIndex
|
|
}, forceUpdate);
|
|
};
|
|
const resetAfterRowIndex = (rowIndex, forceUpdate) => {
|
|
resetAfter({
|
|
rowIndex
|
|
}, forceUpdate);
|
|
};
|
|
Object.assign(instance.proxy, {
|
|
resetAfterColumnIndex,
|
|
resetAfterRowIndex,
|
|
resetAfter
|
|
});
|
|
},
|
|
initCache: ({
|
|
estimatedColumnWidth = DEFAULT_DYNAMIC_LIST_ITEM_SIZE,
|
|
estimatedRowHeight = DEFAULT_DYNAMIC_LIST_ITEM_SIZE
|
|
}) => {
|
|
const cache2 = {
|
|
column: {},
|
|
estimatedColumnWidth,
|
|
estimatedRowHeight,
|
|
lastVisitedColumnIndex: -1,
|
|
lastVisitedRowIndex: -1,
|
|
row: {}
|
|
};
|
|
return cache2;
|
|
},
|
|
clearCache: false,
|
|
validateProps: ({ columnWidth, rowHeight }) => {
|
|
if (true) {
|
|
if (!isFunction(columnWidth)) {
|
|
throwError(SCOPE7, `
|
|
"columnWidth" must be passed as function,
|
|
instead ${typeof columnWidth} was given.
|
|
`);
|
|
}
|
|
if (!isFunction(rowHeight)) {
|
|
throwError(SCOPE7, `
|
|
"rowHeight" must be passed as function,
|
|
instead ${typeof rowHeight} was given.
|
|
`);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/virtual-list/src/components/fixed-size-grid.mjs
|
|
var SCOPE8 = "ElFixedSizeGrid";
|
|
var FixedSizeGrid = createGrid({
|
|
name: "ElFixedSizeGrid",
|
|
getColumnPosition: ({ columnWidth }, index) => [
|
|
columnWidth,
|
|
index * columnWidth
|
|
],
|
|
getRowPosition: ({ rowHeight }, index) => [
|
|
rowHeight,
|
|
index * rowHeight
|
|
],
|
|
getEstimatedTotalHeight: ({ totalRow, rowHeight }) => rowHeight * totalRow,
|
|
getEstimatedTotalWidth: ({ totalColumn, columnWidth }) => columnWidth * totalColumn,
|
|
getColumnOffset: ({ totalColumn, columnWidth, width }, columnIndex, alignment, scrollLeft, _2, scrollBarWidth2) => {
|
|
width = Number(width);
|
|
const lastColumnOffset = Math.max(0, totalColumn * columnWidth - width);
|
|
const maxOffset = Math.min(lastColumnOffset, columnIndex * columnWidth);
|
|
const minOffset = Math.max(0, columnIndex * columnWidth - width + scrollBarWidth2 + columnWidth);
|
|
if (alignment === "smart") {
|
|
if (scrollLeft >= minOffset - width && scrollLeft <= maxOffset + width) {
|
|
alignment = AUTO_ALIGNMENT;
|
|
} else {
|
|
alignment = CENTERED_ALIGNMENT;
|
|
}
|
|
}
|
|
switch (alignment) {
|
|
case START_ALIGNMENT:
|
|
return maxOffset;
|
|
case END_ALIGNMENT:
|
|
return minOffset;
|
|
case CENTERED_ALIGNMENT: {
|
|
const middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
|
|
if (middleOffset < Math.ceil(width / 2)) {
|
|
return 0;
|
|
} else if (middleOffset > lastColumnOffset + Math.floor(width / 2)) {
|
|
return lastColumnOffset;
|
|
} else {
|
|
return middleOffset;
|
|
}
|
|
}
|
|
case AUTO_ALIGNMENT:
|
|
default:
|
|
if (scrollLeft >= minOffset && scrollLeft <= maxOffset) {
|
|
return scrollLeft;
|
|
} else if (minOffset > maxOffset) {
|
|
return minOffset;
|
|
} else if (scrollLeft < minOffset) {
|
|
return minOffset;
|
|
} else {
|
|
return maxOffset;
|
|
}
|
|
}
|
|
},
|
|
getRowOffset: ({ rowHeight, height, totalRow }, rowIndex, align, scrollTop, _2, scrollBarWidth2) => {
|
|
height = Number(height);
|
|
const lastRowOffset = Math.max(0, totalRow * rowHeight - height);
|
|
const maxOffset = Math.min(lastRowOffset, rowIndex * rowHeight);
|
|
const minOffset = Math.max(0, rowIndex * rowHeight - height + scrollBarWidth2 + rowHeight);
|
|
if (align === SMART_ALIGNMENT) {
|
|
if (scrollTop >= minOffset - height && scrollTop <= maxOffset + height) {
|
|
align = AUTO_ALIGNMENT;
|
|
} else {
|
|
align = CENTERED_ALIGNMENT;
|
|
}
|
|
}
|
|
switch (align) {
|
|
case START_ALIGNMENT:
|
|
return maxOffset;
|
|
case END_ALIGNMENT:
|
|
return minOffset;
|
|
case CENTERED_ALIGNMENT: {
|
|
const middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
|
|
if (middleOffset < Math.ceil(height / 2)) {
|
|
return 0;
|
|
} else if (middleOffset > lastRowOffset + Math.floor(height / 2)) {
|
|
return lastRowOffset;
|
|
} else {
|
|
return middleOffset;
|
|
}
|
|
}
|
|
case AUTO_ALIGNMENT:
|
|
default:
|
|
if (scrollTop >= minOffset && scrollTop <= maxOffset) {
|
|
return scrollTop;
|
|
} else if (minOffset > maxOffset) {
|
|
return minOffset;
|
|
} else if (scrollTop < minOffset) {
|
|
return minOffset;
|
|
} else {
|
|
return maxOffset;
|
|
}
|
|
}
|
|
},
|
|
getColumnStartIndexForOffset: ({ columnWidth, totalColumn }, scrollLeft) => Math.max(0, Math.min(totalColumn - 1, Math.floor(scrollLeft / columnWidth))),
|
|
getColumnStopIndexForStartIndex: ({ columnWidth, totalColumn, width }, startIndex, scrollLeft) => {
|
|
const left = startIndex * columnWidth;
|
|
const visibleColumnsCount = Math.ceil((width + scrollLeft - left) / columnWidth);
|
|
return Math.max(0, Math.min(totalColumn - 1, startIndex + visibleColumnsCount - 1));
|
|
},
|
|
getRowStartIndexForOffset: ({ rowHeight, totalRow }, scrollTop) => Math.max(0, Math.min(totalRow - 1, Math.floor(scrollTop / rowHeight))),
|
|
getRowStopIndexForStartIndex: ({ rowHeight, totalRow, height }, startIndex, scrollTop) => {
|
|
const top = startIndex * rowHeight;
|
|
const numVisibleRows = Math.ceil((height + scrollTop - top) / rowHeight);
|
|
return Math.max(0, Math.min(totalRow - 1, startIndex + numVisibleRows - 1));
|
|
},
|
|
initCache: () => void 0,
|
|
clearCache: true,
|
|
validateProps: ({ columnWidth, rowHeight }) => {
|
|
if (true) {
|
|
if (!isNumber2(columnWidth)) {
|
|
throwError(SCOPE8, `
|
|
"columnWidth" must be passed as number,
|
|
instead ${typeof columnWidth} was given.
|
|
`);
|
|
}
|
|
if (!isNumber2(rowHeight)) {
|
|
throwError(SCOPE8, `
|
|
"columnWidth" must be passed as number,
|
|
instead ${typeof rowHeight} was given.
|
|
`);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/composables/utils.mjs
|
|
var calcColumnStyle = (column2, fixedColumn, fixed) => {
|
|
var _a2;
|
|
const flex = {
|
|
flexGrow: 0,
|
|
flexShrink: 0,
|
|
...fixed ? {} : {
|
|
flexGrow: column2.flexGrow || 0,
|
|
flexShrink: column2.flexShrink || 1
|
|
}
|
|
};
|
|
if (!fixed) {
|
|
flex.flexShrink = 1;
|
|
}
|
|
const style = {
|
|
...(_a2 = column2.style) != null ? _a2 : {},
|
|
...flex,
|
|
flexBasis: "auto",
|
|
width: column2.width
|
|
};
|
|
if (!fixedColumn) {
|
|
if (column2.maxWidth)
|
|
style.maxWidth = column2.maxWidth;
|
|
if (column2.minWidth)
|
|
style.minWidth = column2.minWidth;
|
|
}
|
|
return style;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/composables/use-columns.mjs
|
|
function useColumns(props2, columns2, fixed) {
|
|
const _columns = computed(() => unref(columns2).map((column2, index) => {
|
|
var _a2, _b;
|
|
return {
|
|
...column2,
|
|
key: (_b = (_a2 = column2.key) != null ? _a2 : column2.dataKey) != null ? _b : index
|
|
};
|
|
}));
|
|
const visibleColumns = computed(() => {
|
|
return unref(_columns).filter((column2) => !column2.hidden);
|
|
});
|
|
const fixedColumnsOnLeft = computed(() => unref(visibleColumns).filter((column2) => column2.fixed === "left" || column2.fixed === true));
|
|
const fixedColumnsOnRight = computed(() => unref(visibleColumns).filter((column2) => column2.fixed === "right"));
|
|
const normalColumns = computed(() => unref(visibleColumns).filter((column2) => !column2.fixed));
|
|
const mainColumns = computed(() => {
|
|
const ret = [];
|
|
unref(fixedColumnsOnLeft).forEach((column2) => {
|
|
ret.push({
|
|
...column2,
|
|
placeholderSign
|
|
});
|
|
});
|
|
unref(normalColumns).forEach((column2) => {
|
|
ret.push(column2);
|
|
});
|
|
unref(fixedColumnsOnRight).forEach((column2) => {
|
|
ret.push({
|
|
...column2,
|
|
placeholderSign
|
|
});
|
|
});
|
|
return ret;
|
|
});
|
|
const hasFixedColumns = computed(() => {
|
|
return unref(fixedColumnsOnLeft).length || unref(fixedColumnsOnRight).length;
|
|
});
|
|
const columnsStyles = computed(() => {
|
|
return unref(_columns).reduce((style, column2) => {
|
|
style[column2.key] = calcColumnStyle(column2, unref(fixed), props2.fixed);
|
|
return style;
|
|
}, {});
|
|
});
|
|
const columnsTotalWidth = computed(() => {
|
|
return unref(visibleColumns).reduce((width, column2) => width + column2.width, 0);
|
|
});
|
|
const getColumn = (key) => {
|
|
return unref(_columns).find((column2) => column2.key === key);
|
|
};
|
|
const getColumnStyle = (key) => {
|
|
return unref(columnsStyles)[key];
|
|
};
|
|
const updateColumnWidth = (column2, width) => {
|
|
column2.width = width;
|
|
};
|
|
function onColumnSorted(e) {
|
|
var _a2;
|
|
const { key } = e.currentTarget.dataset;
|
|
if (!key)
|
|
return;
|
|
const { sortState, sortBy: sortBy2 } = props2;
|
|
let order = SortOrder.ASC;
|
|
if (isObject(sortState)) {
|
|
order = oppositeOrderMap[sortState[key]];
|
|
} else {
|
|
order = oppositeOrderMap[sortBy2.order];
|
|
}
|
|
(_a2 = props2.onColumnSort) == null ? void 0 : _a2.call(props2, { column: getColumn(key), key, order });
|
|
}
|
|
return {
|
|
columns: _columns,
|
|
columnsStyles,
|
|
columnsTotalWidth,
|
|
fixedColumnsOnLeft,
|
|
fixedColumnsOnRight,
|
|
hasFixedColumns,
|
|
mainColumns,
|
|
normalColumns,
|
|
visibleColumns,
|
|
getColumn,
|
|
getColumnStyle,
|
|
updateColumnWidth,
|
|
onColumnSorted
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/composables/use-scrollbar.mjs
|
|
var useScrollbar2 = (props2, {
|
|
mainTableRef,
|
|
leftTableRef,
|
|
rightTableRef,
|
|
onMaybeEndReached
|
|
}) => {
|
|
const scrollPos = ref({ scrollLeft: 0, scrollTop: 0 });
|
|
function doScroll(params) {
|
|
var _a2, _b, _c;
|
|
const { scrollTop } = params;
|
|
(_a2 = mainTableRef.value) == null ? void 0 : _a2.scrollTo(params);
|
|
(_b = leftTableRef.value) == null ? void 0 : _b.scrollToTop(scrollTop);
|
|
(_c = rightTableRef.value) == null ? void 0 : _c.scrollToTop(scrollTop);
|
|
}
|
|
function scrollTo(params) {
|
|
scrollPos.value = params;
|
|
doScroll(params);
|
|
}
|
|
function scrollToTop(scrollTop) {
|
|
scrollPos.value.scrollTop = scrollTop;
|
|
doScroll(unref(scrollPos));
|
|
}
|
|
function scrollToLeft(scrollLeft) {
|
|
var _a2, _b;
|
|
scrollPos.value.scrollLeft = scrollLeft;
|
|
(_b = (_a2 = mainTableRef.value) == null ? void 0 : _a2.scrollTo) == null ? void 0 : _b.call(_a2, unref(scrollPos));
|
|
}
|
|
function onScroll(params) {
|
|
var _a2;
|
|
scrollTo(params);
|
|
(_a2 = props2.onScroll) == null ? void 0 : _a2.call(props2, params);
|
|
}
|
|
function onVerticalScroll({ scrollTop }) {
|
|
const { scrollTop: currentScrollTop } = unref(scrollPos);
|
|
if (scrollTop !== currentScrollTop)
|
|
scrollToTop(scrollTop);
|
|
}
|
|
function scrollToRow(row, strategy = "auto") {
|
|
var _a2;
|
|
(_a2 = mainTableRef.value) == null ? void 0 : _a2.scrollToRow(row, strategy);
|
|
}
|
|
watch(() => unref(scrollPos).scrollTop, (cur, prev) => {
|
|
if (cur > prev)
|
|
onMaybeEndReached();
|
|
});
|
|
return {
|
|
scrollPos,
|
|
scrollTo,
|
|
scrollToLeft,
|
|
scrollToTop,
|
|
scrollToRow,
|
|
onScroll,
|
|
onVerticalScroll
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/composables/use-row.mjs
|
|
var useRow = (props2, {
|
|
mainTableRef,
|
|
leftTableRef,
|
|
rightTableRef,
|
|
tableInstance,
|
|
ns,
|
|
isScrolling
|
|
}) => {
|
|
const vm = getCurrentInstance();
|
|
const { emit } = vm;
|
|
const isResetting = shallowRef(false);
|
|
const expandedRowKeys = ref(props2.defaultExpandedRowKeys || []);
|
|
const lastRenderedRowIndex = ref(-1);
|
|
const resetIndex = shallowRef(null);
|
|
const rowHeights = ref({});
|
|
const pendingRowHeights = ref({});
|
|
const leftTableHeights = shallowRef({});
|
|
const mainTableHeights = shallowRef({});
|
|
const rightTableHeights = shallowRef({});
|
|
const isDynamic = computed(() => isNumber2(props2.estimatedRowHeight));
|
|
function onRowsRendered(params) {
|
|
var _a2;
|
|
(_a2 = props2.onRowsRendered) == null ? void 0 : _a2.call(props2, params);
|
|
if (params.rowCacheEnd > unref(lastRenderedRowIndex)) {
|
|
lastRenderedRowIndex.value = params.rowCacheEnd;
|
|
}
|
|
}
|
|
function onRowHovered({ hovered, rowKey: rowKey2 }) {
|
|
if (isScrolling.value) {
|
|
return;
|
|
}
|
|
const tableRoot = tableInstance.vnode.el;
|
|
const rows = tableRoot.querySelectorAll(`[rowkey="${String(rowKey2)}"]`);
|
|
rows.forEach((row) => {
|
|
if (hovered) {
|
|
row.classList.add(ns.is("hovered"));
|
|
} else {
|
|
row.classList.remove(ns.is("hovered"));
|
|
}
|
|
});
|
|
}
|
|
function onRowExpanded({
|
|
expanded,
|
|
rowData,
|
|
rowIndex,
|
|
rowKey: rowKey2
|
|
}) {
|
|
var _a2, _b;
|
|
const _expandedRowKeys = [...unref(expandedRowKeys)];
|
|
const currentKeyIndex = _expandedRowKeys.indexOf(rowKey2);
|
|
if (expanded) {
|
|
if (currentKeyIndex === -1)
|
|
_expandedRowKeys.push(rowKey2);
|
|
} else {
|
|
if (currentKeyIndex > -1)
|
|
_expandedRowKeys.splice(currentKeyIndex, 1);
|
|
}
|
|
expandedRowKeys.value = _expandedRowKeys;
|
|
emit("update:expandedRowKeys", _expandedRowKeys);
|
|
(_a2 = props2.onRowExpand) == null ? void 0 : _a2.call(props2, {
|
|
expanded,
|
|
rowData,
|
|
rowIndex,
|
|
rowKey: rowKey2
|
|
});
|
|
(_b = props2.onExpandedRowsChange) == null ? void 0 : _b.call(props2, _expandedRowKeys);
|
|
}
|
|
const flushingRowHeights = debounce_default(() => {
|
|
var _a2, _b, _c, _d;
|
|
isResetting.value = true;
|
|
rowHeights.value = { ...unref(rowHeights), ...unref(pendingRowHeights) };
|
|
resetAfterIndex(unref(resetIndex), false);
|
|
pendingRowHeights.value = {};
|
|
resetIndex.value = null;
|
|
(_a2 = mainTableRef.value) == null ? void 0 : _a2.forceUpdate();
|
|
(_b = leftTableRef.value) == null ? void 0 : _b.forceUpdate();
|
|
(_c = rightTableRef.value) == null ? void 0 : _c.forceUpdate();
|
|
(_d = vm.proxy) == null ? void 0 : _d.$forceUpdate();
|
|
isResetting.value = false;
|
|
}, 0);
|
|
function resetAfterIndex(index, forceUpdate = false) {
|
|
if (!unref(isDynamic))
|
|
return;
|
|
[mainTableRef, leftTableRef, rightTableRef].forEach((tableRef) => {
|
|
const table = unref(tableRef);
|
|
if (table)
|
|
table.resetAfterRowIndex(index, forceUpdate);
|
|
});
|
|
}
|
|
function resetHeights(rowKey2, height, rowIdx) {
|
|
const resetIdx = unref(resetIndex);
|
|
if (resetIdx === null) {
|
|
resetIndex.value = rowIdx;
|
|
} else {
|
|
if (resetIdx > rowIdx) {
|
|
resetIndex.value = rowIdx;
|
|
}
|
|
}
|
|
pendingRowHeights.value[rowKey2] = height;
|
|
}
|
|
function onRowHeightChange({ rowKey: rowKey2, height, rowIndex }, fixedDir) {
|
|
if (!fixedDir) {
|
|
mainTableHeights.value[rowKey2] = height;
|
|
} else {
|
|
if (fixedDir === FixedDir.RIGHT) {
|
|
rightTableHeights.value[rowKey2] = height;
|
|
} else {
|
|
leftTableHeights.value[rowKey2] = height;
|
|
}
|
|
}
|
|
const maximumHeight = Math.max(...[leftTableHeights, rightTableHeights, mainTableHeights].map((records) => records.value[rowKey2] || 0));
|
|
if (unref(rowHeights)[rowKey2] !== maximumHeight) {
|
|
resetHeights(rowKey2, maximumHeight, rowIndex);
|
|
flushingRowHeights();
|
|
}
|
|
}
|
|
return {
|
|
expandedRowKeys,
|
|
lastRenderedRowIndex,
|
|
isDynamic,
|
|
isResetting,
|
|
rowHeights,
|
|
resetAfterIndex,
|
|
onRowExpanded,
|
|
onRowHovered,
|
|
onRowsRendered,
|
|
onRowHeightChange
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/composables/use-data.mjs
|
|
var useData = (props2, { expandedRowKeys, lastRenderedRowIndex, resetAfterIndex }) => {
|
|
const depthMap = ref({});
|
|
const flattenedData = computed(() => {
|
|
const depths = {};
|
|
const { data: data2, rowKey: rowKey2 } = props2;
|
|
const _expandedRowKeys = unref(expandedRowKeys);
|
|
if (!_expandedRowKeys || !_expandedRowKeys.length)
|
|
return data2;
|
|
const array4 = [];
|
|
const keysSet = new Set();
|
|
_expandedRowKeys.forEach((x2) => keysSet.add(x2));
|
|
let copy = data2.slice();
|
|
copy.forEach((x2) => depths[x2[rowKey2]] = 0);
|
|
while (copy.length > 0) {
|
|
const item = copy.shift();
|
|
array4.push(item);
|
|
if (keysSet.has(item[rowKey2]) && isArray(item.children) && item.children.length > 0) {
|
|
copy = [...item.children, ...copy];
|
|
item.children.forEach((child) => depths[child[rowKey2]] = depths[item[rowKey2]] + 1);
|
|
}
|
|
}
|
|
depthMap.value = depths;
|
|
return array4;
|
|
});
|
|
const data = computed(() => {
|
|
const { data: data2, expandColumnKey: expandColumnKey2 } = props2;
|
|
return expandColumnKey2 ? unref(flattenedData) : data2;
|
|
});
|
|
watch(data, (val, prev) => {
|
|
if (val !== prev) {
|
|
lastRenderedRowIndex.value = -1;
|
|
resetAfterIndex(0, true);
|
|
}
|
|
});
|
|
return {
|
|
data,
|
|
depthMap
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/utils.mjs
|
|
var sumReducer = (sum22, num) => sum22 + num;
|
|
var sum2 = (listLike) => {
|
|
return isArray(listLike) ? listLike.reduce(sumReducer, 0) : listLike;
|
|
};
|
|
var tryCall = (fLike, params, defaultRet = {}) => {
|
|
return isFunction(fLike) ? fLike(params) : fLike != null ? fLike : defaultRet;
|
|
};
|
|
var enforceUnit = (style) => {
|
|
["width", "maxWidth", "minWidth", "height"].forEach((key) => {
|
|
style[key] = addUnit(style[key]);
|
|
});
|
|
return style;
|
|
};
|
|
var componentToSlot = (ComponentLike) => isVNode(ComponentLike) ? (props2) => h(ComponentLike, props2) : ComponentLike;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/composables/use-styles.mjs
|
|
var useStyles2 = (props2, {
|
|
columnsTotalWidth,
|
|
rowsHeight,
|
|
fixedColumnsOnLeft,
|
|
fixedColumnsOnRight
|
|
}) => {
|
|
const bodyWidth = computed(() => {
|
|
const { fixed, width, vScrollbarSize } = props2;
|
|
const ret = width - vScrollbarSize;
|
|
return fixed ? Math.max(Math.round(unref(columnsTotalWidth)), ret) : ret;
|
|
});
|
|
const mainTableHeight = computed(() => {
|
|
const { height = 0, maxHeight = 0, footerHeight: footerHeight2, hScrollbarSize } = props2;
|
|
if (maxHeight > 0) {
|
|
const _fixedRowsHeight = unref(fixedRowsHeight);
|
|
const _rowsHeight = unref(rowsHeight);
|
|
const _headerHeight = unref(headerHeight);
|
|
const total2 = _headerHeight + _fixedRowsHeight + _rowsHeight + hScrollbarSize;
|
|
return Math.min(total2, maxHeight - footerHeight2);
|
|
}
|
|
return height - footerHeight2;
|
|
});
|
|
const fixedTableHeight = computed(() => {
|
|
const { maxHeight } = props2;
|
|
const tableHeight = unref(mainTableHeight);
|
|
if (isNumber2(maxHeight) && maxHeight > 0)
|
|
return tableHeight;
|
|
const totalHeight = unref(rowsHeight) + unref(headerHeight) + unref(fixedRowsHeight);
|
|
return Math.min(tableHeight, totalHeight);
|
|
});
|
|
const mapColumn = (column2) => column2.width;
|
|
const leftTableWidth = computed(() => sum2(unref(fixedColumnsOnLeft).map(mapColumn)));
|
|
const rightTableWidth = computed(() => sum2(unref(fixedColumnsOnRight).map(mapColumn)));
|
|
const headerHeight = computed(() => sum2(props2.headerHeight));
|
|
const fixedRowsHeight = computed(() => {
|
|
var _a2;
|
|
return (((_a2 = props2.fixedData) == null ? void 0 : _a2.length) || 0) * props2.rowHeight;
|
|
});
|
|
const windowHeight = computed(() => {
|
|
return unref(mainTableHeight) - unref(headerHeight) - unref(fixedRowsHeight);
|
|
});
|
|
const rootStyle = computed(() => {
|
|
const { style = {}, height, width } = props2;
|
|
return enforceUnit({
|
|
...style,
|
|
height,
|
|
width
|
|
});
|
|
});
|
|
const footerHeight = computed(() => enforceUnit({ height: props2.footerHeight }));
|
|
const emptyStyle = computed(() => ({
|
|
top: addUnit(unref(headerHeight)),
|
|
bottom: addUnit(props2.footerHeight),
|
|
width: addUnit(props2.width)
|
|
}));
|
|
return {
|
|
bodyWidth,
|
|
fixedTableHeight,
|
|
mainTableHeight,
|
|
leftTableWidth,
|
|
rightTableWidth,
|
|
windowHeight,
|
|
footerHeight,
|
|
emptyStyle,
|
|
rootStyle,
|
|
headerHeight
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/use-table.mjs
|
|
function useTable(props2) {
|
|
const mainTableRef = ref();
|
|
const leftTableRef = ref();
|
|
const rightTableRef = ref();
|
|
const {
|
|
columns: columns2,
|
|
columnsStyles,
|
|
columnsTotalWidth,
|
|
fixedColumnsOnLeft,
|
|
fixedColumnsOnRight,
|
|
hasFixedColumns,
|
|
mainColumns,
|
|
onColumnSorted
|
|
} = useColumns(props2, toRef(props2, "columns"), toRef(props2, "fixed"));
|
|
const {
|
|
scrollTo,
|
|
scrollToLeft,
|
|
scrollToTop,
|
|
scrollToRow,
|
|
onScroll,
|
|
onVerticalScroll,
|
|
scrollPos
|
|
} = useScrollbar2(props2, {
|
|
mainTableRef,
|
|
leftTableRef,
|
|
rightTableRef,
|
|
onMaybeEndReached
|
|
});
|
|
const ns = useNamespace("table-v2");
|
|
const instance = getCurrentInstance();
|
|
const isScrolling = shallowRef(false);
|
|
const {
|
|
expandedRowKeys,
|
|
lastRenderedRowIndex,
|
|
isDynamic,
|
|
isResetting,
|
|
rowHeights,
|
|
resetAfterIndex,
|
|
onRowExpanded,
|
|
onRowHeightChange,
|
|
onRowHovered,
|
|
onRowsRendered
|
|
} = useRow(props2, {
|
|
mainTableRef,
|
|
leftTableRef,
|
|
rightTableRef,
|
|
tableInstance: instance,
|
|
ns,
|
|
isScrolling
|
|
});
|
|
const { data, depthMap } = useData(props2, {
|
|
expandedRowKeys,
|
|
lastRenderedRowIndex,
|
|
resetAfterIndex
|
|
});
|
|
const rowsHeight = computed(() => {
|
|
const { estimatedRowHeight, rowHeight } = props2;
|
|
const _data = unref(data);
|
|
if (isNumber2(estimatedRowHeight)) {
|
|
return Object.values(unref(rowHeights)).reduce((acc, curr) => acc + curr, 0);
|
|
}
|
|
return _data.length * rowHeight;
|
|
});
|
|
const {
|
|
bodyWidth,
|
|
fixedTableHeight,
|
|
mainTableHeight,
|
|
leftTableWidth,
|
|
rightTableWidth,
|
|
windowHeight,
|
|
footerHeight,
|
|
emptyStyle,
|
|
rootStyle,
|
|
headerHeight
|
|
} = useStyles2(props2, {
|
|
columnsTotalWidth,
|
|
fixedColumnsOnLeft,
|
|
fixedColumnsOnRight,
|
|
rowsHeight
|
|
});
|
|
const containerRef = ref();
|
|
const showEmpty = computed(() => {
|
|
const noData = unref(data).length === 0;
|
|
return isArray(props2.fixedData) ? props2.fixedData.length === 0 && noData : noData;
|
|
});
|
|
function getRowHeight(rowIndex) {
|
|
const { estimatedRowHeight, rowHeight, rowKey: rowKey2 } = props2;
|
|
if (!estimatedRowHeight)
|
|
return rowHeight;
|
|
return unref(rowHeights)[unref(data)[rowIndex][rowKey2]] || estimatedRowHeight;
|
|
}
|
|
const isEndReached = ref(false);
|
|
function onMaybeEndReached() {
|
|
const { onEndReached } = props2;
|
|
if (!onEndReached)
|
|
return;
|
|
const { scrollTop } = unref(scrollPos);
|
|
const _totalHeight = unref(rowsHeight);
|
|
const clientHeight = unref(windowHeight);
|
|
const remainDistance = _totalHeight - (scrollTop + clientHeight) + props2.hScrollbarSize;
|
|
if (!isEndReached.value && unref(lastRenderedRowIndex) >= 0 && _totalHeight <= scrollTop + unref(mainTableHeight) - unref(headerHeight)) {
|
|
isEndReached.value = true;
|
|
onEndReached(remainDistance);
|
|
} else {
|
|
isEndReached.value = false;
|
|
}
|
|
}
|
|
watch(() => unref(rowsHeight), () => isEndReached.value = false);
|
|
watch(() => props2.expandedRowKeys, (val) => expandedRowKeys.value = val, {
|
|
deep: true
|
|
});
|
|
return {
|
|
columns: columns2,
|
|
containerRef,
|
|
mainTableRef,
|
|
leftTableRef,
|
|
rightTableRef,
|
|
isDynamic,
|
|
isResetting,
|
|
isScrolling,
|
|
hasFixedColumns,
|
|
columnsStyles,
|
|
columnsTotalWidth,
|
|
data,
|
|
expandedRowKeys,
|
|
depthMap,
|
|
fixedColumnsOnLeft,
|
|
fixedColumnsOnRight,
|
|
mainColumns,
|
|
bodyWidth,
|
|
emptyStyle,
|
|
rootStyle,
|
|
footerHeight,
|
|
mainTableHeight,
|
|
fixedTableHeight,
|
|
leftTableWidth,
|
|
rightTableWidth,
|
|
showEmpty,
|
|
getRowHeight,
|
|
onColumnSorted,
|
|
onRowHovered,
|
|
onRowExpanded,
|
|
onRowsRendered,
|
|
onRowHeightChange,
|
|
scrollTo,
|
|
scrollToLeft,
|
|
scrollToTop,
|
|
scrollToRow,
|
|
onScroll,
|
|
onVerticalScroll
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/tokens.mjs
|
|
var TableV2InjectionKey = Symbol("tableV2");
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/components/header.mjs
|
|
var COMPONENT_NAME19 = "ElTableV2Header";
|
|
var TableV2Header = defineComponent({
|
|
name: COMPONENT_NAME19,
|
|
props: tableV2HeaderProps,
|
|
setup(props2, {
|
|
slots,
|
|
expose
|
|
}) {
|
|
const ns = useNamespace("table-v2");
|
|
const scrollLeftInfo = inject("tableV2GridScrollLeft");
|
|
const headerRef = ref();
|
|
const headerStyle = computed(() => enforceUnit({
|
|
width: props2.width,
|
|
height: props2.height
|
|
}));
|
|
const rowStyle = computed(() => enforceUnit({
|
|
width: props2.rowWidth,
|
|
height: props2.height
|
|
}));
|
|
const headerHeights = computed(() => castArray_default(unref(props2.headerHeight)));
|
|
const scrollToLeft = (left) => {
|
|
const headerEl = unref(headerRef);
|
|
nextTick(() => {
|
|
(headerEl == null ? void 0 : headerEl.scroll) && headerEl.scroll({
|
|
left
|
|
});
|
|
});
|
|
};
|
|
const renderFixedRows = () => {
|
|
const fixedRowClassName = ns.e("fixed-header-row");
|
|
const {
|
|
columns: columns2,
|
|
fixedHeaderData,
|
|
rowHeight
|
|
} = props2;
|
|
return fixedHeaderData == null ? void 0 : fixedHeaderData.map((fixedRowData, fixedRowIndex) => {
|
|
var _a2;
|
|
const style = enforceUnit({
|
|
height: rowHeight,
|
|
width: "100%"
|
|
});
|
|
return (_a2 = slots.fixed) == null ? void 0 : _a2.call(slots, {
|
|
class: fixedRowClassName,
|
|
columns: columns2,
|
|
rowData: fixedRowData,
|
|
rowIndex: -(fixedRowIndex + 1),
|
|
style
|
|
});
|
|
});
|
|
};
|
|
const renderDynamicRows = () => {
|
|
const dynamicRowClassName = ns.e("dynamic-header-row");
|
|
const {
|
|
columns: columns2
|
|
} = props2;
|
|
return unref(headerHeights).map((rowHeight, rowIndex) => {
|
|
var _a2;
|
|
const style = enforceUnit({
|
|
width: "100%",
|
|
height: rowHeight
|
|
});
|
|
return (_a2 = slots.dynamic) == null ? void 0 : _a2.call(slots, {
|
|
class: dynamicRowClassName,
|
|
columns: columns2,
|
|
headerIndex: rowIndex,
|
|
style
|
|
});
|
|
});
|
|
};
|
|
onUpdated(() => {
|
|
if (scrollLeftInfo == null ? void 0 : scrollLeftInfo.value) {
|
|
scrollToLeft(scrollLeftInfo.value);
|
|
}
|
|
});
|
|
expose({
|
|
scrollToLeft
|
|
});
|
|
return () => {
|
|
if (props2.height <= 0)
|
|
return;
|
|
return createVNode("div", {
|
|
"ref": headerRef,
|
|
"class": props2.class,
|
|
"style": unref(headerStyle),
|
|
"role": "rowgroup"
|
|
}, [createVNode("div", {
|
|
"style": unref(rowStyle),
|
|
"class": ns.e("header")
|
|
}, [renderDynamicRows(), renderFixedRows()])]);
|
|
};
|
|
}
|
|
});
|
|
var Header2 = TableV2Header;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/table-grid.mjs
|
|
var COMPONENT_NAME20 = "ElTableV2Grid";
|
|
var useTableGrid = (props2) => {
|
|
const headerRef = ref();
|
|
const bodyRef = ref();
|
|
const scrollLeft = ref(0);
|
|
const totalHeight = computed(() => {
|
|
const {
|
|
data,
|
|
rowHeight,
|
|
estimatedRowHeight
|
|
} = props2;
|
|
if (estimatedRowHeight) {
|
|
return;
|
|
}
|
|
return data.length * rowHeight;
|
|
});
|
|
const fixedRowHeight = computed(() => {
|
|
const {
|
|
fixedData,
|
|
rowHeight
|
|
} = props2;
|
|
return ((fixedData == null ? void 0 : fixedData.length) || 0) * rowHeight;
|
|
});
|
|
const headerHeight = computed(() => sum2(props2.headerHeight));
|
|
const gridHeight = computed(() => {
|
|
const {
|
|
height
|
|
} = props2;
|
|
return Math.max(0, height - unref(headerHeight) - unref(fixedRowHeight));
|
|
});
|
|
const hasHeader = computed(() => {
|
|
return unref(headerHeight) + unref(fixedRowHeight) > 0;
|
|
});
|
|
const itemKey = ({
|
|
data,
|
|
rowIndex
|
|
}) => data[rowIndex][props2.rowKey];
|
|
function onItemRendered({
|
|
rowCacheStart,
|
|
rowCacheEnd,
|
|
rowVisibleStart,
|
|
rowVisibleEnd
|
|
}) {
|
|
var _a2;
|
|
(_a2 = props2.onRowsRendered) == null ? void 0 : _a2.call(props2, {
|
|
rowCacheStart,
|
|
rowCacheEnd,
|
|
rowVisibleStart,
|
|
rowVisibleEnd
|
|
});
|
|
}
|
|
function resetAfterRowIndex(index, forceUpdate2) {
|
|
var _a2;
|
|
(_a2 = bodyRef.value) == null ? void 0 : _a2.resetAfterRowIndex(index, forceUpdate2);
|
|
}
|
|
function scrollTo(leftOrOptions, top) {
|
|
const header$ = unref(headerRef);
|
|
const body$ = unref(bodyRef);
|
|
if (isObject(leftOrOptions)) {
|
|
header$ == null ? void 0 : header$.scrollToLeft(leftOrOptions.scrollLeft);
|
|
scrollLeft.value = leftOrOptions.scrollLeft;
|
|
body$ == null ? void 0 : body$.scrollTo(leftOrOptions);
|
|
} else {
|
|
header$ == null ? void 0 : header$.scrollToLeft(leftOrOptions);
|
|
scrollLeft.value = leftOrOptions;
|
|
body$ == null ? void 0 : body$.scrollTo({
|
|
scrollLeft: leftOrOptions,
|
|
scrollTop: top
|
|
});
|
|
}
|
|
}
|
|
function scrollToTop(scrollTop) {
|
|
var _a2;
|
|
(_a2 = unref(bodyRef)) == null ? void 0 : _a2.scrollTo({
|
|
scrollTop
|
|
});
|
|
}
|
|
function scrollToRow(row, strategy) {
|
|
var _a2;
|
|
(_a2 = unref(bodyRef)) == null ? void 0 : _a2.scrollToItem(row, 1, strategy);
|
|
}
|
|
function forceUpdate() {
|
|
var _a2, _b;
|
|
(_a2 = unref(bodyRef)) == null ? void 0 : _a2.$forceUpdate();
|
|
(_b = unref(headerRef)) == null ? void 0 : _b.$forceUpdate();
|
|
}
|
|
watch(() => props2.bodyWidth, () => {
|
|
var _a2;
|
|
if (isNumber2(props2.estimatedRowHeight))
|
|
(_a2 = bodyRef.value) == null ? void 0 : _a2.resetAfter({
|
|
columnIndex: 0
|
|
}, false);
|
|
});
|
|
return {
|
|
bodyRef,
|
|
forceUpdate,
|
|
fixedRowHeight,
|
|
gridHeight,
|
|
hasHeader,
|
|
headerHeight,
|
|
headerRef,
|
|
totalHeight,
|
|
itemKey,
|
|
onItemRendered,
|
|
resetAfterRowIndex,
|
|
scrollTo,
|
|
scrollToTop,
|
|
scrollToRow,
|
|
scrollLeft
|
|
};
|
|
};
|
|
var TableGrid = defineComponent({
|
|
name: COMPONENT_NAME20,
|
|
props: tableV2GridProps,
|
|
setup(props2, {
|
|
slots,
|
|
expose
|
|
}) {
|
|
const {
|
|
ns
|
|
} = inject(TableV2InjectionKey);
|
|
const {
|
|
bodyRef,
|
|
fixedRowHeight,
|
|
gridHeight,
|
|
hasHeader,
|
|
headerRef,
|
|
headerHeight,
|
|
totalHeight,
|
|
forceUpdate,
|
|
itemKey,
|
|
onItemRendered,
|
|
resetAfterRowIndex,
|
|
scrollTo,
|
|
scrollToTop,
|
|
scrollToRow,
|
|
scrollLeft
|
|
} = useTableGrid(props2);
|
|
provide("tableV2GridScrollLeft", scrollLeft);
|
|
onActivated(async () => {
|
|
var _a2;
|
|
await nextTick();
|
|
const scrollTop = (_a2 = bodyRef.value) == null ? void 0 : _a2.states.scrollTop;
|
|
scrollTop && scrollToTop(Math.round(scrollTop) + 1);
|
|
});
|
|
expose({
|
|
forceUpdate,
|
|
totalHeight,
|
|
scrollTo,
|
|
scrollToTop,
|
|
scrollToRow,
|
|
resetAfterRowIndex
|
|
});
|
|
const getColumnWidth = () => props2.bodyWidth;
|
|
return () => {
|
|
const {
|
|
cache: cache2,
|
|
columns: columns2,
|
|
data,
|
|
fixedData,
|
|
useIsScrolling,
|
|
scrollbarAlwaysOn,
|
|
scrollbarEndGap,
|
|
scrollbarStartGap,
|
|
style,
|
|
rowHeight,
|
|
bodyWidth,
|
|
estimatedRowHeight,
|
|
headerWidth,
|
|
height,
|
|
width,
|
|
getRowHeight,
|
|
onScroll
|
|
} = props2;
|
|
const isDynamicRowEnabled = isNumber2(estimatedRowHeight);
|
|
const Grid = isDynamicRowEnabled ? DynamicSizeGrid : FixedSizeGrid;
|
|
const _headerHeight = unref(headerHeight);
|
|
return createVNode("div", {
|
|
"role": "table",
|
|
"class": [ns.e("table"), props2.class],
|
|
"style": style
|
|
}, [createVNode(Grid, {
|
|
"ref": bodyRef,
|
|
"data": data,
|
|
"useIsScrolling": useIsScrolling,
|
|
"itemKey": itemKey,
|
|
"columnCache": 0,
|
|
"columnWidth": isDynamicRowEnabled ? getColumnWidth : bodyWidth,
|
|
"totalColumn": 1,
|
|
"totalRow": data.length,
|
|
"rowCache": cache2,
|
|
"rowHeight": isDynamicRowEnabled ? getRowHeight : rowHeight,
|
|
"width": width,
|
|
"height": unref(gridHeight),
|
|
"class": ns.e("body"),
|
|
"role": "rowgroup",
|
|
"scrollbarStartGap": scrollbarStartGap,
|
|
"scrollbarEndGap": scrollbarEndGap,
|
|
"scrollbarAlwaysOn": scrollbarAlwaysOn,
|
|
"onScroll": onScroll,
|
|
"onItemRendered": onItemRendered,
|
|
"perfMode": false
|
|
}, {
|
|
default: (params) => {
|
|
var _a2;
|
|
const rowData = data[params.rowIndex];
|
|
return (_a2 = slots.row) == null ? void 0 : _a2.call(slots, {
|
|
...params,
|
|
columns: columns2,
|
|
rowData
|
|
});
|
|
}
|
|
}), unref(hasHeader) && createVNode(Header2, {
|
|
"ref": headerRef,
|
|
"class": ns.e("header-wrapper"),
|
|
"columns": columns2,
|
|
"headerData": data,
|
|
"headerHeight": props2.headerHeight,
|
|
"fixedHeaderData": fixedData,
|
|
"rowWidth": headerWidth,
|
|
"rowHeight": rowHeight,
|
|
"width": width,
|
|
"height": Math.min(_headerHeight + unref(fixedRowHeight), height)
|
|
}, {
|
|
dynamic: slots.header,
|
|
fixed: slots.row
|
|
})]);
|
|
};
|
|
}
|
|
});
|
|
var Table2 = TableGrid;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/main-table.mjs
|
|
function _isSlot(s2) {
|
|
return typeof s2 === "function" || Object.prototype.toString.call(s2) === "[object Object]" && !isVNode(s2);
|
|
}
|
|
var MainTable = (props2, {
|
|
slots
|
|
}) => {
|
|
const {
|
|
mainTableRef,
|
|
...rest2
|
|
} = props2;
|
|
return createVNode(Table2, mergeProps({
|
|
"ref": mainTableRef
|
|
}, rest2), _isSlot(slots) ? slots : {
|
|
default: () => [slots]
|
|
});
|
|
};
|
|
var MainTable$1 = MainTable;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/left-table.mjs
|
|
function _isSlot2(s2) {
|
|
return typeof s2 === "function" || Object.prototype.toString.call(s2) === "[object Object]" && !isVNode(s2);
|
|
}
|
|
var LeftTable = (props2, {
|
|
slots
|
|
}) => {
|
|
if (!props2.columns.length)
|
|
return;
|
|
const {
|
|
leftTableRef,
|
|
...rest2
|
|
} = props2;
|
|
return createVNode(Table2, mergeProps({
|
|
"ref": leftTableRef
|
|
}, rest2), _isSlot2(slots) ? slots : {
|
|
default: () => [slots]
|
|
});
|
|
};
|
|
var LeftTable$1 = LeftTable;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/right-table.mjs
|
|
function _isSlot3(s2) {
|
|
return typeof s2 === "function" || Object.prototype.toString.call(s2) === "[object Object]" && !isVNode(s2);
|
|
}
|
|
var LeftTable2 = (props2, {
|
|
slots
|
|
}) => {
|
|
if (!props2.columns.length)
|
|
return;
|
|
const {
|
|
rightTableRef,
|
|
...rest2
|
|
} = props2;
|
|
return createVNode(Table2, mergeProps({
|
|
"ref": rightTableRef
|
|
}, rest2), _isSlot3(slots) ? slots : {
|
|
default: () => [slots]
|
|
});
|
|
};
|
|
var RightTable = LeftTable2;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/components/row.mjs
|
|
var useTableRow = (props2) => {
|
|
const {
|
|
isScrolling
|
|
} = inject(TableV2InjectionKey);
|
|
const measured = ref(false);
|
|
const rowRef = ref();
|
|
const measurable = computed(() => {
|
|
return isNumber2(props2.estimatedRowHeight) && props2.rowIndex >= 0;
|
|
});
|
|
const doMeasure = (isInit = false) => {
|
|
const $rowRef = unref(rowRef);
|
|
if (!$rowRef)
|
|
return;
|
|
const {
|
|
columns: columns2,
|
|
onRowHeightChange,
|
|
rowKey: rowKey2,
|
|
rowIndex,
|
|
style
|
|
} = props2;
|
|
const {
|
|
height
|
|
} = $rowRef.getBoundingClientRect();
|
|
measured.value = true;
|
|
nextTick(() => {
|
|
if (isInit || height !== Number.parseInt(style.height)) {
|
|
const firstColumn = columns2[0];
|
|
const isPlaceholder = (firstColumn == null ? void 0 : firstColumn.placeholderSign) === placeholderSign;
|
|
onRowHeightChange == null ? void 0 : onRowHeightChange({
|
|
rowKey: rowKey2,
|
|
height,
|
|
rowIndex
|
|
}, firstColumn && !isPlaceholder && firstColumn.fixed);
|
|
}
|
|
});
|
|
};
|
|
const eventHandlers = computed(() => {
|
|
const {
|
|
rowData,
|
|
rowIndex,
|
|
rowKey: rowKey2,
|
|
onRowHover
|
|
} = props2;
|
|
const handlers2 = props2.rowEventHandlers || {};
|
|
const eventHandlers2 = {};
|
|
Object.entries(handlers2).forEach(([eventName, handler]) => {
|
|
if (isFunction(handler)) {
|
|
eventHandlers2[eventName] = (event) => {
|
|
handler({
|
|
event,
|
|
rowData,
|
|
rowIndex,
|
|
rowKey: rowKey2
|
|
});
|
|
};
|
|
}
|
|
});
|
|
if (onRowHover) {
|
|
[{
|
|
name: "onMouseleave",
|
|
hovered: false
|
|
}, {
|
|
name: "onMouseenter",
|
|
hovered: true
|
|
}].forEach(({
|
|
name,
|
|
hovered
|
|
}) => {
|
|
const existedHandler = eventHandlers2[name];
|
|
eventHandlers2[name] = (event) => {
|
|
onRowHover({
|
|
event,
|
|
hovered,
|
|
rowData,
|
|
rowIndex,
|
|
rowKey: rowKey2
|
|
});
|
|
existedHandler == null ? void 0 : existedHandler(event);
|
|
};
|
|
});
|
|
}
|
|
return eventHandlers2;
|
|
});
|
|
const onExpand = (expanded) => {
|
|
const {
|
|
onRowExpand,
|
|
rowData,
|
|
rowIndex,
|
|
rowKey: rowKey2
|
|
} = props2;
|
|
onRowExpand == null ? void 0 : onRowExpand({
|
|
expanded,
|
|
rowData,
|
|
rowIndex,
|
|
rowKey: rowKey2
|
|
});
|
|
};
|
|
onMounted(() => {
|
|
if (unref(measurable)) {
|
|
doMeasure(true);
|
|
}
|
|
});
|
|
return {
|
|
isScrolling,
|
|
measurable,
|
|
measured,
|
|
rowRef,
|
|
eventHandlers,
|
|
onExpand
|
|
};
|
|
};
|
|
var COMPONENT_NAME21 = "ElTableV2TableRow";
|
|
var TableV2Row = defineComponent({
|
|
name: COMPONENT_NAME21,
|
|
props: tableV2RowProps,
|
|
setup(props2, {
|
|
expose,
|
|
slots,
|
|
attrs
|
|
}) {
|
|
const {
|
|
eventHandlers,
|
|
isScrolling,
|
|
measurable,
|
|
measured,
|
|
rowRef,
|
|
onExpand
|
|
} = useTableRow(props2);
|
|
expose({
|
|
onExpand
|
|
});
|
|
return () => {
|
|
const {
|
|
columns: columns2,
|
|
columnsStyles,
|
|
expandColumnKey: expandColumnKey2,
|
|
depth,
|
|
rowData,
|
|
rowIndex,
|
|
style
|
|
} = props2;
|
|
let ColumnCells = columns2.map((column2, columnIndex) => {
|
|
const expandable = isArray(rowData.children) && rowData.children.length > 0 && column2.key === expandColumnKey2;
|
|
return slots.cell({
|
|
column: column2,
|
|
columns: columns2,
|
|
columnIndex,
|
|
depth,
|
|
style: columnsStyles[column2.key],
|
|
rowData,
|
|
rowIndex,
|
|
isScrolling: unref(isScrolling),
|
|
expandIconProps: expandable ? {
|
|
rowData,
|
|
rowIndex,
|
|
onExpand
|
|
} : void 0
|
|
});
|
|
});
|
|
if (slots.row) {
|
|
ColumnCells = slots.row({
|
|
cells: ColumnCells.map((node) => {
|
|
if (isArray(node) && node.length === 1) {
|
|
return node[0];
|
|
}
|
|
return node;
|
|
}),
|
|
style,
|
|
columns: columns2,
|
|
depth,
|
|
rowData,
|
|
rowIndex,
|
|
isScrolling: unref(isScrolling)
|
|
});
|
|
}
|
|
if (unref(measurable)) {
|
|
const {
|
|
height,
|
|
...exceptHeightStyle
|
|
} = style || {};
|
|
const _measured = unref(measured);
|
|
return createVNode("div", mergeProps({
|
|
"ref": rowRef,
|
|
"class": props2.class,
|
|
"style": _measured ? style : exceptHeightStyle,
|
|
"role": "row"
|
|
}, attrs, unref(eventHandlers)), [ColumnCells]);
|
|
}
|
|
return createVNode("div", mergeProps(attrs, {
|
|
"ref": rowRef,
|
|
"class": props2.class,
|
|
"style": style,
|
|
"role": "row"
|
|
}, unref(eventHandlers)), [ColumnCells]);
|
|
};
|
|
}
|
|
});
|
|
var Row2 = TableV2Row;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/row.mjs
|
|
function _isSlot4(s2) {
|
|
return typeof s2 === "function" || Object.prototype.toString.call(s2) === "[object Object]" && !isVNode(s2);
|
|
}
|
|
var RowRenderer = (props2, {
|
|
slots
|
|
}) => {
|
|
const {
|
|
columns: columns2,
|
|
columnsStyles,
|
|
depthMap,
|
|
expandColumnKey: expandColumnKey2,
|
|
expandedRowKeys,
|
|
estimatedRowHeight,
|
|
hasFixedColumns,
|
|
rowData,
|
|
rowIndex,
|
|
style,
|
|
isScrolling,
|
|
rowProps: rowProps2,
|
|
rowClass,
|
|
rowKey: rowKey2,
|
|
rowEventHandlers,
|
|
ns,
|
|
onRowHovered,
|
|
onRowExpanded
|
|
} = props2;
|
|
const rowKls = tryCall(rowClass, {
|
|
columns: columns2,
|
|
rowData,
|
|
rowIndex
|
|
}, "");
|
|
const additionalProps = tryCall(rowProps2, {
|
|
columns: columns2,
|
|
rowData,
|
|
rowIndex
|
|
});
|
|
const _rowKey = rowData[rowKey2];
|
|
const depth = depthMap[_rowKey] || 0;
|
|
const canExpand = Boolean(expandColumnKey2);
|
|
const isFixedRow = rowIndex < 0;
|
|
const kls = [ns.e("row"), rowKls, {
|
|
[ns.e(`row-depth-${depth}`)]: canExpand && rowIndex >= 0,
|
|
[ns.is("expanded")]: canExpand && expandedRowKeys.includes(_rowKey),
|
|
[ns.is("fixed")]: !depth && isFixedRow,
|
|
[ns.is("customized")]: Boolean(slots.row)
|
|
}];
|
|
const onRowHover = hasFixedColumns ? onRowHovered : void 0;
|
|
const _rowProps = {
|
|
...additionalProps,
|
|
columns: columns2,
|
|
columnsStyles,
|
|
class: kls,
|
|
depth,
|
|
expandColumnKey: expandColumnKey2,
|
|
estimatedRowHeight: isFixedRow ? void 0 : estimatedRowHeight,
|
|
isScrolling,
|
|
rowIndex,
|
|
rowData,
|
|
rowKey: _rowKey,
|
|
rowEventHandlers,
|
|
style
|
|
};
|
|
const handlerMosueEnter = (e) => {
|
|
onRowHover == null ? void 0 : onRowHover({
|
|
hovered: true,
|
|
rowKey: _rowKey,
|
|
event: e,
|
|
rowData,
|
|
rowIndex
|
|
});
|
|
};
|
|
const handlerMouseLeave = (e) => {
|
|
onRowHover == null ? void 0 : onRowHover({
|
|
hovered: false,
|
|
rowKey: _rowKey,
|
|
event: e,
|
|
rowData,
|
|
rowIndex
|
|
});
|
|
};
|
|
return createVNode(Row2, mergeProps(_rowProps, {
|
|
"onRowExpand": onRowExpanded,
|
|
"onMouseenter": handlerMosueEnter,
|
|
"onMouseleave": handlerMouseLeave,
|
|
"rowkey": _rowKey
|
|
}), _isSlot4(slots) ? slots : {
|
|
default: () => [slots]
|
|
});
|
|
};
|
|
var Row3 = RowRenderer;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/components/cell.mjs
|
|
var TableV2Cell = (props2, {
|
|
slots
|
|
}) => {
|
|
var _a2;
|
|
const {
|
|
cellData,
|
|
style
|
|
} = props2;
|
|
const displayText = ((_a2 = cellData == null ? void 0 : cellData.toString) == null ? void 0 : _a2.call(cellData)) || "";
|
|
const defaultSlot = renderSlot(slots, "default", props2, () => [displayText]);
|
|
return createVNode("div", {
|
|
"class": props2.class,
|
|
"title": displayText,
|
|
"style": style
|
|
}, [defaultSlot]);
|
|
};
|
|
TableV2Cell.displayName = "ElTableV2Cell";
|
|
TableV2Cell.inheritAttrs = false;
|
|
var TableCell = TableV2Cell;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/components/expand-icon.mjs
|
|
var ExpandIcon = (props2) => {
|
|
const {
|
|
expanded,
|
|
expandable,
|
|
onExpand,
|
|
style,
|
|
size: size3
|
|
} = props2;
|
|
const expandIconProps = {
|
|
onClick: expandable ? () => onExpand(!expanded) : void 0,
|
|
class: props2.class
|
|
};
|
|
return createVNode(ElIcon, mergeProps(expandIconProps, {
|
|
"size": size3,
|
|
"style": style
|
|
}), {
|
|
default: () => [createVNode(arrow_right_default, null, null)]
|
|
});
|
|
};
|
|
var ExpandIcon$1 = ExpandIcon;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/cell.mjs
|
|
var CellRenderer = ({
|
|
columns: columns2,
|
|
column: column2,
|
|
columnIndex,
|
|
depth,
|
|
expandIconProps,
|
|
isScrolling,
|
|
rowData,
|
|
rowIndex,
|
|
style,
|
|
expandedRowKeys,
|
|
ns,
|
|
cellProps: _cellProps,
|
|
expandColumnKey: expandColumnKey2,
|
|
indentSize,
|
|
iconSize,
|
|
rowKey: rowKey2
|
|
}, {
|
|
slots
|
|
}) => {
|
|
const cellStyle = enforceUnit(style);
|
|
if (column2.placeholderSign === placeholderSign) {
|
|
return createVNode("div", {
|
|
"class": ns.em("row-cell", "placeholder"),
|
|
"style": cellStyle
|
|
}, null);
|
|
}
|
|
const {
|
|
cellRenderer,
|
|
dataKey,
|
|
dataGetter
|
|
} = column2;
|
|
const cellData = isFunction(dataGetter) ? dataGetter({
|
|
columns: columns2,
|
|
column: column2,
|
|
columnIndex,
|
|
rowData,
|
|
rowIndex
|
|
}) : get_default(rowData, dataKey != null ? dataKey : "");
|
|
const extraCellProps = tryCall(_cellProps, {
|
|
cellData,
|
|
columns: columns2,
|
|
column: column2,
|
|
columnIndex,
|
|
rowIndex,
|
|
rowData
|
|
});
|
|
const cellProps = {
|
|
class: ns.e("cell-text"),
|
|
columns: columns2,
|
|
column: column2,
|
|
columnIndex,
|
|
cellData,
|
|
isScrolling,
|
|
rowData,
|
|
rowIndex
|
|
};
|
|
const columnCellRenderer = componentToSlot(cellRenderer);
|
|
const Cell2 = columnCellRenderer ? columnCellRenderer(cellProps) : renderSlot(slots, "default", cellProps, () => [createVNode(TableCell, cellProps, null)]);
|
|
const kls = [ns.e("row-cell"), column2.class, column2.align === Alignment.CENTER && ns.is("align-center"), column2.align === Alignment.RIGHT && ns.is("align-right")];
|
|
const expandable = rowIndex >= 0 && expandColumnKey2 && column2.key === expandColumnKey2;
|
|
const expanded = rowIndex >= 0 && expandedRowKeys.includes(rowData[rowKey2]);
|
|
let IconOrPlaceholder;
|
|
const iconStyle = `margin-inline-start: ${depth * indentSize}px;`;
|
|
if (expandable) {
|
|
if (isObject(expandIconProps)) {
|
|
IconOrPlaceholder = createVNode(ExpandIcon$1, mergeProps(expandIconProps, {
|
|
"class": [ns.e("expand-icon"), ns.is("expanded", expanded)],
|
|
"size": iconSize,
|
|
"expanded": expanded,
|
|
"style": iconStyle,
|
|
"expandable": true
|
|
}), null);
|
|
} else {
|
|
IconOrPlaceholder = createVNode("div", {
|
|
"style": [iconStyle, `width: ${iconSize}px; height: ${iconSize}px;`].join(" ")
|
|
}, null);
|
|
}
|
|
}
|
|
return createVNode("div", mergeProps({
|
|
"class": kls,
|
|
"style": cellStyle
|
|
}, extraCellProps, {
|
|
"role": "cell"
|
|
}), [IconOrPlaceholder, Cell2]);
|
|
};
|
|
CellRenderer.inheritAttrs = false;
|
|
var Cell = CellRenderer;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/header-row.mjs
|
|
var tableV2HeaderRowProps = buildProps({
|
|
class: String,
|
|
columns,
|
|
columnsStyles: {
|
|
type: definePropType(Object),
|
|
required: true
|
|
},
|
|
headerIndex: Number,
|
|
style: { type: definePropType(Object) }
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/components/header-row.mjs
|
|
var TableV2HeaderRow = defineComponent({
|
|
name: "ElTableV2HeaderRow",
|
|
props: tableV2HeaderRowProps,
|
|
setup(props2, {
|
|
slots
|
|
}) {
|
|
return () => {
|
|
const {
|
|
columns: columns2,
|
|
columnsStyles,
|
|
headerIndex,
|
|
style
|
|
} = props2;
|
|
let Cells = columns2.map((column2, columnIndex) => {
|
|
return slots.cell({
|
|
columns: columns2,
|
|
column: column2,
|
|
columnIndex,
|
|
headerIndex,
|
|
style: columnsStyles[column2.key]
|
|
});
|
|
});
|
|
if (slots.header) {
|
|
Cells = slots.header({
|
|
cells: Cells.map((node) => {
|
|
if (isArray(node) && node.length === 1) {
|
|
return node[0];
|
|
}
|
|
return node;
|
|
}),
|
|
columns: columns2,
|
|
headerIndex
|
|
});
|
|
}
|
|
return createVNode("div", {
|
|
"class": props2.class,
|
|
"style": style,
|
|
"role": "row"
|
|
}, [Cells]);
|
|
};
|
|
}
|
|
});
|
|
var HeaderRow = TableV2HeaderRow;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/header.mjs
|
|
function _isSlot5(s2) {
|
|
return typeof s2 === "function" || Object.prototype.toString.call(s2) === "[object Object]" && !isVNode(s2);
|
|
}
|
|
var HeaderRenderer = ({
|
|
columns: columns2,
|
|
columnsStyles,
|
|
headerIndex,
|
|
style,
|
|
headerClass,
|
|
headerProps,
|
|
ns
|
|
}, {
|
|
slots
|
|
}) => {
|
|
const param = {
|
|
columns: columns2,
|
|
headerIndex
|
|
};
|
|
const kls = [ns.e("header-row"), tryCall(headerClass, param, ""), {
|
|
[ns.is("customized")]: Boolean(slots.header)
|
|
}];
|
|
const extraProps = {
|
|
...tryCall(headerProps, param),
|
|
columnsStyles,
|
|
class: kls,
|
|
columns: columns2,
|
|
headerIndex,
|
|
style
|
|
};
|
|
return createVNode(HeaderRow, extraProps, _isSlot5(slots) ? slots : {
|
|
default: () => [slots]
|
|
});
|
|
};
|
|
var Header3 = HeaderRenderer;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/components/header-cell.mjs
|
|
var HeaderCell = (props2, {
|
|
slots
|
|
}) => renderSlot(slots, "default", props2, () => {
|
|
var _a2, _b;
|
|
return [createVNode("div", {
|
|
"class": props2.class,
|
|
"title": (_a2 = props2.column) == null ? void 0 : _a2.title
|
|
}, [(_b = props2.column) == null ? void 0 : _b.title])];
|
|
});
|
|
HeaderCell.displayName = "ElTableV2HeaderCell";
|
|
HeaderCell.inheritAttrs = false;
|
|
var HeaderCell$1 = HeaderCell;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/components/sort-icon.mjs
|
|
var SortIcon = (props2) => {
|
|
const {
|
|
sortOrder
|
|
} = props2;
|
|
return createVNode(ElIcon, {
|
|
"size": 14,
|
|
"class": props2.class
|
|
}, {
|
|
default: () => [sortOrder === SortOrder.ASC ? createVNode(sort_up_default, null, null) : createVNode(sort_down_default, null, null)]
|
|
});
|
|
};
|
|
var SortIcon$1 = SortIcon;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/header-cell.mjs
|
|
var HeaderCellRenderer = (props2, {
|
|
slots
|
|
}) => {
|
|
const {
|
|
column: column2,
|
|
ns,
|
|
style,
|
|
onColumnSorted
|
|
} = props2;
|
|
const cellStyle = enforceUnit(style);
|
|
if (column2.placeholderSign === placeholderSign) {
|
|
return createVNode("div", {
|
|
"class": ns.em("header-row-cell", "placeholder"),
|
|
"style": cellStyle
|
|
}, null);
|
|
}
|
|
const {
|
|
headerCellRenderer,
|
|
headerClass,
|
|
sortable
|
|
} = column2;
|
|
const cellProps = {
|
|
...props2,
|
|
class: ns.e("header-cell-text")
|
|
};
|
|
const columnCellRenderer = componentToSlot(headerCellRenderer);
|
|
const Cell2 = columnCellRenderer ? columnCellRenderer(cellProps) : renderSlot(slots, "default", cellProps, () => [createVNode(HeaderCell$1, cellProps, null)]);
|
|
const {
|
|
sortBy: sortBy2,
|
|
sortState,
|
|
headerCellProps
|
|
} = props2;
|
|
let sorting, sortOrder;
|
|
if (sortState) {
|
|
const order = sortState[column2.key];
|
|
sorting = Boolean(oppositeOrderMap[order]);
|
|
sortOrder = sorting ? order : SortOrder.ASC;
|
|
} else {
|
|
sorting = column2.key === sortBy2.key;
|
|
sortOrder = sorting ? sortBy2.order : SortOrder.ASC;
|
|
}
|
|
const cellKls = [ns.e("header-cell"), tryCall(headerClass, props2, ""), column2.align === Alignment.CENTER && ns.is("align-center"), column2.align === Alignment.RIGHT && ns.is("align-right"), sortable && ns.is("sortable")];
|
|
const cellWrapperProps = {
|
|
...tryCall(headerCellProps, props2),
|
|
onClick: column2.sortable ? onColumnSorted : void 0,
|
|
class: cellKls,
|
|
style: cellStyle,
|
|
["data-key"]: column2.key
|
|
};
|
|
return createVNode("div", mergeProps(cellWrapperProps, {
|
|
"role": "columnheader"
|
|
}), [Cell2, sortable && createVNode(SortIcon$1, {
|
|
"class": [ns.e("sort-icon"), sorting && ns.is("sorting")],
|
|
"sortOrder": sortOrder
|
|
}, null)]);
|
|
};
|
|
var HeaderCell2 = HeaderCellRenderer;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/footer.mjs
|
|
var Footer2 = (props2, {
|
|
slots
|
|
}) => {
|
|
var _a2;
|
|
return createVNode("div", {
|
|
"class": props2.class,
|
|
"style": props2.style
|
|
}, [(_a2 = slots.default) == null ? void 0 : _a2.call(slots)]);
|
|
};
|
|
Footer2.displayName = "ElTableV2Footer";
|
|
var Footer$1 = Footer2;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/empty.mjs
|
|
var Footer3 = (props2, {
|
|
slots
|
|
}) => {
|
|
const defaultSlot = renderSlot(slots, "default", {}, () => [createVNode(ElEmpty, null, null)]);
|
|
return createVNode("div", {
|
|
"class": props2.class,
|
|
"style": props2.style
|
|
}, [defaultSlot]);
|
|
};
|
|
Footer3.displayName = "ElTableV2Empty";
|
|
var Empty2 = Footer3;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/overlay.mjs
|
|
var Overlay2 = (props2, {
|
|
slots
|
|
}) => {
|
|
var _a2;
|
|
return createVNode("div", {
|
|
"class": props2.class,
|
|
"style": props2.style
|
|
}, [(_a2 = slots.default) == null ? void 0 : _a2.call(slots)]);
|
|
};
|
|
Overlay2.displayName = "ElTableV2Overlay";
|
|
var Overlay$1 = Overlay2;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/table-v2.mjs
|
|
function _isSlot6(s2) {
|
|
return typeof s2 === "function" || Object.prototype.toString.call(s2) === "[object Object]" && !isVNode(s2);
|
|
}
|
|
var COMPONENT_NAME22 = "ElTableV2";
|
|
var TableV2 = defineComponent({
|
|
name: COMPONENT_NAME22,
|
|
props: tableV2Props,
|
|
setup(props2, {
|
|
slots,
|
|
expose
|
|
}) {
|
|
const ns = useNamespace("table-v2");
|
|
const {
|
|
columnsStyles,
|
|
fixedColumnsOnLeft,
|
|
fixedColumnsOnRight,
|
|
mainColumns,
|
|
mainTableHeight,
|
|
fixedTableHeight,
|
|
leftTableWidth,
|
|
rightTableWidth,
|
|
data,
|
|
depthMap,
|
|
expandedRowKeys,
|
|
hasFixedColumns,
|
|
mainTableRef,
|
|
leftTableRef,
|
|
rightTableRef,
|
|
isDynamic,
|
|
isResetting,
|
|
isScrolling,
|
|
bodyWidth,
|
|
emptyStyle,
|
|
rootStyle,
|
|
footerHeight,
|
|
showEmpty,
|
|
scrollTo,
|
|
scrollToLeft,
|
|
scrollToTop,
|
|
scrollToRow,
|
|
getRowHeight,
|
|
onColumnSorted,
|
|
onRowHeightChange,
|
|
onRowHovered,
|
|
onRowExpanded,
|
|
onRowsRendered,
|
|
onScroll,
|
|
onVerticalScroll
|
|
} = useTable(props2);
|
|
expose({
|
|
scrollTo,
|
|
scrollToLeft,
|
|
scrollToTop,
|
|
scrollToRow
|
|
});
|
|
provide(TableV2InjectionKey, {
|
|
ns,
|
|
isResetting,
|
|
isScrolling
|
|
});
|
|
return () => {
|
|
const {
|
|
cache: cache2,
|
|
cellProps,
|
|
estimatedRowHeight,
|
|
expandColumnKey: expandColumnKey2,
|
|
fixedData,
|
|
headerHeight,
|
|
headerClass,
|
|
headerProps,
|
|
headerCellProps,
|
|
sortBy: sortBy2,
|
|
sortState,
|
|
rowHeight,
|
|
rowClass,
|
|
rowEventHandlers,
|
|
rowKey: rowKey2,
|
|
rowProps: rowProps2,
|
|
scrollbarAlwaysOn,
|
|
indentSize,
|
|
iconSize,
|
|
useIsScrolling,
|
|
vScrollbarSize,
|
|
width
|
|
} = props2;
|
|
const _data = unref(data);
|
|
const mainTableProps = {
|
|
cache: cache2,
|
|
class: ns.e("main"),
|
|
columns: unref(mainColumns),
|
|
data: _data,
|
|
fixedData,
|
|
estimatedRowHeight,
|
|
bodyWidth: unref(bodyWidth),
|
|
headerHeight,
|
|
headerWidth: unref(bodyWidth),
|
|
height: unref(mainTableHeight),
|
|
mainTableRef,
|
|
rowKey: rowKey2,
|
|
rowHeight,
|
|
scrollbarAlwaysOn,
|
|
scrollbarStartGap: 2,
|
|
scrollbarEndGap: vScrollbarSize,
|
|
useIsScrolling,
|
|
width,
|
|
getRowHeight,
|
|
onRowsRendered,
|
|
onScroll
|
|
};
|
|
const leftColumnsWidth = unref(leftTableWidth);
|
|
const _fixedTableHeight = unref(fixedTableHeight);
|
|
const leftTableProps = {
|
|
cache: cache2,
|
|
class: ns.e("left"),
|
|
columns: unref(fixedColumnsOnLeft),
|
|
data: _data,
|
|
fixedData,
|
|
estimatedRowHeight,
|
|
leftTableRef,
|
|
rowHeight,
|
|
bodyWidth: leftColumnsWidth,
|
|
headerWidth: leftColumnsWidth,
|
|
headerHeight,
|
|
height: _fixedTableHeight,
|
|
rowKey: rowKey2,
|
|
scrollbarAlwaysOn,
|
|
scrollbarStartGap: 2,
|
|
scrollbarEndGap: vScrollbarSize,
|
|
useIsScrolling,
|
|
width: leftColumnsWidth,
|
|
getRowHeight,
|
|
onScroll: onVerticalScroll
|
|
};
|
|
const rightColumnsWidth = unref(rightTableWidth);
|
|
const rightTableProps = {
|
|
cache: cache2,
|
|
class: ns.e("right"),
|
|
columns: unref(fixedColumnsOnRight),
|
|
data: _data,
|
|
fixedData,
|
|
estimatedRowHeight,
|
|
rightTableRef,
|
|
rowHeight,
|
|
bodyWidth: rightColumnsWidth,
|
|
headerWidth: rightColumnsWidth,
|
|
headerHeight,
|
|
height: _fixedTableHeight,
|
|
rowKey: rowKey2,
|
|
scrollbarAlwaysOn,
|
|
scrollbarStartGap: 2,
|
|
scrollbarEndGap: vScrollbarSize,
|
|
width: rightColumnsWidth,
|
|
style: `--${unref(ns.namespace)}-table-scrollbar-size: ${vScrollbarSize}px`,
|
|
useIsScrolling,
|
|
getRowHeight,
|
|
onScroll: onVerticalScroll
|
|
};
|
|
const _columnsStyles = unref(columnsStyles);
|
|
const tableRowProps = {
|
|
ns,
|
|
depthMap: unref(depthMap),
|
|
columnsStyles: _columnsStyles,
|
|
expandColumnKey: expandColumnKey2,
|
|
expandedRowKeys: unref(expandedRowKeys),
|
|
estimatedRowHeight,
|
|
hasFixedColumns: unref(hasFixedColumns),
|
|
rowProps: rowProps2,
|
|
rowClass,
|
|
rowKey: rowKey2,
|
|
rowEventHandlers,
|
|
onRowHovered,
|
|
onRowExpanded,
|
|
onRowHeightChange
|
|
};
|
|
const tableCellProps = {
|
|
cellProps,
|
|
expandColumnKey: expandColumnKey2,
|
|
indentSize,
|
|
iconSize,
|
|
rowKey: rowKey2,
|
|
expandedRowKeys: unref(expandedRowKeys),
|
|
ns
|
|
};
|
|
const tableHeaderProps = {
|
|
ns,
|
|
headerClass,
|
|
headerProps,
|
|
columnsStyles: _columnsStyles
|
|
};
|
|
const tableHeaderCellProps = {
|
|
ns,
|
|
sortBy: sortBy2,
|
|
sortState,
|
|
headerCellProps,
|
|
onColumnSorted
|
|
};
|
|
const tableSlots = {
|
|
row: (props22) => createVNode(Row3, mergeProps(props22, tableRowProps), {
|
|
row: slots.row,
|
|
cell: (props3) => {
|
|
let _slot;
|
|
return slots.cell ? createVNode(Cell, mergeProps(props3, tableCellProps, {
|
|
"style": _columnsStyles[props3.column.key]
|
|
}), _isSlot6(_slot = slots.cell(props3)) ? _slot : {
|
|
default: () => [_slot]
|
|
}) : createVNode(Cell, mergeProps(props3, tableCellProps, {
|
|
"style": _columnsStyles[props3.column.key]
|
|
}), null);
|
|
}
|
|
}),
|
|
header: (props22) => createVNode(Header3, mergeProps(props22, tableHeaderProps), {
|
|
header: slots.header,
|
|
cell: (props3) => {
|
|
let _slot2;
|
|
return slots["header-cell"] ? createVNode(HeaderCell2, mergeProps(props3, tableHeaderCellProps, {
|
|
"style": _columnsStyles[props3.column.key]
|
|
}), _isSlot6(_slot2 = slots["header-cell"](props3)) ? _slot2 : {
|
|
default: () => [_slot2]
|
|
}) : createVNode(HeaderCell2, mergeProps(props3, tableHeaderCellProps, {
|
|
"style": _columnsStyles[props3.column.key]
|
|
}), null);
|
|
}
|
|
})
|
|
};
|
|
const rootKls = [props2.class, ns.b(), ns.e("root"), {
|
|
[ns.is("dynamic")]: unref(isDynamic)
|
|
}];
|
|
const footerProps = {
|
|
class: ns.e("footer"),
|
|
style: unref(footerHeight)
|
|
};
|
|
return createVNode("div", {
|
|
"class": rootKls,
|
|
"style": unref(rootStyle)
|
|
}, [createVNode(MainTable$1, mainTableProps, _isSlot6(tableSlots) ? tableSlots : {
|
|
default: () => [tableSlots]
|
|
}), createVNode(LeftTable$1, leftTableProps, _isSlot6(tableSlots) ? tableSlots : {
|
|
default: () => [tableSlots]
|
|
}), createVNode(RightTable, rightTableProps, _isSlot6(tableSlots) ? tableSlots : {
|
|
default: () => [tableSlots]
|
|
}), slots.footer && createVNode(Footer$1, footerProps, {
|
|
default: slots.footer
|
|
}), unref(showEmpty) && createVNode(Empty2, {
|
|
"class": ns.e("empty"),
|
|
"style": unref(emptyStyle)
|
|
}, {
|
|
default: slots.empty
|
|
}), slots.overlay && createVNode(Overlay$1, {
|
|
"class": ns.e("overlay")
|
|
}, {
|
|
default: slots.overlay
|
|
})]);
|
|
};
|
|
}
|
|
});
|
|
var TableV2$1 = TableV2;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/auto-resizer.mjs
|
|
var autoResizerProps = buildProps({
|
|
disableWidth: Boolean,
|
|
disableHeight: Boolean,
|
|
onResize: {
|
|
type: definePropType(Function)
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/composables/use-auto-resize.mjs
|
|
var useAutoResize = (props2) => {
|
|
const sizer = ref();
|
|
const width$ = ref(0);
|
|
const height$ = ref(0);
|
|
let resizerStopper;
|
|
onMounted(() => {
|
|
resizerStopper = useResizeObserver(sizer, ([entry]) => {
|
|
const { width, height } = entry.contentRect;
|
|
const { paddingLeft, paddingRight, paddingTop, paddingBottom } = getComputedStyle(entry.target);
|
|
const left = Number.parseInt(paddingLeft) || 0;
|
|
const right = Number.parseInt(paddingRight) || 0;
|
|
const top = Number.parseInt(paddingTop) || 0;
|
|
const bottom = Number.parseInt(paddingBottom) || 0;
|
|
width$.value = width - left - right;
|
|
height$.value = height - top - bottom;
|
|
}).stop;
|
|
});
|
|
onBeforeUnmount(() => {
|
|
resizerStopper == null ? void 0 : resizerStopper();
|
|
});
|
|
watch([width$, height$], ([width, height]) => {
|
|
var _a2;
|
|
(_a2 = props2.onResize) == null ? void 0 : _a2.call(props2, {
|
|
width,
|
|
height
|
|
});
|
|
});
|
|
return {
|
|
sizer,
|
|
width: width$,
|
|
height: height$
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/components/auto-resizer.mjs
|
|
var AutoResizer = defineComponent({
|
|
name: "ElAutoResizer",
|
|
props: autoResizerProps,
|
|
setup(props2, {
|
|
slots
|
|
}) {
|
|
const ns = useNamespace("auto-resizer");
|
|
const {
|
|
height,
|
|
width,
|
|
sizer
|
|
} = useAutoResize(props2);
|
|
const style = {
|
|
width: "100%",
|
|
height: "100%"
|
|
};
|
|
return () => {
|
|
var _a2;
|
|
return createVNode("div", {
|
|
"ref": sizer,
|
|
"class": ns.b(),
|
|
"style": style
|
|
}, [(_a2 = slots.default) == null ? void 0 : _a2.call(slots, {
|
|
height: height.value,
|
|
width: width.value
|
|
})]);
|
|
};
|
|
}
|
|
});
|
|
var AutoResizer$1 = AutoResizer;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/index.mjs
|
|
var ElTableV2 = withInstall(TableV2$1);
|
|
var ElAutoResizer = withInstall(AutoResizer$1);
|
|
|
|
// node_modules/element-plus/es/components/tabs/src/constants.mjs
|
|
var tabsRootContextKey = Symbol("tabsRootContextKey");
|
|
|
|
// node_modules/element-plus/es/components/tabs/src/tab-bar.mjs
|
|
var tabBarProps = buildProps({
|
|
tabs: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([])
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tabs/src/tab-bar2.mjs
|
|
var COMPONENT_NAME23 = "ElTabBar";
|
|
var __default__91 = defineComponent({
|
|
name: COMPONENT_NAME23
|
|
});
|
|
var _sfc_main127 = defineComponent({
|
|
...__default__91,
|
|
props: tabBarProps,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const instance = getCurrentInstance();
|
|
const rootTabs = inject(tabsRootContextKey);
|
|
if (!rootTabs)
|
|
throwError(COMPONENT_NAME23, "<el-tabs><el-tab-bar /></el-tabs>");
|
|
const ns = useNamespace("tabs");
|
|
const barRef = ref();
|
|
const barStyle = ref();
|
|
const getBarStyle = () => {
|
|
let offset3 = 0;
|
|
let tabSize = 0;
|
|
const sizeName = ["top", "bottom"].includes(rootTabs.props.tabPosition) ? "width" : "height";
|
|
const sizeDir = sizeName === "width" ? "x" : "y";
|
|
const position = sizeDir === "x" ? "left" : "top";
|
|
props2.tabs.every((tab) => {
|
|
var _a2, _b;
|
|
const $el = (_b = (_a2 = instance.parent) == null ? void 0 : _a2.refs) == null ? void 0 : _b[`tab-${tab.uid}`];
|
|
if (!$el)
|
|
return false;
|
|
if (!tab.active) {
|
|
return true;
|
|
}
|
|
offset3 = $el[`offset${capitalize3(position)}`];
|
|
tabSize = $el[`client${capitalize3(sizeName)}`];
|
|
const tabStyles = window.getComputedStyle($el);
|
|
if (sizeName === "width") {
|
|
tabSize -= Number.parseFloat(tabStyles.paddingLeft) + Number.parseFloat(tabStyles.paddingRight);
|
|
offset3 += Number.parseFloat(tabStyles.paddingLeft);
|
|
}
|
|
return false;
|
|
});
|
|
return {
|
|
[sizeName]: `${tabSize}px`,
|
|
transform: `translate${capitalize3(sizeDir)}(${offset3}px)`
|
|
};
|
|
};
|
|
const update2 = () => barStyle.value = getBarStyle();
|
|
const saveObserver = [];
|
|
const observerTabs = () => {
|
|
var _a2;
|
|
saveObserver.forEach((observer) => observer.stop());
|
|
saveObserver.length = 0;
|
|
const list = (_a2 = instance.parent) == null ? void 0 : _a2.refs;
|
|
if (!list)
|
|
return;
|
|
for (const key in list) {
|
|
if (key.startsWith("tab-")) {
|
|
const _el = list[key];
|
|
if (_el) {
|
|
saveObserver.push(useResizeObserver(_el, update2));
|
|
}
|
|
}
|
|
}
|
|
};
|
|
watch(() => props2.tabs, async () => {
|
|
await nextTick();
|
|
update2();
|
|
observerTabs();
|
|
}, { immediate: true });
|
|
const barObserever = useResizeObserver(barRef, () => update2());
|
|
onBeforeUnmount(() => {
|
|
saveObserver.forEach((observer) => observer.stop());
|
|
saveObserver.length = 0;
|
|
barObserever.stop();
|
|
});
|
|
expose({
|
|
ref: barRef,
|
|
update: update2
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "barRef",
|
|
ref: barRef,
|
|
class: normalizeClass([unref(ns).e("active-bar"), unref(ns).is(unref(rootTabs).props.tabPosition)]),
|
|
style: normalizeStyle(barStyle.value)
|
|
}, null, 6);
|
|
};
|
|
}
|
|
});
|
|
var TabBar = _export_sfc(_sfc_main127, [["__file", "tab-bar.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tabs/src/tab-nav.mjs
|
|
var tabNavProps = buildProps({
|
|
panes: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([])
|
|
},
|
|
currentName: {
|
|
type: [String, Number],
|
|
default: ""
|
|
},
|
|
editable: Boolean,
|
|
type: {
|
|
type: String,
|
|
values: ["card", "border-card", ""],
|
|
default: ""
|
|
},
|
|
stretch: Boolean
|
|
});
|
|
var tabNavEmits = {
|
|
tabClick: (tab, tabName, ev) => ev instanceof Event,
|
|
tabRemove: (tab, ev) => ev instanceof Event
|
|
};
|
|
var COMPONENT_NAME24 = "ElTabNav";
|
|
var TabNav = defineComponent({
|
|
name: COMPONENT_NAME24,
|
|
props: tabNavProps,
|
|
emits: tabNavEmits,
|
|
setup(props2, {
|
|
expose,
|
|
emit
|
|
}) {
|
|
const rootTabs = inject(tabsRootContextKey);
|
|
if (!rootTabs)
|
|
throwError(COMPONENT_NAME24, `<el-tabs><tab-nav /></el-tabs>`);
|
|
const ns = useNamespace("tabs");
|
|
const visibility = useDocumentVisibility();
|
|
const focused = useWindowFocus();
|
|
const navScroll$ = ref();
|
|
const nav$ = ref();
|
|
const el$ = ref();
|
|
const tabBarRef = ref();
|
|
const scrollable = ref(false);
|
|
const navOffset = ref(0);
|
|
const isFocus = ref(false);
|
|
const focusable = ref(true);
|
|
const sizeName = computed(() => ["top", "bottom"].includes(rootTabs.props.tabPosition) ? "width" : "height");
|
|
const navStyle = computed(() => {
|
|
const dir = sizeName.value === "width" ? "X" : "Y";
|
|
return {
|
|
transform: `translate${dir}(-${navOffset.value}px)`
|
|
};
|
|
});
|
|
const scrollPrev = () => {
|
|
if (!navScroll$.value)
|
|
return;
|
|
const containerSize = navScroll$.value[`offset${capitalize3(sizeName.value)}`];
|
|
const currentOffset = navOffset.value;
|
|
if (!currentOffset)
|
|
return;
|
|
const newOffset = currentOffset > containerSize ? currentOffset - containerSize : 0;
|
|
navOffset.value = newOffset;
|
|
};
|
|
const scrollNext = () => {
|
|
if (!navScroll$.value || !nav$.value)
|
|
return;
|
|
const navSize = nav$.value[`offset${capitalize3(sizeName.value)}`];
|
|
const containerSize = navScroll$.value[`offset${capitalize3(sizeName.value)}`];
|
|
const currentOffset = navOffset.value;
|
|
if (navSize - currentOffset <= containerSize)
|
|
return;
|
|
const newOffset = navSize - currentOffset > containerSize * 2 ? currentOffset + containerSize : navSize - containerSize;
|
|
navOffset.value = newOffset;
|
|
};
|
|
const scrollToActiveTab = async () => {
|
|
const nav = nav$.value;
|
|
if (!scrollable.value || !el$.value || !navScroll$.value || !nav)
|
|
return;
|
|
await nextTick();
|
|
const activeTab = el$.value.querySelector(".is-active");
|
|
if (!activeTab)
|
|
return;
|
|
const navScroll = navScroll$.value;
|
|
const isHorizontal2 = ["top", "bottom"].includes(rootTabs.props.tabPosition);
|
|
const activeTabBounding = activeTab.getBoundingClientRect();
|
|
const navScrollBounding = navScroll.getBoundingClientRect();
|
|
const maxOffset = isHorizontal2 ? nav.offsetWidth - navScrollBounding.width : nav.offsetHeight - navScrollBounding.height;
|
|
const currentOffset = navOffset.value;
|
|
let newOffset = currentOffset;
|
|
if (isHorizontal2) {
|
|
if (activeTabBounding.left < navScrollBounding.left) {
|
|
newOffset = currentOffset - (navScrollBounding.left - activeTabBounding.left);
|
|
}
|
|
if (activeTabBounding.right > navScrollBounding.right) {
|
|
newOffset = currentOffset + activeTabBounding.right - navScrollBounding.right;
|
|
}
|
|
} else {
|
|
if (activeTabBounding.top < navScrollBounding.top) {
|
|
newOffset = currentOffset - (navScrollBounding.top - activeTabBounding.top);
|
|
}
|
|
if (activeTabBounding.bottom > navScrollBounding.bottom) {
|
|
newOffset = currentOffset + (activeTabBounding.bottom - navScrollBounding.bottom);
|
|
}
|
|
}
|
|
newOffset = Math.max(newOffset, 0);
|
|
navOffset.value = Math.min(newOffset, maxOffset);
|
|
};
|
|
const update2 = () => {
|
|
var _a2;
|
|
if (!nav$.value || !navScroll$.value)
|
|
return;
|
|
props2.stretch && ((_a2 = tabBarRef.value) == null ? void 0 : _a2.update());
|
|
const navSize = nav$.value[`offset${capitalize3(sizeName.value)}`];
|
|
const containerSize = navScroll$.value[`offset${capitalize3(sizeName.value)}`];
|
|
const currentOffset = navOffset.value;
|
|
if (containerSize < navSize) {
|
|
scrollable.value = scrollable.value || {};
|
|
scrollable.value.prev = currentOffset;
|
|
scrollable.value.next = currentOffset + containerSize < navSize;
|
|
if (navSize - currentOffset < containerSize) {
|
|
navOffset.value = navSize - containerSize;
|
|
}
|
|
} else {
|
|
scrollable.value = false;
|
|
if (currentOffset > 0) {
|
|
navOffset.value = 0;
|
|
}
|
|
}
|
|
};
|
|
const changeTab = (event) => {
|
|
let step = 0;
|
|
switch (event.code) {
|
|
case EVENT_CODE.left:
|
|
case EVENT_CODE.up:
|
|
step = -1;
|
|
break;
|
|
case EVENT_CODE.right:
|
|
case EVENT_CODE.down:
|
|
step = 1;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
const tabList = Array.from(event.currentTarget.querySelectorAll("[role=tab]:not(.is-disabled)"));
|
|
const currentIndex = tabList.indexOf(event.target);
|
|
let nextIndex = currentIndex + step;
|
|
if (nextIndex < 0) {
|
|
nextIndex = tabList.length - 1;
|
|
} else if (nextIndex >= tabList.length) {
|
|
nextIndex = 0;
|
|
}
|
|
tabList[nextIndex].focus({
|
|
preventScroll: true
|
|
});
|
|
tabList[nextIndex].click();
|
|
setFocus();
|
|
};
|
|
const setFocus = () => {
|
|
if (focusable.value)
|
|
isFocus.value = true;
|
|
};
|
|
const removeFocus = () => isFocus.value = false;
|
|
watch(visibility, (visibility2) => {
|
|
if (visibility2 === "hidden") {
|
|
focusable.value = false;
|
|
} else if (visibility2 === "visible") {
|
|
setTimeout(() => focusable.value = true, 50);
|
|
}
|
|
});
|
|
watch(focused, (focused2) => {
|
|
if (focused2) {
|
|
setTimeout(() => focusable.value = true, 50);
|
|
} else {
|
|
focusable.value = false;
|
|
}
|
|
});
|
|
useResizeObserver(el$, update2);
|
|
onMounted(() => setTimeout(() => scrollToActiveTab(), 0));
|
|
onUpdated(() => update2());
|
|
expose({
|
|
scrollToActiveTab,
|
|
removeFocus,
|
|
tabListRef: nav$,
|
|
tabBarRef
|
|
});
|
|
return () => {
|
|
const scrollBtn = scrollable.value ? [createVNode("span", {
|
|
"class": [ns.e("nav-prev"), ns.is("disabled", !scrollable.value.prev)],
|
|
"onClick": scrollPrev
|
|
}, [createVNode(ElIcon, null, {
|
|
default: () => [createVNode(arrow_left_default, null, null)]
|
|
})]), createVNode("span", {
|
|
"class": [ns.e("nav-next"), ns.is("disabled", !scrollable.value.next)],
|
|
"onClick": scrollNext
|
|
}, [createVNode(ElIcon, null, {
|
|
default: () => [createVNode(arrow_right_default, null, null)]
|
|
})])] : null;
|
|
const tabs = props2.panes.map((pane, index) => {
|
|
var _a2, _b, _c, _d;
|
|
const uid2 = pane.uid;
|
|
const disabled = pane.props.disabled;
|
|
const tabName = (_b = (_a2 = pane.props.name) != null ? _a2 : pane.index) != null ? _b : `${index}`;
|
|
const closable = !disabled && (pane.isClosable || props2.editable);
|
|
pane.index = `${index}`;
|
|
const btnClose = closable ? createVNode(ElIcon, {
|
|
"class": "is-icon-close",
|
|
"onClick": (ev) => emit("tabRemove", pane, ev)
|
|
}, {
|
|
default: () => [createVNode(close_default, null, null)]
|
|
}) : null;
|
|
const tabLabelContent = ((_d = (_c = pane.slots).label) == null ? void 0 : _d.call(_c)) || pane.props.label;
|
|
const tabindex = !disabled && pane.active ? 0 : -1;
|
|
return createVNode("div", {
|
|
"ref": `tab-${uid2}`,
|
|
"class": [ns.e("item"), ns.is(rootTabs.props.tabPosition), ns.is("active", pane.active), ns.is("disabled", disabled), ns.is("closable", closable), ns.is("focus", isFocus.value)],
|
|
"id": `tab-${tabName}`,
|
|
"key": `tab-${uid2}`,
|
|
"aria-controls": `pane-${tabName}`,
|
|
"role": "tab",
|
|
"aria-selected": pane.active,
|
|
"tabindex": tabindex,
|
|
"onFocus": () => setFocus(),
|
|
"onBlur": () => removeFocus(),
|
|
"onClick": (ev) => {
|
|
removeFocus();
|
|
emit("tabClick", pane, tabName, ev);
|
|
},
|
|
"onKeydown": (ev) => {
|
|
if (closable && (ev.code === EVENT_CODE.delete || ev.code === EVENT_CODE.backspace)) {
|
|
emit("tabRemove", pane, ev);
|
|
}
|
|
}
|
|
}, [...[tabLabelContent, btnClose]]);
|
|
});
|
|
return createVNode("div", {
|
|
"ref": el$,
|
|
"class": [ns.e("nav-wrap"), ns.is("scrollable", !!scrollable.value), ns.is(rootTabs.props.tabPosition)]
|
|
}, [scrollBtn, createVNode("div", {
|
|
"class": ns.e("nav-scroll"),
|
|
"ref": navScroll$
|
|
}, [createVNode("div", {
|
|
"class": [ns.e("nav"), ns.is(rootTabs.props.tabPosition), ns.is("stretch", props2.stretch && ["top", "bottom"].includes(rootTabs.props.tabPosition))],
|
|
"ref": nav$,
|
|
"style": navStyle.value,
|
|
"role": "tablist",
|
|
"onKeydown": changeTab
|
|
}, [...[!props2.type ? createVNode(TabBar, {
|
|
"ref": tabBarRef,
|
|
"tabs": [...props2.panes]
|
|
}, null) : null, tabs]])])]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tabs/src/tabs.mjs
|
|
var tabsProps = buildProps({
|
|
type: {
|
|
type: String,
|
|
values: ["card", "border-card", ""],
|
|
default: ""
|
|
},
|
|
closable: Boolean,
|
|
addable: Boolean,
|
|
modelValue: {
|
|
type: [String, Number]
|
|
},
|
|
editable: Boolean,
|
|
tabPosition: {
|
|
type: String,
|
|
values: ["top", "right", "bottom", "left"],
|
|
default: "top"
|
|
},
|
|
beforeLeave: {
|
|
type: definePropType(Function),
|
|
default: () => true
|
|
},
|
|
stretch: Boolean
|
|
});
|
|
var isPaneName = (value) => isString(value) || isNumber2(value);
|
|
var tabsEmits = {
|
|
[UPDATE_MODEL_EVENT]: (name) => isPaneName(name),
|
|
tabClick: (pane, ev) => ev instanceof Event,
|
|
tabChange: (name) => isPaneName(name),
|
|
edit: (paneName, action) => ["remove", "add"].includes(action),
|
|
tabRemove: (name) => isPaneName(name),
|
|
tabAdd: () => true
|
|
};
|
|
var Tabs = defineComponent({
|
|
name: "ElTabs",
|
|
props: tabsProps,
|
|
emits: tabsEmits,
|
|
setup(props2, {
|
|
emit,
|
|
slots,
|
|
expose
|
|
}) {
|
|
var _a2;
|
|
const ns = useNamespace("tabs");
|
|
const isVertical = computed(() => ["left", "right"].includes(props2.tabPosition));
|
|
const {
|
|
children: panes,
|
|
addChild: sortPane,
|
|
removeChild: unregisterPane
|
|
} = useOrderedChildren(getCurrentInstance(), "ElTabPane");
|
|
const nav$ = ref();
|
|
const currentName = ref((_a2 = props2.modelValue) != null ? _a2 : "0");
|
|
const setCurrentName = async (value, trigger = false) => {
|
|
var _a22, _b;
|
|
if (currentName.value === value || isUndefined2(value))
|
|
return;
|
|
try {
|
|
let canLeave;
|
|
if (props2.beforeLeave) {
|
|
const result2 = props2.beforeLeave(value, currentName.value);
|
|
canLeave = result2 instanceof Promise ? await result2 : result2;
|
|
} else {
|
|
canLeave = true;
|
|
}
|
|
if (canLeave !== false) {
|
|
currentName.value = value;
|
|
if (trigger) {
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emit("tabChange", value);
|
|
}
|
|
(_b = (_a22 = nav$.value) == null ? void 0 : _a22.removeFocus) == null ? void 0 : _b.call(_a22);
|
|
}
|
|
} catch (e) {
|
|
}
|
|
};
|
|
const handleTabClick = (tab, tabName, event) => {
|
|
if (tab.props.disabled)
|
|
return;
|
|
emit("tabClick", tab, event);
|
|
setCurrentName(tabName, true);
|
|
};
|
|
const handleTabRemove = (pane, ev) => {
|
|
if (pane.props.disabled || isUndefined2(pane.props.name))
|
|
return;
|
|
ev.stopPropagation();
|
|
emit("edit", pane.props.name, "remove");
|
|
emit("tabRemove", pane.props.name);
|
|
};
|
|
const handleTabAdd = () => {
|
|
emit("edit", void 0, "add");
|
|
emit("tabAdd");
|
|
};
|
|
watch(() => props2.modelValue, (modelValue) => setCurrentName(modelValue));
|
|
watch(currentName, async () => {
|
|
var _a22;
|
|
await nextTick();
|
|
(_a22 = nav$.value) == null ? void 0 : _a22.scrollToActiveTab();
|
|
});
|
|
provide(tabsRootContextKey, {
|
|
props: props2,
|
|
currentName,
|
|
registerPane: (pane) => {
|
|
panes.value.push(pane);
|
|
},
|
|
sortPane,
|
|
unregisterPane
|
|
});
|
|
expose({
|
|
currentName,
|
|
tabNavRef: nav$
|
|
});
|
|
const TabNavRenderer = ({
|
|
render: render2
|
|
}) => {
|
|
return render2();
|
|
};
|
|
return () => {
|
|
const addSlot = slots["add-icon"];
|
|
const newButton = props2.editable || props2.addable ? createVNode("div", {
|
|
"class": [ns.e("new-tab"), isVertical.value && ns.e("new-tab-vertical")],
|
|
"tabindex": "0",
|
|
"onClick": handleTabAdd,
|
|
"onKeydown": (ev) => {
|
|
if ([EVENT_CODE.enter, EVENT_CODE.numpadEnter].includes(ev.code))
|
|
handleTabAdd();
|
|
}
|
|
}, [addSlot ? renderSlot(slots, "add-icon") : createVNode(ElIcon, {
|
|
"class": ns.is("icon-plus")
|
|
}, {
|
|
default: () => [createVNode(plus_default, null, null)]
|
|
})]) : null;
|
|
const header = createVNode("div", {
|
|
"class": [ns.e("header"), isVertical.value && ns.e("header-vertical"), ns.is(props2.tabPosition)]
|
|
}, [createVNode(TabNavRenderer, {
|
|
"render": () => {
|
|
const hasLabelSlot = panes.value.some((pane) => pane.slots.label);
|
|
return createVNode(TabNav, {
|
|
ref: nav$,
|
|
currentName: currentName.value,
|
|
editable: props2.editable,
|
|
type: props2.type,
|
|
panes: panes.value,
|
|
stretch: props2.stretch,
|
|
onTabClick: handleTabClick,
|
|
onTabRemove: handleTabRemove
|
|
}, {
|
|
$stable: !hasLabelSlot
|
|
});
|
|
}
|
|
}, null), newButton]);
|
|
const panels = createVNode("div", {
|
|
"class": ns.e("content")
|
|
}, [renderSlot(slots, "default")]);
|
|
return createVNode("div", {
|
|
"class": [ns.b(), ns.m(props2.tabPosition), {
|
|
[ns.m("card")]: props2.type === "card",
|
|
[ns.m("border-card")]: props2.type === "border-card"
|
|
}]
|
|
}, [panels, header]);
|
|
};
|
|
}
|
|
});
|
|
var Tabs$1 = Tabs;
|
|
|
|
// node_modules/element-plus/es/components/tabs/src/tab-pane.mjs
|
|
var tabPaneProps = buildProps({
|
|
label: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
name: {
|
|
type: [String, Number]
|
|
},
|
|
closable: Boolean,
|
|
disabled: Boolean,
|
|
lazy: Boolean
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tabs/src/tab-pane2.mjs
|
|
var COMPONENT_NAME25 = "ElTabPane";
|
|
var __default__92 = defineComponent({
|
|
name: COMPONENT_NAME25
|
|
});
|
|
var _sfc_main128 = defineComponent({
|
|
...__default__92,
|
|
props: tabPaneProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const instance = getCurrentInstance();
|
|
const slots = useSlots();
|
|
const tabsRoot = inject(tabsRootContextKey);
|
|
if (!tabsRoot)
|
|
throwError(COMPONENT_NAME25, "usage: <el-tabs><el-tab-pane /></el-tabs/>");
|
|
const ns = useNamespace("tab-pane");
|
|
const index = ref();
|
|
const isClosable = computed(() => props2.closable || tabsRoot.props.closable);
|
|
const active = computedEager(() => {
|
|
var _a2;
|
|
return tabsRoot.currentName.value === ((_a2 = props2.name) != null ? _a2 : index.value);
|
|
});
|
|
const loaded = ref(active.value);
|
|
const paneName = computed(() => {
|
|
var _a2;
|
|
return (_a2 = props2.name) != null ? _a2 : index.value;
|
|
});
|
|
const shouldBeRender = computedEager(() => !props2.lazy || loaded.value || active.value);
|
|
watch(active, (val) => {
|
|
if (val)
|
|
loaded.value = true;
|
|
});
|
|
const pane = reactive({
|
|
uid: instance.uid,
|
|
slots,
|
|
props: props2,
|
|
paneName,
|
|
active,
|
|
index,
|
|
isClosable
|
|
});
|
|
tabsRoot.registerPane(pane);
|
|
onMounted(() => {
|
|
tabsRoot.sortPane(pane);
|
|
});
|
|
onUnmounted(() => {
|
|
tabsRoot.unregisterPane(pane.uid);
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return unref(shouldBeRender) ? withDirectives((openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
id: `pane-${unref(paneName)}`,
|
|
class: normalizeClass(unref(ns).b()),
|
|
role: "tabpanel",
|
|
"aria-hidden": !unref(active),
|
|
"aria-labelledby": `tab-${unref(paneName)}`
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 10, ["id", "aria-hidden", "aria-labelledby"])), [
|
|
[vShow, unref(active)]
|
|
]) : createCommentVNode("v-if", true);
|
|
};
|
|
}
|
|
});
|
|
var TabPane = _export_sfc(_sfc_main128, [["__file", "tab-pane.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tabs/index.mjs
|
|
var ElTabs = withInstall(Tabs$1, {
|
|
TabPane
|
|
});
|
|
var ElTabPane = withNoopInstall(TabPane);
|
|
|
|
// node_modules/element-plus/es/components/text/src/text.mjs
|
|
var textProps = buildProps({
|
|
type: {
|
|
type: String,
|
|
values: ["primary", "success", "info", "warning", "danger", ""],
|
|
default: ""
|
|
},
|
|
size: {
|
|
type: String,
|
|
values: componentSizes,
|
|
default: ""
|
|
},
|
|
truncated: Boolean,
|
|
lineClamp: {
|
|
type: [String, Number]
|
|
},
|
|
tag: {
|
|
type: String,
|
|
default: "span"
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/text/src/text2.mjs
|
|
var __default__93 = defineComponent({
|
|
name: "ElText"
|
|
});
|
|
var _sfc_main129 = defineComponent({
|
|
...__default__93,
|
|
props: textProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const textRef = ref();
|
|
const textSize = useFormSize();
|
|
const ns = useNamespace("text");
|
|
const textKls = computed(() => [
|
|
ns.b(),
|
|
ns.m(props2.type),
|
|
ns.m(textSize.value),
|
|
ns.is("truncated", props2.truncated),
|
|
ns.is("line-clamp", !isUndefined2(props2.lineClamp))
|
|
]);
|
|
const inheritTitle = useAttrs().title;
|
|
const bindTitle = () => {
|
|
var _a2, _b, _c, _d, _e, _f, _g;
|
|
if (inheritTitle)
|
|
return;
|
|
let shouldAddTitle = false;
|
|
const text = ((_a2 = textRef.value) == null ? void 0 : _a2.textContent) || "";
|
|
if (props2.truncated) {
|
|
const width = (_b = textRef.value) == null ? void 0 : _b.offsetWidth;
|
|
const scrollWidth = (_c = textRef.value) == null ? void 0 : _c.scrollWidth;
|
|
if (width && scrollWidth && scrollWidth > width) {
|
|
shouldAddTitle = true;
|
|
}
|
|
} else if (!isUndefined2(props2.lineClamp)) {
|
|
const height = (_d = textRef.value) == null ? void 0 : _d.offsetHeight;
|
|
const scrollHeight = (_e = textRef.value) == null ? void 0 : _e.scrollHeight;
|
|
if (height && scrollHeight && scrollHeight > height) {
|
|
shouldAddTitle = true;
|
|
}
|
|
}
|
|
if (shouldAddTitle) {
|
|
(_f = textRef.value) == null ? void 0 : _f.setAttribute("title", text);
|
|
} else {
|
|
(_g = textRef.value) == null ? void 0 : _g.removeAttribute("title");
|
|
}
|
|
};
|
|
onMounted(bindTitle);
|
|
onUpdated(bindTitle);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(resolveDynamicComponent(_ctx.tag), {
|
|
ref_key: "textRef",
|
|
ref: textRef,
|
|
class: normalizeClass(unref(textKls)),
|
|
style: normalizeStyle({ "-webkit-line-clamp": _ctx.lineClamp })
|
|
}, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 8, ["class", "style"]);
|
|
};
|
|
}
|
|
});
|
|
var Text2 = _export_sfc(_sfc_main129, [["__file", "text.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/text/index.mjs
|
|
var ElText = withInstall(Text2);
|
|
|
|
// node_modules/element-plus/es/components/time-select/src/time-select.mjs
|
|
var timeSelectProps = buildProps({
|
|
format: {
|
|
type: String,
|
|
default: "HH:mm"
|
|
},
|
|
modelValue: String,
|
|
disabled: Boolean,
|
|
editable: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
effect: {
|
|
type: definePropType(String),
|
|
default: "light"
|
|
},
|
|
clearable: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
size: useSizeProp,
|
|
placeholder: String,
|
|
start: {
|
|
type: String,
|
|
default: "09:00"
|
|
},
|
|
end: {
|
|
type: String,
|
|
default: "18:00"
|
|
},
|
|
step: {
|
|
type: String,
|
|
default: "00:30"
|
|
},
|
|
minTime: String,
|
|
maxTime: String,
|
|
includeEndTime: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
name: String,
|
|
prefixIcon: {
|
|
type: definePropType([String, Object]),
|
|
default: () => clock_default
|
|
},
|
|
clearIcon: {
|
|
type: definePropType([String, Object]),
|
|
default: () => circle_close_default
|
|
},
|
|
...useEmptyValuesProps
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/time-select/src/time-select2.mjs
|
|
var import_dayjs18 = __toModule(require_dayjs_min());
|
|
var import_customParseFormat3 = __toModule(require_customParseFormat());
|
|
|
|
// node_modules/element-plus/es/components/time-select/src/utils.mjs
|
|
var parseTime = (time) => {
|
|
const values2 = (time || "").split(":");
|
|
if (values2.length >= 2) {
|
|
let hours = Number.parseInt(values2[0], 10);
|
|
const minutes = Number.parseInt(values2[1], 10);
|
|
const timeUpper = time.toUpperCase();
|
|
if (timeUpper.includes("AM") && hours === 12) {
|
|
hours = 0;
|
|
} else if (timeUpper.includes("PM") && hours !== 12) {
|
|
hours += 12;
|
|
}
|
|
return {
|
|
hours,
|
|
minutes
|
|
};
|
|
}
|
|
return null;
|
|
};
|
|
var compareTime = (time1, time2) => {
|
|
const value1 = parseTime(time1);
|
|
if (!value1)
|
|
return -1;
|
|
const value2 = parseTime(time2);
|
|
if (!value2)
|
|
return -1;
|
|
const minutes1 = value1.minutes + value1.hours * 60;
|
|
const minutes2 = value2.minutes + value2.hours * 60;
|
|
if (minutes1 === minutes2) {
|
|
return 0;
|
|
}
|
|
return minutes1 > minutes2 ? 1 : -1;
|
|
};
|
|
var padTime = (time) => {
|
|
return `${time}`.padStart(2, "0");
|
|
};
|
|
var formatTime2 = (time) => {
|
|
return `${padTime(time.hours)}:${padTime(time.minutes)}`;
|
|
};
|
|
var nextTime = (time, step) => {
|
|
const timeValue = parseTime(time);
|
|
if (!timeValue)
|
|
return "";
|
|
const stepValue = parseTime(step);
|
|
if (!stepValue)
|
|
return "";
|
|
const next = {
|
|
hours: timeValue.hours,
|
|
minutes: timeValue.minutes
|
|
};
|
|
next.minutes += stepValue.minutes;
|
|
next.hours += stepValue.hours;
|
|
next.hours += Math.floor(next.minutes / 60);
|
|
next.minutes = next.minutes % 60;
|
|
return formatTime2(next);
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/time-select/src/time-select2.mjs
|
|
var __default__94 = defineComponent({
|
|
name: "ElTimeSelect"
|
|
});
|
|
var _sfc_main130 = defineComponent({
|
|
...__default__94,
|
|
props: timeSelectProps,
|
|
emits: [CHANGE_EVENT, "blur", "focus", "clear", UPDATE_MODEL_EVENT],
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
import_dayjs18.default.extend(import_customParseFormat3.default);
|
|
const { Option: ElOption2 } = ElSelect;
|
|
const nsInput = useNamespace("input");
|
|
const select = ref();
|
|
const _disabled = useFormDisabled();
|
|
const { lang } = useLocale();
|
|
const value = computed(() => props2.modelValue);
|
|
const start = computed(() => {
|
|
const time = parseTime(props2.start);
|
|
return time ? formatTime2(time) : null;
|
|
});
|
|
const end = computed(() => {
|
|
const time = parseTime(props2.end);
|
|
return time ? formatTime2(time) : null;
|
|
});
|
|
const step = computed(() => {
|
|
const time = parseTime(props2.step);
|
|
return time ? formatTime2(time) : null;
|
|
});
|
|
const minTime = computed(() => {
|
|
const time = parseTime(props2.minTime || "");
|
|
return time ? formatTime2(time) : null;
|
|
});
|
|
const maxTime = computed(() => {
|
|
const time = parseTime(props2.maxTime || "");
|
|
return time ? formatTime2(time) : null;
|
|
});
|
|
const items = computed(() => {
|
|
var _a2;
|
|
const result2 = [];
|
|
const push = (formattedValue, rawValue) => {
|
|
result2.push({
|
|
value: formattedValue,
|
|
disabled: compareTime(rawValue, minTime.value || "-1:-1") <= 0 || compareTime(rawValue, maxTime.value || "100:100") >= 0
|
|
});
|
|
};
|
|
if (props2.start && props2.end && props2.step) {
|
|
let current = start.value;
|
|
let currentTime;
|
|
while (current && end.value && compareTime(current, end.value) <= 0) {
|
|
currentTime = (0, import_dayjs18.default)(current, "HH:mm").locale(lang.value).format(props2.format);
|
|
push(currentTime, current);
|
|
current = nextTime(current, step.value);
|
|
}
|
|
if (props2.includeEndTime && end.value && ((_a2 = result2[result2.length - 1]) == null ? void 0 : _a2.value) !== end.value) {
|
|
const formattedValue = (0, import_dayjs18.default)(end.value, "HH:mm").locale(lang.value).format(props2.format);
|
|
push(formattedValue, end.value);
|
|
}
|
|
}
|
|
return result2;
|
|
});
|
|
const blur = () => {
|
|
var _a2, _b;
|
|
(_b = (_a2 = select.value) == null ? void 0 : _a2.blur) == null ? void 0 : _b.call(_a2);
|
|
};
|
|
const focus = () => {
|
|
var _a2, _b;
|
|
(_b = (_a2 = select.value) == null ? void 0 : _a2.focus) == null ? void 0 : _b.call(_a2);
|
|
};
|
|
expose({
|
|
blur,
|
|
focus
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElSelect), {
|
|
ref_key: "select",
|
|
ref: select,
|
|
"model-value": unref(value),
|
|
disabled: unref(_disabled),
|
|
clearable: _ctx.clearable,
|
|
"clear-icon": _ctx.clearIcon,
|
|
size: _ctx.size,
|
|
effect: _ctx.effect,
|
|
placeholder: _ctx.placeholder,
|
|
"default-first-option": "",
|
|
filterable: _ctx.editable,
|
|
"empty-values": _ctx.emptyValues,
|
|
"value-on-clear": _ctx.valueOnClear,
|
|
"onUpdate:modelValue": (event) => _ctx.$emit(unref(UPDATE_MODEL_EVENT), event),
|
|
onChange: (event) => _ctx.$emit(unref(CHANGE_EVENT), event),
|
|
onBlur: (event) => _ctx.$emit("blur", event),
|
|
onFocus: (event) => _ctx.$emit("focus", event),
|
|
onClear: () => _ctx.$emit("clear")
|
|
}, {
|
|
prefix: withCtx(() => [
|
|
_ctx.prefixIcon ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(nsInput).e("prefix-icon"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.prefixIcon)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true)
|
|
]),
|
|
default: withCtx(() => [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(items), (item) => {
|
|
return openBlock(), createBlock(unref(ElOption2), {
|
|
key: item.value,
|
|
label: item.value,
|
|
value: item.value,
|
|
disabled: item.disabled
|
|
}, null, 8, ["label", "value", "disabled"]);
|
|
}), 128))
|
|
]),
|
|
_: 1
|
|
}, 8, ["model-value", "disabled", "clearable", "clear-icon", "size", "effect", "placeholder", "filterable", "empty-values", "value-on-clear", "onUpdate:modelValue", "onChange", "onBlur", "onFocus", "onClear"]);
|
|
};
|
|
}
|
|
});
|
|
var TimeSelect = _export_sfc(_sfc_main130, [["__file", "time-select.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/time-select/index.mjs
|
|
var ElTimeSelect = withInstall(TimeSelect);
|
|
|
|
// node_modules/element-plus/es/components/timeline/src/timeline-item.mjs
|
|
var timelineItemProps = buildProps({
|
|
timestamp: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
hideTimestamp: Boolean,
|
|
center: Boolean,
|
|
placement: {
|
|
type: String,
|
|
values: ["top", "bottom"],
|
|
default: "bottom"
|
|
},
|
|
type: {
|
|
type: String,
|
|
values: ["primary", "success", "warning", "danger", "info"],
|
|
default: ""
|
|
},
|
|
color: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
size: {
|
|
type: String,
|
|
values: ["normal", "large"],
|
|
default: "normal"
|
|
},
|
|
icon: {
|
|
type: iconPropType
|
|
},
|
|
hollow: Boolean
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/timeline/src/timeline.mjs
|
|
var Timeline = defineComponent({
|
|
name: "ElTimeline",
|
|
setup(_2, { slots }) {
|
|
const ns = useNamespace("timeline");
|
|
provide("timeline", slots);
|
|
return () => {
|
|
return h("ul", { class: [ns.b()] }, [renderSlot(slots, "default")]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/timeline/src/timeline-item2.mjs
|
|
var __default__95 = defineComponent({
|
|
name: "ElTimelineItem"
|
|
});
|
|
var _sfc_main131 = defineComponent({
|
|
...__default__95,
|
|
props: timelineItemProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("timeline-item");
|
|
const defaultNodeKls = computed(() => [
|
|
ns.e("node"),
|
|
ns.em("node", props2.size || ""),
|
|
ns.em("node", props2.type || ""),
|
|
ns.is("hollow", props2.hollow)
|
|
]);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("li", {
|
|
class: normalizeClass([unref(ns).b(), { [unref(ns).e("center")]: _ctx.center }])
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("tail"))
|
|
}, null, 2),
|
|
!_ctx.$slots.dot ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(defaultNodeKls)),
|
|
style: normalizeStyle({
|
|
backgroundColor: _ctx.color
|
|
})
|
|
}, [
|
|
_ctx.icon ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("icon"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true)
|
|
], 6)) : createCommentVNode("v-if", true),
|
|
_ctx.$slots.dot ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("dot"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "dot")
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("wrapper"))
|
|
}, [
|
|
!_ctx.hideTimestamp && _ctx.placement === "top" ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("timestamp"), unref(ns).is("top")])
|
|
}, toDisplayString(_ctx.timestamp), 3)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("content"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2),
|
|
!_ctx.hideTimestamp && _ctx.placement === "bottom" ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass([unref(ns).e("timestamp"), unref(ns).is("bottom")])
|
|
}, toDisplayString(_ctx.timestamp), 3)) : createCommentVNode("v-if", true)
|
|
], 2)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var TimelineItem = _export_sfc(_sfc_main131, [["__file", "timeline-item.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/timeline/index.mjs
|
|
var ElTimeline = withInstall(Timeline, {
|
|
TimelineItem
|
|
});
|
|
var ElTimelineItem = withNoopInstall(TimelineItem);
|
|
|
|
// node_modules/@floating-ui/utils/dist/floating-ui.utils.esm.js
|
|
var sides = ["top", "right", "bottom", "left"];
|
|
var alignments = ["start", "end"];
|
|
var placements = sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
|
|
var min3 = Math.min;
|
|
var max3 = Math.max;
|
|
var round2 = Math.round;
|
|
var floor3 = Math.floor;
|
|
var createCoords = (v2) => ({
|
|
x: v2,
|
|
y: v2
|
|
});
|
|
var oppositeSideMap = {
|
|
left: "right",
|
|
right: "left",
|
|
bottom: "top",
|
|
top: "bottom"
|
|
};
|
|
var oppositeAlignmentMap = {
|
|
start: "end",
|
|
end: "start"
|
|
};
|
|
function clamp3(start, value, end) {
|
|
return max3(start, min3(value, end));
|
|
}
|
|
function evaluate(value, param) {
|
|
return typeof value === "function" ? value(param) : value;
|
|
}
|
|
function getSide(placement) {
|
|
return placement.split("-")[0];
|
|
}
|
|
function getAlignment(placement) {
|
|
return placement.split("-")[1];
|
|
}
|
|
function getOppositeAxis(axis) {
|
|
return axis === "x" ? "y" : "x";
|
|
}
|
|
function getAxisLength(axis) {
|
|
return axis === "y" ? "height" : "width";
|
|
}
|
|
function getSideAxis(placement) {
|
|
return ["top", "bottom"].includes(getSide(placement)) ? "y" : "x";
|
|
}
|
|
function getAlignmentAxis(placement) {
|
|
return getOppositeAxis(getSideAxis(placement));
|
|
}
|
|
function getAlignmentSides(placement, rects, rtl) {
|
|
if (rtl === void 0) {
|
|
rtl = false;
|
|
}
|
|
const alignment = getAlignment(placement);
|
|
const alignmentAxis = getAlignmentAxis(placement);
|
|
const length = getAxisLength(alignmentAxis);
|
|
let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
|
|
if (rects.reference[length] > rects.floating[length]) {
|
|
mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
|
|
}
|
|
return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
|
|
}
|
|
function getExpandedPlacements(placement) {
|
|
const oppositePlacement = getOppositePlacement(placement);
|
|
return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
|
|
}
|
|
function getOppositeAlignmentPlacement(placement) {
|
|
return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
|
|
}
|
|
function getSideList(side, isStart, rtl) {
|
|
const lr = ["left", "right"];
|
|
const rl = ["right", "left"];
|
|
const tb = ["top", "bottom"];
|
|
const bt2 = ["bottom", "top"];
|
|
switch (side) {
|
|
case "top":
|
|
case "bottom":
|
|
if (rtl)
|
|
return isStart ? rl : lr;
|
|
return isStart ? lr : rl;
|
|
case "left":
|
|
case "right":
|
|
return isStart ? tb : bt2;
|
|
default:
|
|
return [];
|
|
}
|
|
}
|
|
function getOppositeAxisPlacements(placement, flipAlignment, direction2, rtl) {
|
|
const alignment = getAlignment(placement);
|
|
let list = getSideList(getSide(placement), direction2 === "start", rtl);
|
|
if (alignment) {
|
|
list = list.map((side) => side + "-" + alignment);
|
|
if (flipAlignment) {
|
|
list = list.concat(list.map(getOppositeAlignmentPlacement));
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
function getOppositePlacement(placement) {
|
|
return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
|
|
}
|
|
function expandPaddingObject(padding) {
|
|
return {
|
|
top: 0,
|
|
right: 0,
|
|
bottom: 0,
|
|
left: 0,
|
|
...padding
|
|
};
|
|
}
|
|
function getPaddingObject(padding) {
|
|
return typeof padding !== "number" ? expandPaddingObject(padding) : {
|
|
top: padding,
|
|
right: padding,
|
|
bottom: padding,
|
|
left: padding
|
|
};
|
|
}
|
|
function rectToClientRect(rect) {
|
|
const {
|
|
x: x2,
|
|
y,
|
|
width,
|
|
height
|
|
} = rect;
|
|
return {
|
|
width,
|
|
height,
|
|
top: y,
|
|
left: x2,
|
|
right: x2 + width,
|
|
bottom: y + height,
|
|
x: x2,
|
|
y
|
|
};
|
|
}
|
|
|
|
// node_modules/@floating-ui/core/dist/floating-ui.core.esm.js
|
|
function computeCoordsFromPlacement(_ref, placement, rtl) {
|
|
let {
|
|
reference,
|
|
floating
|
|
} = _ref;
|
|
const sideAxis = getSideAxis(placement);
|
|
const alignmentAxis = getAlignmentAxis(placement);
|
|
const alignLength = getAxisLength(alignmentAxis);
|
|
const side = getSide(placement);
|
|
const isVertical = sideAxis === "y";
|
|
const commonX = reference.x + reference.width / 2 - floating.width / 2;
|
|
const commonY = reference.y + reference.height / 2 - floating.height / 2;
|
|
const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
|
|
let coords;
|
|
switch (side) {
|
|
case "top":
|
|
coords = {
|
|
x: commonX,
|
|
y: reference.y - floating.height
|
|
};
|
|
break;
|
|
case "bottom":
|
|
coords = {
|
|
x: commonX,
|
|
y: reference.y + reference.height
|
|
};
|
|
break;
|
|
case "right":
|
|
coords = {
|
|
x: reference.x + reference.width,
|
|
y: commonY
|
|
};
|
|
break;
|
|
case "left":
|
|
coords = {
|
|
x: reference.x - floating.width,
|
|
y: commonY
|
|
};
|
|
break;
|
|
default:
|
|
coords = {
|
|
x: reference.x,
|
|
y: reference.y
|
|
};
|
|
}
|
|
switch (getAlignment(placement)) {
|
|
case "start":
|
|
coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
|
|
break;
|
|
case "end":
|
|
coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
|
|
break;
|
|
}
|
|
return coords;
|
|
}
|
|
var computePosition = async (reference, floating, config) => {
|
|
const {
|
|
placement = "bottom",
|
|
strategy = "absolute",
|
|
middleware = [],
|
|
platform: platform2
|
|
} = config;
|
|
const validMiddleware = middleware.filter(Boolean);
|
|
const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
|
|
let rects = await platform2.getElementRects({
|
|
reference,
|
|
floating,
|
|
strategy
|
|
});
|
|
let {
|
|
x: x2,
|
|
y
|
|
} = computeCoordsFromPlacement(rects, placement, rtl);
|
|
let statefulPlacement = placement;
|
|
let middlewareData = {};
|
|
let resetCount = 0;
|
|
for (let i = 0; i < validMiddleware.length; i++) {
|
|
const {
|
|
name,
|
|
fn: fn2
|
|
} = validMiddleware[i];
|
|
const {
|
|
x: nextX,
|
|
y: nextY,
|
|
data,
|
|
reset
|
|
} = await fn2({
|
|
x: x2,
|
|
y,
|
|
initialPlacement: placement,
|
|
placement: statefulPlacement,
|
|
strategy,
|
|
middlewareData,
|
|
rects,
|
|
platform: platform2,
|
|
elements: {
|
|
reference,
|
|
floating
|
|
}
|
|
});
|
|
x2 = nextX != null ? nextX : x2;
|
|
y = nextY != null ? nextY : y;
|
|
middlewareData = {
|
|
...middlewareData,
|
|
[name]: {
|
|
...middlewareData[name],
|
|
...data
|
|
}
|
|
};
|
|
if (reset && resetCount <= 50) {
|
|
resetCount++;
|
|
if (typeof reset === "object") {
|
|
if (reset.placement) {
|
|
statefulPlacement = reset.placement;
|
|
}
|
|
if (reset.rects) {
|
|
rects = reset.rects === true ? await platform2.getElementRects({
|
|
reference,
|
|
floating,
|
|
strategy
|
|
}) : reset.rects;
|
|
}
|
|
({
|
|
x: x2,
|
|
y
|
|
} = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
|
|
}
|
|
i = -1;
|
|
}
|
|
}
|
|
return {
|
|
x: x2,
|
|
y,
|
|
placement: statefulPlacement,
|
|
strategy,
|
|
middlewareData
|
|
};
|
|
};
|
|
async function detectOverflow(state, options) {
|
|
var _await$platform$isEle;
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
const {
|
|
x: x2,
|
|
y,
|
|
platform: platform2,
|
|
rects,
|
|
elements,
|
|
strategy
|
|
} = state;
|
|
const {
|
|
boundary = "clippingAncestors",
|
|
rootBoundary = "viewport",
|
|
elementContext = "floating",
|
|
altBoundary = false,
|
|
padding = 0
|
|
} = evaluate(options, state);
|
|
const paddingObject = getPaddingObject(padding);
|
|
const altContext = elementContext === "floating" ? "reference" : "floating";
|
|
const element = elements[altBoundary ? altContext : elementContext];
|
|
const clippingClientRect = rectToClientRect(await platform2.getClippingRect({
|
|
element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
|
|
boundary,
|
|
rootBoundary,
|
|
strategy
|
|
}));
|
|
const rect = elementContext === "floating" ? {
|
|
x: x2,
|
|
y,
|
|
width: rects.floating.width,
|
|
height: rects.floating.height
|
|
} : rects.reference;
|
|
const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating));
|
|
const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
|
|
x: 1,
|
|
y: 1
|
|
} : {
|
|
x: 1,
|
|
y: 1
|
|
};
|
|
const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
|
|
elements,
|
|
rect,
|
|
offsetParent,
|
|
strategy
|
|
}) : rect);
|
|
return {
|
|
top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
|
|
bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
|
|
left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
|
|
right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
|
|
};
|
|
}
|
|
var arrow = (options) => ({
|
|
name: "arrow",
|
|
options,
|
|
async fn(state) {
|
|
const {
|
|
x: x2,
|
|
y,
|
|
placement,
|
|
rects,
|
|
platform: platform2,
|
|
elements,
|
|
middlewareData
|
|
} = state;
|
|
const {
|
|
element,
|
|
padding = 0
|
|
} = evaluate(options, state) || {};
|
|
if (element == null) {
|
|
return {};
|
|
}
|
|
const paddingObject = getPaddingObject(padding);
|
|
const coords = {
|
|
x: x2,
|
|
y
|
|
};
|
|
const axis = getAlignmentAxis(placement);
|
|
const length = getAxisLength(axis);
|
|
const arrowDimensions = await platform2.getDimensions(element);
|
|
const isYAxis = axis === "y";
|
|
const minProp = isYAxis ? "top" : "left";
|
|
const maxProp = isYAxis ? "bottom" : "right";
|
|
const clientProp = isYAxis ? "clientHeight" : "clientWidth";
|
|
const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
|
|
const startDiff = coords[axis] - rects.reference[axis];
|
|
const arrowOffsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(element));
|
|
let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
|
|
if (!clientSize || !await (platform2.isElement == null ? void 0 : platform2.isElement(arrowOffsetParent))) {
|
|
clientSize = elements.floating[clientProp] || rects.floating[length];
|
|
}
|
|
const centerToReference = endDiff / 2 - startDiff / 2;
|
|
const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
|
|
const minPadding = min3(paddingObject[minProp], largestPossiblePadding);
|
|
const maxPadding = min3(paddingObject[maxProp], largestPossiblePadding);
|
|
const min$1 = minPadding;
|
|
const max4 = clientSize - arrowDimensions[length] - maxPadding;
|
|
const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
|
|
const offset3 = clamp3(min$1, center, max4);
|
|
const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset3 && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
|
|
const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max4 : 0;
|
|
return {
|
|
[axis]: coords[axis] + alignmentOffset,
|
|
data: {
|
|
[axis]: offset3,
|
|
centerOffset: center - offset3 - alignmentOffset,
|
|
...shouldAddOffset && {
|
|
alignmentOffset
|
|
}
|
|
},
|
|
reset: shouldAddOffset
|
|
};
|
|
}
|
|
});
|
|
var flip2 = function(options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
return {
|
|
name: "flip",
|
|
options,
|
|
async fn(state) {
|
|
var _middlewareData$arrow, _middlewareData$flip;
|
|
const {
|
|
placement,
|
|
middlewareData,
|
|
rects,
|
|
initialPlacement,
|
|
platform: platform2,
|
|
elements
|
|
} = state;
|
|
const {
|
|
mainAxis: checkMainAxis = true,
|
|
crossAxis: checkCrossAxis = true,
|
|
fallbackPlacements: specifiedFallbackPlacements,
|
|
fallbackStrategy = "bestFit",
|
|
fallbackAxisSideDirection = "none",
|
|
flipAlignment = true,
|
|
...detectOverflowOptions
|
|
} = evaluate(options, state);
|
|
if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
|
|
return {};
|
|
}
|
|
const side = getSide(placement);
|
|
const initialSideAxis = getSideAxis(initialPlacement);
|
|
const isBasePlacement = getSide(initialPlacement) === initialPlacement;
|
|
const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
|
|
const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
|
|
const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
|
|
if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
|
|
fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
|
|
}
|
|
const placements2 = [initialPlacement, ...fallbackPlacements];
|
|
const overflow = await detectOverflow(state, detectOverflowOptions);
|
|
const overflows = [];
|
|
let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
|
|
if (checkMainAxis) {
|
|
overflows.push(overflow[side]);
|
|
}
|
|
if (checkCrossAxis) {
|
|
const sides2 = getAlignmentSides(placement, rects, rtl);
|
|
overflows.push(overflow[sides2[0]], overflow[sides2[1]]);
|
|
}
|
|
overflowsData = [...overflowsData, {
|
|
placement,
|
|
overflows
|
|
}];
|
|
if (!overflows.every((side2) => side2 <= 0)) {
|
|
var _middlewareData$flip2, _overflowsData$filter;
|
|
const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
|
|
const nextPlacement = placements2[nextIndex];
|
|
if (nextPlacement) {
|
|
return {
|
|
data: {
|
|
index: nextIndex,
|
|
overflows: overflowsData
|
|
},
|
|
reset: {
|
|
placement: nextPlacement
|
|
}
|
|
};
|
|
}
|
|
let resetPlacement = (_overflowsData$filter = overflowsData.filter((d2) => d2.overflows[0] <= 0).sort((a2, b2) => a2.overflows[1] - b2.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
|
|
if (!resetPlacement) {
|
|
switch (fallbackStrategy) {
|
|
case "bestFit": {
|
|
var _overflowsData$filter2;
|
|
const placement2 = (_overflowsData$filter2 = overflowsData.filter((d2) => {
|
|
if (hasFallbackAxisSideDirection) {
|
|
const currentSideAxis = getSideAxis(d2.placement);
|
|
return currentSideAxis === initialSideAxis || currentSideAxis === "y";
|
|
}
|
|
return true;
|
|
}).map((d2) => [d2.placement, d2.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a2, b2) => a2[1] - b2[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
|
|
if (placement2) {
|
|
resetPlacement = placement2;
|
|
}
|
|
break;
|
|
}
|
|
case "initialPlacement":
|
|
resetPlacement = initialPlacement;
|
|
break;
|
|
}
|
|
}
|
|
if (placement !== resetPlacement) {
|
|
return {
|
|
reset: {
|
|
placement: resetPlacement
|
|
}
|
|
};
|
|
}
|
|
}
|
|
return {};
|
|
}
|
|
};
|
|
};
|
|
async function convertValueToCoords(state, options) {
|
|
const {
|
|
placement,
|
|
platform: platform2,
|
|
elements
|
|
} = state;
|
|
const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
|
|
const side = getSide(placement);
|
|
const alignment = getAlignment(placement);
|
|
const isVertical = getSideAxis(placement) === "y";
|
|
const mainAxisMulti = ["left", "top"].includes(side) ? -1 : 1;
|
|
const crossAxisMulti = rtl && isVertical ? -1 : 1;
|
|
const rawValue = evaluate(options, state);
|
|
let {
|
|
mainAxis,
|
|
crossAxis,
|
|
alignmentAxis
|
|
} = typeof rawValue === "number" ? {
|
|
mainAxis: rawValue,
|
|
crossAxis: 0,
|
|
alignmentAxis: null
|
|
} : {
|
|
mainAxis: rawValue.mainAxis || 0,
|
|
crossAxis: rawValue.crossAxis || 0,
|
|
alignmentAxis: rawValue.alignmentAxis
|
|
};
|
|
if (alignment && typeof alignmentAxis === "number") {
|
|
crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
|
|
}
|
|
return isVertical ? {
|
|
x: crossAxis * crossAxisMulti,
|
|
y: mainAxis * mainAxisMulti
|
|
} : {
|
|
x: mainAxis * mainAxisMulti,
|
|
y: crossAxis * crossAxisMulti
|
|
};
|
|
}
|
|
var offset = function(options) {
|
|
if (options === void 0) {
|
|
options = 0;
|
|
}
|
|
return {
|
|
name: "offset",
|
|
options,
|
|
async fn(state) {
|
|
var _middlewareData$offse, _middlewareData$arrow;
|
|
const {
|
|
x: x2,
|
|
y,
|
|
placement,
|
|
middlewareData
|
|
} = state;
|
|
const diffCoords = await convertValueToCoords(state, options);
|
|
if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
|
|
return {};
|
|
}
|
|
return {
|
|
x: x2 + diffCoords.x,
|
|
y: y + diffCoords.y,
|
|
data: {
|
|
...diffCoords,
|
|
placement
|
|
}
|
|
};
|
|
}
|
|
};
|
|
};
|
|
var shift = function(options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
return {
|
|
name: "shift",
|
|
options,
|
|
async fn(state) {
|
|
const {
|
|
x: x2,
|
|
y,
|
|
placement
|
|
} = state;
|
|
const {
|
|
mainAxis: checkMainAxis = true,
|
|
crossAxis: checkCrossAxis = false,
|
|
limiter = {
|
|
fn: (_ref) => {
|
|
let {
|
|
x: x3,
|
|
y: y2
|
|
} = _ref;
|
|
return {
|
|
x: x3,
|
|
y: y2
|
|
};
|
|
}
|
|
},
|
|
...detectOverflowOptions
|
|
} = evaluate(options, state);
|
|
const coords = {
|
|
x: x2,
|
|
y
|
|
};
|
|
const overflow = await detectOverflow(state, detectOverflowOptions);
|
|
const crossAxis = getSideAxis(getSide(placement));
|
|
const mainAxis = getOppositeAxis(crossAxis);
|
|
let mainAxisCoord = coords[mainAxis];
|
|
let crossAxisCoord = coords[crossAxis];
|
|
if (checkMainAxis) {
|
|
const minSide = mainAxis === "y" ? "top" : "left";
|
|
const maxSide = mainAxis === "y" ? "bottom" : "right";
|
|
const min4 = mainAxisCoord + overflow[minSide];
|
|
const max4 = mainAxisCoord - overflow[maxSide];
|
|
mainAxisCoord = clamp3(min4, mainAxisCoord, max4);
|
|
}
|
|
if (checkCrossAxis) {
|
|
const minSide = crossAxis === "y" ? "top" : "left";
|
|
const maxSide = crossAxis === "y" ? "bottom" : "right";
|
|
const min4 = crossAxisCoord + overflow[minSide];
|
|
const max4 = crossAxisCoord - overflow[maxSide];
|
|
crossAxisCoord = clamp3(min4, crossAxisCoord, max4);
|
|
}
|
|
const limitedCoords = limiter.fn({
|
|
...state,
|
|
[mainAxis]: mainAxisCoord,
|
|
[crossAxis]: crossAxisCoord
|
|
});
|
|
return {
|
|
...limitedCoords,
|
|
data: {
|
|
x: limitedCoords.x - x2,
|
|
y: limitedCoords.y - y,
|
|
enabled: {
|
|
[mainAxis]: checkMainAxis,
|
|
[crossAxis]: checkCrossAxis
|
|
}
|
|
}
|
|
};
|
|
}
|
|
};
|
|
};
|
|
|
|
// node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
|
|
function hasWindow() {
|
|
return typeof window !== "undefined";
|
|
}
|
|
function getNodeName(node) {
|
|
if (isNode(node)) {
|
|
return (node.nodeName || "").toLowerCase();
|
|
}
|
|
return "#document";
|
|
}
|
|
function getWindow(node) {
|
|
var _node$ownerDocument;
|
|
return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
|
|
}
|
|
function getDocumentElement(node) {
|
|
var _ref;
|
|
return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
|
|
}
|
|
function isNode(value) {
|
|
if (!hasWindow()) {
|
|
return false;
|
|
}
|
|
return value instanceof Node || value instanceof getWindow(value).Node;
|
|
}
|
|
function isElement3(value) {
|
|
if (!hasWindow()) {
|
|
return false;
|
|
}
|
|
return value instanceof Element || value instanceof getWindow(value).Element;
|
|
}
|
|
function isHTMLElement(value) {
|
|
if (!hasWindow()) {
|
|
return false;
|
|
}
|
|
return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
|
|
}
|
|
function isShadowRoot(value) {
|
|
if (!hasWindow() || typeof ShadowRoot === "undefined") {
|
|
return false;
|
|
}
|
|
return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
|
|
}
|
|
function isOverflowElement(element) {
|
|
const {
|
|
overflow,
|
|
overflowX,
|
|
overflowY,
|
|
display
|
|
} = getComputedStyle2(element);
|
|
return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !["inline", "contents"].includes(display);
|
|
}
|
|
function isTableElement(element) {
|
|
return ["table", "td", "th"].includes(getNodeName(element));
|
|
}
|
|
function isTopLayer(element) {
|
|
return [":popover-open", ":modal"].some((selector) => {
|
|
try {
|
|
return element.matches(selector);
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
});
|
|
}
|
|
function isContainingBlock(elementOrCss) {
|
|
const webkit = isWebKit();
|
|
const css = isElement3(elementOrCss) ? getComputedStyle2(elementOrCss) : elementOrCss;
|
|
return ["transform", "translate", "scale", "rotate", "perspective"].some((value) => css[value] ? css[value] !== "none" : false) || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || ["transform", "translate", "scale", "rotate", "perspective", "filter"].some((value) => (css.willChange || "").includes(value)) || ["paint", "layout", "strict", "content"].some((value) => (css.contain || "").includes(value));
|
|
}
|
|
function getContainingBlock(element) {
|
|
let currentNode = getParentNode(element);
|
|
while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
|
|
if (isContainingBlock(currentNode)) {
|
|
return currentNode;
|
|
} else if (isTopLayer(currentNode)) {
|
|
return null;
|
|
}
|
|
currentNode = getParentNode(currentNode);
|
|
}
|
|
return null;
|
|
}
|
|
function isWebKit() {
|
|
if (typeof CSS === "undefined" || !CSS.supports)
|
|
return false;
|
|
return CSS.supports("-webkit-backdrop-filter", "none");
|
|
}
|
|
function isLastTraversableNode(node) {
|
|
return ["html", "body", "#document"].includes(getNodeName(node));
|
|
}
|
|
function getComputedStyle2(element) {
|
|
return getWindow(element).getComputedStyle(element);
|
|
}
|
|
function getNodeScroll(element) {
|
|
if (isElement3(element)) {
|
|
return {
|
|
scrollLeft: element.scrollLeft,
|
|
scrollTop: element.scrollTop
|
|
};
|
|
}
|
|
return {
|
|
scrollLeft: element.scrollX,
|
|
scrollTop: element.scrollY
|
|
};
|
|
}
|
|
function getParentNode(node) {
|
|
if (getNodeName(node) === "html") {
|
|
return node;
|
|
}
|
|
const result2 = node.assignedSlot || node.parentNode || isShadowRoot(node) && node.host || getDocumentElement(node);
|
|
return isShadowRoot(result2) ? result2.host : result2;
|
|
}
|
|
function getNearestOverflowAncestor(node) {
|
|
const parentNode = getParentNode(node);
|
|
if (isLastTraversableNode(parentNode)) {
|
|
return node.ownerDocument ? node.ownerDocument.body : node.body;
|
|
}
|
|
if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
|
|
return parentNode;
|
|
}
|
|
return getNearestOverflowAncestor(parentNode);
|
|
}
|
|
function getOverflowAncestors(node, list, traverseIframes) {
|
|
var _node$ownerDocument2;
|
|
if (list === void 0) {
|
|
list = [];
|
|
}
|
|
if (traverseIframes === void 0) {
|
|
traverseIframes = true;
|
|
}
|
|
const scrollableAncestor = getNearestOverflowAncestor(node);
|
|
const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
|
|
const win = getWindow(scrollableAncestor);
|
|
if (isBody) {
|
|
const frameElement = getFrameElement(win);
|
|
return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
|
|
}
|
|
return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
|
|
}
|
|
function getFrameElement(win) {
|
|
return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
|
|
}
|
|
|
|
// node_modules/@floating-ui/dom/dist/floating-ui.dom.esm.js
|
|
function getCssDimensions(element) {
|
|
const css = getComputedStyle2(element);
|
|
let width = parseFloat(css.width) || 0;
|
|
let height = parseFloat(css.height) || 0;
|
|
const hasOffset = isHTMLElement(element);
|
|
const offsetWidth = hasOffset ? element.offsetWidth : width;
|
|
const offsetHeight = hasOffset ? element.offsetHeight : height;
|
|
const shouldFallback = round2(width) !== offsetWidth || round2(height) !== offsetHeight;
|
|
if (shouldFallback) {
|
|
width = offsetWidth;
|
|
height = offsetHeight;
|
|
}
|
|
return {
|
|
width,
|
|
height,
|
|
$: shouldFallback
|
|
};
|
|
}
|
|
function unwrapElement(element) {
|
|
return !isElement3(element) ? element.contextElement : element;
|
|
}
|
|
function getScale(element) {
|
|
const domElement = unwrapElement(element);
|
|
if (!isHTMLElement(domElement)) {
|
|
return createCoords(1);
|
|
}
|
|
const rect = domElement.getBoundingClientRect();
|
|
const {
|
|
width,
|
|
height,
|
|
$
|
|
} = getCssDimensions(domElement);
|
|
let x2 = ($ ? round2(rect.width) : rect.width) / width;
|
|
let y = ($ ? round2(rect.height) : rect.height) / height;
|
|
if (!x2 || !Number.isFinite(x2)) {
|
|
x2 = 1;
|
|
}
|
|
if (!y || !Number.isFinite(y)) {
|
|
y = 1;
|
|
}
|
|
return {
|
|
x: x2,
|
|
y
|
|
};
|
|
}
|
|
var noOffsets = createCoords(0);
|
|
function getVisualOffsets(element) {
|
|
const win = getWindow(element);
|
|
if (!isWebKit() || !win.visualViewport) {
|
|
return noOffsets;
|
|
}
|
|
return {
|
|
x: win.visualViewport.offsetLeft,
|
|
y: win.visualViewport.offsetTop
|
|
};
|
|
}
|
|
function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
|
|
if (isFixed === void 0) {
|
|
isFixed = false;
|
|
}
|
|
if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
|
|
return false;
|
|
}
|
|
return isFixed;
|
|
}
|
|
function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
|
|
if (includeScale === void 0) {
|
|
includeScale = false;
|
|
}
|
|
if (isFixedStrategy === void 0) {
|
|
isFixedStrategy = false;
|
|
}
|
|
const clientRect = element.getBoundingClientRect();
|
|
const domElement = unwrapElement(element);
|
|
let scale = createCoords(1);
|
|
if (includeScale) {
|
|
if (offsetParent) {
|
|
if (isElement3(offsetParent)) {
|
|
scale = getScale(offsetParent);
|
|
}
|
|
} else {
|
|
scale = getScale(element);
|
|
}
|
|
}
|
|
const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
|
|
let x2 = (clientRect.left + visualOffsets.x) / scale.x;
|
|
let y = (clientRect.top + visualOffsets.y) / scale.y;
|
|
let width = clientRect.width / scale.x;
|
|
let height = clientRect.height / scale.y;
|
|
if (domElement) {
|
|
const win = getWindow(domElement);
|
|
const offsetWin = offsetParent && isElement3(offsetParent) ? getWindow(offsetParent) : offsetParent;
|
|
let currentWin = win;
|
|
let currentIFrame = getFrameElement(currentWin);
|
|
while (currentIFrame && offsetParent && offsetWin !== currentWin) {
|
|
const iframeScale = getScale(currentIFrame);
|
|
const iframeRect = currentIFrame.getBoundingClientRect();
|
|
const css = getComputedStyle2(currentIFrame);
|
|
const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
|
|
const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
|
|
x2 *= iframeScale.x;
|
|
y *= iframeScale.y;
|
|
width *= iframeScale.x;
|
|
height *= iframeScale.y;
|
|
x2 += left;
|
|
y += top;
|
|
currentWin = getWindow(currentIFrame);
|
|
currentIFrame = getFrameElement(currentWin);
|
|
}
|
|
}
|
|
return rectToClientRect({
|
|
width,
|
|
height,
|
|
x: x2,
|
|
y
|
|
});
|
|
}
|
|
function getWindowScrollBarX(element, rect) {
|
|
const leftScroll = getNodeScroll(element).scrollLeft;
|
|
if (!rect) {
|
|
return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
|
|
}
|
|
return rect.left + leftScroll;
|
|
}
|
|
function getHTMLOffset(documentElement, scroll, ignoreScrollbarX) {
|
|
if (ignoreScrollbarX === void 0) {
|
|
ignoreScrollbarX = false;
|
|
}
|
|
const htmlRect = documentElement.getBoundingClientRect();
|
|
const x2 = htmlRect.left + scroll.scrollLeft - (ignoreScrollbarX ? 0 : getWindowScrollBarX(documentElement, htmlRect));
|
|
const y = htmlRect.top + scroll.scrollTop;
|
|
return {
|
|
x: x2,
|
|
y
|
|
};
|
|
}
|
|
function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
|
|
let {
|
|
elements,
|
|
rect,
|
|
offsetParent,
|
|
strategy
|
|
} = _ref;
|
|
const isFixed = strategy === "fixed";
|
|
const documentElement = getDocumentElement(offsetParent);
|
|
const topLayer = elements ? isTopLayer(elements.floating) : false;
|
|
if (offsetParent === documentElement || topLayer && isFixed) {
|
|
return rect;
|
|
}
|
|
let scroll = {
|
|
scrollLeft: 0,
|
|
scrollTop: 0
|
|
};
|
|
let scale = createCoords(1);
|
|
const offsets = createCoords(0);
|
|
const isOffsetParentAnElement = isHTMLElement(offsetParent);
|
|
if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
|
|
if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
|
|
scroll = getNodeScroll(offsetParent);
|
|
}
|
|
if (isHTMLElement(offsetParent)) {
|
|
const offsetRect = getBoundingClientRect(offsetParent);
|
|
scale = getScale(offsetParent);
|
|
offsets.x = offsetRect.x + offsetParent.clientLeft;
|
|
offsets.y = offsetRect.y + offsetParent.clientTop;
|
|
}
|
|
}
|
|
const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll, true) : createCoords(0);
|
|
return {
|
|
width: rect.width * scale.x,
|
|
height: rect.height * scale.y,
|
|
x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
|
|
y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
|
|
};
|
|
}
|
|
function getClientRects(element) {
|
|
return Array.from(element.getClientRects());
|
|
}
|
|
function getDocumentRect(element) {
|
|
const html = getDocumentElement(element);
|
|
const scroll = getNodeScroll(element);
|
|
const body = element.ownerDocument.body;
|
|
const width = max3(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
|
|
const height = max3(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
|
|
let x2 = -scroll.scrollLeft + getWindowScrollBarX(element);
|
|
const y = -scroll.scrollTop;
|
|
if (getComputedStyle2(body).direction === "rtl") {
|
|
x2 += max3(html.clientWidth, body.clientWidth) - width;
|
|
}
|
|
return {
|
|
width,
|
|
height,
|
|
x: x2,
|
|
y
|
|
};
|
|
}
|
|
function getViewportRect(element, strategy) {
|
|
const win = getWindow(element);
|
|
const html = getDocumentElement(element);
|
|
const visualViewport = win.visualViewport;
|
|
let width = html.clientWidth;
|
|
let height = html.clientHeight;
|
|
let x2 = 0;
|
|
let y = 0;
|
|
if (visualViewport) {
|
|
width = visualViewport.width;
|
|
height = visualViewport.height;
|
|
const visualViewportBased = isWebKit();
|
|
if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
|
|
x2 = visualViewport.offsetLeft;
|
|
y = visualViewport.offsetTop;
|
|
}
|
|
}
|
|
return {
|
|
width,
|
|
height,
|
|
x: x2,
|
|
y
|
|
};
|
|
}
|
|
function getInnerBoundingClientRect(element, strategy) {
|
|
const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
|
|
const top = clientRect.top + element.clientTop;
|
|
const left = clientRect.left + element.clientLeft;
|
|
const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
|
|
const width = element.clientWidth * scale.x;
|
|
const height = element.clientHeight * scale.y;
|
|
const x2 = left * scale.x;
|
|
const y = top * scale.y;
|
|
return {
|
|
width,
|
|
height,
|
|
x: x2,
|
|
y
|
|
};
|
|
}
|
|
function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
|
|
let rect;
|
|
if (clippingAncestor === "viewport") {
|
|
rect = getViewportRect(element, strategy);
|
|
} else if (clippingAncestor === "document") {
|
|
rect = getDocumentRect(getDocumentElement(element));
|
|
} else if (isElement3(clippingAncestor)) {
|
|
rect = getInnerBoundingClientRect(clippingAncestor, strategy);
|
|
} else {
|
|
const visualOffsets = getVisualOffsets(element);
|
|
rect = {
|
|
x: clippingAncestor.x - visualOffsets.x,
|
|
y: clippingAncestor.y - visualOffsets.y,
|
|
width: clippingAncestor.width,
|
|
height: clippingAncestor.height
|
|
};
|
|
}
|
|
return rectToClientRect(rect);
|
|
}
|
|
function hasFixedPositionAncestor(element, stopNode) {
|
|
const parentNode = getParentNode(element);
|
|
if (parentNode === stopNode || !isElement3(parentNode) || isLastTraversableNode(parentNode)) {
|
|
return false;
|
|
}
|
|
return getComputedStyle2(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
|
|
}
|
|
function getClippingElementAncestors(element, cache2) {
|
|
const cachedResult = cache2.get(element);
|
|
if (cachedResult) {
|
|
return cachedResult;
|
|
}
|
|
let result2 = getOverflowAncestors(element, [], false).filter((el) => isElement3(el) && getNodeName(el) !== "body");
|
|
let currentContainingBlockComputedStyle = null;
|
|
const elementIsFixed = getComputedStyle2(element).position === "fixed";
|
|
let currentNode = elementIsFixed ? getParentNode(element) : element;
|
|
while (isElement3(currentNode) && !isLastTraversableNode(currentNode)) {
|
|
const computedStyle = getComputedStyle2(currentNode);
|
|
const currentNodeIsContaining = isContainingBlock(currentNode);
|
|
if (!currentNodeIsContaining && computedStyle.position === "fixed") {
|
|
currentContainingBlockComputedStyle = null;
|
|
}
|
|
const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && ["absolute", "fixed"].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
|
|
if (shouldDropCurrentNode) {
|
|
result2 = result2.filter((ancestor) => ancestor !== currentNode);
|
|
} else {
|
|
currentContainingBlockComputedStyle = computedStyle;
|
|
}
|
|
currentNode = getParentNode(currentNode);
|
|
}
|
|
cache2.set(element, result2);
|
|
return result2;
|
|
}
|
|
function getClippingRect(_ref) {
|
|
let {
|
|
element,
|
|
boundary,
|
|
rootBoundary,
|
|
strategy
|
|
} = _ref;
|
|
const elementClippingAncestors = boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
|
|
const clippingAncestors = [...elementClippingAncestors, rootBoundary];
|
|
const firstClippingAncestor = clippingAncestors[0];
|
|
const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
|
|
const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
|
|
accRect.top = max3(rect.top, accRect.top);
|
|
accRect.right = min3(rect.right, accRect.right);
|
|
accRect.bottom = min3(rect.bottom, accRect.bottom);
|
|
accRect.left = max3(rect.left, accRect.left);
|
|
return accRect;
|
|
}, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
|
|
return {
|
|
width: clippingRect.right - clippingRect.left,
|
|
height: clippingRect.bottom - clippingRect.top,
|
|
x: clippingRect.left,
|
|
y: clippingRect.top
|
|
};
|
|
}
|
|
function getDimensions(element) {
|
|
const {
|
|
width,
|
|
height
|
|
} = getCssDimensions(element);
|
|
return {
|
|
width,
|
|
height
|
|
};
|
|
}
|
|
function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
|
|
const isOffsetParentAnElement = isHTMLElement(offsetParent);
|
|
const documentElement = getDocumentElement(offsetParent);
|
|
const isFixed = strategy === "fixed";
|
|
const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
|
|
let scroll = {
|
|
scrollLeft: 0,
|
|
scrollTop: 0
|
|
};
|
|
const offsets = createCoords(0);
|
|
if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
|
|
if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
|
|
scroll = getNodeScroll(offsetParent);
|
|
}
|
|
if (isOffsetParentAnElement) {
|
|
const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
|
|
offsets.x = offsetRect.x + offsetParent.clientLeft;
|
|
offsets.y = offsetRect.y + offsetParent.clientTop;
|
|
} else if (documentElement) {
|
|
offsets.x = getWindowScrollBarX(documentElement);
|
|
}
|
|
}
|
|
const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
|
|
const x2 = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
|
|
const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
|
|
return {
|
|
x: x2,
|
|
y,
|
|
width: rect.width,
|
|
height: rect.height
|
|
};
|
|
}
|
|
function isStaticPositioned(element) {
|
|
return getComputedStyle2(element).position === "static";
|
|
}
|
|
function getTrueOffsetParent(element, polyfill) {
|
|
if (!isHTMLElement(element) || getComputedStyle2(element).position === "fixed") {
|
|
return null;
|
|
}
|
|
if (polyfill) {
|
|
return polyfill(element);
|
|
}
|
|
let rawOffsetParent = element.offsetParent;
|
|
if (getDocumentElement(element) === rawOffsetParent) {
|
|
rawOffsetParent = rawOffsetParent.ownerDocument.body;
|
|
}
|
|
return rawOffsetParent;
|
|
}
|
|
function getOffsetParent(element, polyfill) {
|
|
const win = getWindow(element);
|
|
if (isTopLayer(element)) {
|
|
return win;
|
|
}
|
|
if (!isHTMLElement(element)) {
|
|
let svgOffsetParent = getParentNode(element);
|
|
while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
|
|
if (isElement3(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
|
|
return svgOffsetParent;
|
|
}
|
|
svgOffsetParent = getParentNode(svgOffsetParent);
|
|
}
|
|
return win;
|
|
}
|
|
let offsetParent = getTrueOffsetParent(element, polyfill);
|
|
while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
|
|
offsetParent = getTrueOffsetParent(offsetParent, polyfill);
|
|
}
|
|
if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
|
|
return win;
|
|
}
|
|
return offsetParent || getContainingBlock(element) || win;
|
|
}
|
|
var getElementRects = async function(data) {
|
|
const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
|
|
const getDimensionsFn = this.getDimensions;
|
|
const floatingDimensions = await getDimensionsFn(data.floating);
|
|
return {
|
|
reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
|
|
floating: {
|
|
x: 0,
|
|
y: 0,
|
|
width: floatingDimensions.width,
|
|
height: floatingDimensions.height
|
|
}
|
|
};
|
|
};
|
|
function isRTL2(element) {
|
|
return getComputedStyle2(element).direction === "rtl";
|
|
}
|
|
var platform = {
|
|
convertOffsetParentRelativeRectToViewportRelativeRect,
|
|
getDocumentElement,
|
|
getClippingRect,
|
|
getOffsetParent,
|
|
getElementRects,
|
|
getClientRects,
|
|
getDimensions,
|
|
getScale,
|
|
isElement: isElement3,
|
|
isRTL: isRTL2
|
|
};
|
|
function rectsAreEqual(a2, b2) {
|
|
return a2.x === b2.x && a2.y === b2.y && a2.width === b2.width && a2.height === b2.height;
|
|
}
|
|
function observeMove(element, onMove) {
|
|
let io = null;
|
|
let timeoutId;
|
|
const root2 = getDocumentElement(element);
|
|
function cleanup() {
|
|
var _io;
|
|
clearTimeout(timeoutId);
|
|
(_io = io) == null || _io.disconnect();
|
|
io = null;
|
|
}
|
|
function refresh(skip, threshold) {
|
|
if (skip === void 0) {
|
|
skip = false;
|
|
}
|
|
if (threshold === void 0) {
|
|
threshold = 1;
|
|
}
|
|
cleanup();
|
|
const elementRectForRootMargin = element.getBoundingClientRect();
|
|
const {
|
|
left,
|
|
top,
|
|
width,
|
|
height
|
|
} = elementRectForRootMargin;
|
|
if (!skip) {
|
|
onMove();
|
|
}
|
|
if (!width || !height) {
|
|
return;
|
|
}
|
|
const insetTop = floor3(top);
|
|
const insetRight = floor3(root2.clientWidth - (left + width));
|
|
const insetBottom = floor3(root2.clientHeight - (top + height));
|
|
const insetLeft = floor3(left);
|
|
const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
|
|
const options = {
|
|
rootMargin,
|
|
threshold: max3(0, min3(1, threshold)) || 1
|
|
};
|
|
let isFirstUpdate = true;
|
|
function handleObserve(entries) {
|
|
const ratio = entries[0].intersectionRatio;
|
|
if (ratio !== threshold) {
|
|
if (!isFirstUpdate) {
|
|
return refresh();
|
|
}
|
|
if (!ratio) {
|
|
timeoutId = setTimeout(() => {
|
|
refresh(false, 1e-7);
|
|
}, 1e3);
|
|
} else {
|
|
refresh(false, ratio);
|
|
}
|
|
}
|
|
if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {
|
|
refresh();
|
|
}
|
|
isFirstUpdate = false;
|
|
}
|
|
try {
|
|
io = new IntersectionObserver(handleObserve, {
|
|
...options,
|
|
root: root2.ownerDocument
|
|
});
|
|
} catch (e) {
|
|
io = new IntersectionObserver(handleObserve, options);
|
|
}
|
|
io.observe(element);
|
|
}
|
|
refresh(true);
|
|
return cleanup;
|
|
}
|
|
function autoUpdate(reference, floating, update2, options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
const {
|
|
ancestorScroll = true,
|
|
ancestorResize = true,
|
|
elementResize = typeof ResizeObserver === "function",
|
|
layoutShift = typeof IntersectionObserver === "function",
|
|
animationFrame = false
|
|
} = options;
|
|
const referenceEl = unwrapElement(reference);
|
|
const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...getOverflowAncestors(floating)] : [];
|
|
ancestors.forEach((ancestor) => {
|
|
ancestorScroll && ancestor.addEventListener("scroll", update2, {
|
|
passive: true
|
|
});
|
|
ancestorResize && ancestor.addEventListener("resize", update2);
|
|
});
|
|
const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update2) : null;
|
|
let reobserveFrame = -1;
|
|
let resizeObserver = null;
|
|
if (elementResize) {
|
|
resizeObserver = new ResizeObserver((_ref) => {
|
|
let [firstEntry] = _ref;
|
|
if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
|
|
resizeObserver.unobserve(floating);
|
|
cancelAnimationFrame(reobserveFrame);
|
|
reobserveFrame = requestAnimationFrame(() => {
|
|
var _resizeObserver;
|
|
(_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
|
|
});
|
|
}
|
|
update2();
|
|
});
|
|
if (referenceEl && !animationFrame) {
|
|
resizeObserver.observe(referenceEl);
|
|
}
|
|
resizeObserver.observe(floating);
|
|
}
|
|
let frameId;
|
|
let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
|
|
if (animationFrame) {
|
|
frameLoop();
|
|
}
|
|
function frameLoop() {
|
|
const nextRefRect = getBoundingClientRect(reference);
|
|
if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) {
|
|
update2();
|
|
}
|
|
prevRefRect = nextRefRect;
|
|
frameId = requestAnimationFrame(frameLoop);
|
|
}
|
|
update2();
|
|
return () => {
|
|
var _resizeObserver2;
|
|
ancestors.forEach((ancestor) => {
|
|
ancestorScroll && ancestor.removeEventListener("scroll", update2);
|
|
ancestorResize && ancestor.removeEventListener("resize", update2);
|
|
});
|
|
cleanupIo == null || cleanupIo();
|
|
(_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
|
|
resizeObserver = null;
|
|
if (animationFrame) {
|
|
cancelAnimationFrame(frameId);
|
|
}
|
|
};
|
|
}
|
|
var detectOverflow2 = detectOverflow;
|
|
var offset2 = offset;
|
|
var shift2 = shift;
|
|
var flip3 = flip2;
|
|
var arrow2 = arrow;
|
|
var computePosition2 = (reference, floating, options) => {
|
|
const cache2 = new Map();
|
|
const mergedOptions = {
|
|
platform,
|
|
...options
|
|
};
|
|
const platformWithCache = {
|
|
...mergedOptions.platform,
|
|
_c: cache2
|
|
};
|
|
return computePosition(reference, floating, {
|
|
...mergedOptions,
|
|
platform: platformWithCache
|
|
});
|
|
};
|
|
|
|
// node_modules/element-plus/es/hooks/use-floating/index.mjs
|
|
var useFloatingProps = buildProps({});
|
|
var unrefReference = (elRef) => {
|
|
if (!isClient)
|
|
return;
|
|
if (!elRef)
|
|
return elRef;
|
|
const unrefEl = unrefElement(elRef);
|
|
if (unrefEl)
|
|
return unrefEl;
|
|
return isRef(elRef) ? unrefEl : elRef;
|
|
};
|
|
var getPositionDataWithUnit = (record, key) => {
|
|
const value = record == null ? void 0 : record[key];
|
|
return isNil_default(value) ? "" : `${value}px`;
|
|
};
|
|
var useFloating = ({
|
|
middleware,
|
|
placement,
|
|
strategy
|
|
}) => {
|
|
const referenceRef = ref();
|
|
const contentRef = ref();
|
|
const x2 = ref();
|
|
const y = ref();
|
|
const middlewareData = ref({});
|
|
const states = {
|
|
x: x2,
|
|
y,
|
|
placement,
|
|
strategy,
|
|
middlewareData
|
|
};
|
|
const update2 = async () => {
|
|
if (!isClient)
|
|
return;
|
|
const referenceEl = unrefReference(referenceRef);
|
|
const contentEl = unrefElement(contentRef);
|
|
if (!referenceEl || !contentEl)
|
|
return;
|
|
const data = await computePosition2(referenceEl, contentEl, {
|
|
placement: unref(placement),
|
|
strategy: unref(strategy),
|
|
middleware: unref(middleware)
|
|
});
|
|
keysOf(states).forEach((key) => {
|
|
states[key].value = data[key];
|
|
});
|
|
};
|
|
onMounted(() => {
|
|
watchEffect(() => {
|
|
update2();
|
|
});
|
|
});
|
|
return {
|
|
...states,
|
|
update: update2,
|
|
referenceRef,
|
|
contentRef
|
|
};
|
|
};
|
|
var arrowMiddleware = ({
|
|
arrowRef,
|
|
padding
|
|
}) => {
|
|
return {
|
|
name: "arrow",
|
|
options: {
|
|
element: arrowRef,
|
|
padding
|
|
},
|
|
fn(args) {
|
|
const arrowEl = unref(arrowRef);
|
|
if (!arrowEl)
|
|
return {};
|
|
return arrow2({
|
|
element: arrowEl,
|
|
padding
|
|
}).fn(args);
|
|
}
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/transfer/src/transfer.mjs
|
|
var LEFT_CHECK_CHANGE_EVENT = "left-check-change";
|
|
var RIGHT_CHECK_CHANGE_EVENT = "right-check-change";
|
|
var transferProps = buildProps({
|
|
data: {
|
|
type: definePropType(Array),
|
|
default: () => []
|
|
},
|
|
titles: {
|
|
type: definePropType(Array),
|
|
default: () => []
|
|
},
|
|
buttonTexts: {
|
|
type: definePropType(Array),
|
|
default: () => []
|
|
},
|
|
filterPlaceholder: String,
|
|
filterMethod: {
|
|
type: definePropType(Function)
|
|
},
|
|
leftDefaultChecked: {
|
|
type: definePropType(Array),
|
|
default: () => []
|
|
},
|
|
rightDefaultChecked: {
|
|
type: definePropType(Array),
|
|
default: () => []
|
|
},
|
|
renderContent: {
|
|
type: definePropType(Function)
|
|
},
|
|
modelValue: {
|
|
type: definePropType(Array),
|
|
default: () => []
|
|
},
|
|
format: {
|
|
type: definePropType(Object),
|
|
default: () => ({})
|
|
},
|
|
filterable: Boolean,
|
|
props: {
|
|
type: definePropType(Object),
|
|
default: () => mutable({
|
|
label: "label",
|
|
key: "key",
|
|
disabled: "disabled"
|
|
})
|
|
},
|
|
targetOrder: {
|
|
type: String,
|
|
values: ["original", "push", "unshift"],
|
|
default: "original"
|
|
},
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
}
|
|
});
|
|
var transferCheckedChangeFn = (value, movedKeys) => [value, movedKeys].every(isArray) || isArray(value) && isNil_default(movedKeys);
|
|
var transferEmits = {
|
|
[CHANGE_EVENT]: (value, direction2, movedKeys) => [value, movedKeys].every(isArray) && ["left", "right"].includes(direction2),
|
|
[UPDATE_MODEL_EVENT]: (value) => isArray(value),
|
|
[LEFT_CHECK_CHANGE_EVENT]: transferCheckedChangeFn,
|
|
[RIGHT_CHECK_CHANGE_EVENT]: transferCheckedChangeFn
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/transfer/src/transfer-panel.mjs
|
|
var CHECKED_CHANGE_EVENT = "checked-change";
|
|
var transferPanelProps = buildProps({
|
|
data: transferProps.data,
|
|
optionRender: {
|
|
type: definePropType(Function)
|
|
},
|
|
placeholder: String,
|
|
title: String,
|
|
filterable: Boolean,
|
|
format: transferProps.format,
|
|
filterMethod: transferProps.filterMethod,
|
|
defaultChecked: transferProps.leftDefaultChecked,
|
|
props: transferProps.props
|
|
});
|
|
var transferPanelEmits = {
|
|
[CHECKED_CHANGE_EVENT]: transferCheckedChangeFn
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/transfer/src/composables/use-props-alias.mjs
|
|
var usePropsAlias = (props2) => {
|
|
const initProps = {
|
|
label: "label",
|
|
key: "key",
|
|
disabled: "disabled"
|
|
};
|
|
return computed(() => ({
|
|
...initProps,
|
|
...props2.props
|
|
}));
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/transfer/src/composables/use-check.mjs
|
|
var useCheck = (props2, panelState, emit) => {
|
|
const propsAlias = usePropsAlias(props2);
|
|
const filteredData = computed(() => {
|
|
return props2.data.filter((item) => {
|
|
if (isFunction(props2.filterMethod)) {
|
|
return props2.filterMethod(panelState.query, item);
|
|
} else {
|
|
const label = String(item[propsAlias.value.label] || item[propsAlias.value.key]);
|
|
return label.toLowerCase().includes(panelState.query.toLowerCase());
|
|
}
|
|
});
|
|
});
|
|
const checkableData = computed(() => filteredData.value.filter((item) => !item[propsAlias.value.disabled]));
|
|
const checkedSummary = computed(() => {
|
|
const checkedLength = panelState.checked.length;
|
|
const dataLength = props2.data.length;
|
|
const { noChecked, hasChecked } = props2.format;
|
|
if (noChecked && hasChecked) {
|
|
return checkedLength > 0 ? hasChecked.replace(/\${checked}/g, checkedLength.toString()).replace(/\${total}/g, dataLength.toString()) : noChecked.replace(/\${total}/g, dataLength.toString());
|
|
} else {
|
|
return `${checkedLength}/${dataLength}`;
|
|
}
|
|
});
|
|
const isIndeterminate = computed(() => {
|
|
const checkedLength = panelState.checked.length;
|
|
return checkedLength > 0 && checkedLength < checkableData.value.length;
|
|
});
|
|
const updateAllChecked = () => {
|
|
const checkableDataKeys = checkableData.value.map((item) => item[propsAlias.value.key]);
|
|
panelState.allChecked = checkableDataKeys.length > 0 && checkableDataKeys.every((item) => panelState.checked.includes(item));
|
|
};
|
|
const handleAllCheckedChange = (value) => {
|
|
panelState.checked = value ? checkableData.value.map((item) => item[propsAlias.value.key]) : [];
|
|
};
|
|
watch(() => panelState.checked, (val, oldVal) => {
|
|
updateAllChecked();
|
|
if (panelState.checkChangeByUser) {
|
|
const movedKeys = val.concat(oldVal).filter((v2) => !val.includes(v2) || !oldVal.includes(v2));
|
|
emit(CHECKED_CHANGE_EVENT, val, movedKeys);
|
|
} else {
|
|
emit(CHECKED_CHANGE_EVENT, val);
|
|
panelState.checkChangeByUser = true;
|
|
}
|
|
});
|
|
watch(checkableData, () => {
|
|
updateAllChecked();
|
|
});
|
|
watch(() => props2.data, () => {
|
|
const checked = [];
|
|
const filteredDataKeys = filteredData.value.map((item) => item[propsAlias.value.key]);
|
|
panelState.checked.forEach((item) => {
|
|
if (filteredDataKeys.includes(item)) {
|
|
checked.push(item);
|
|
}
|
|
});
|
|
panelState.checkChangeByUser = false;
|
|
panelState.checked = checked;
|
|
});
|
|
watch(() => props2.defaultChecked, (val, oldVal) => {
|
|
if (oldVal && val.length === oldVal.length && val.every((item) => oldVal.includes(item)))
|
|
return;
|
|
const checked = [];
|
|
const checkableDataKeys = checkableData.value.map((item) => item[propsAlias.value.key]);
|
|
val.forEach((item) => {
|
|
if (checkableDataKeys.includes(item)) {
|
|
checked.push(item);
|
|
}
|
|
});
|
|
panelState.checkChangeByUser = false;
|
|
panelState.checked = checked;
|
|
}, {
|
|
immediate: true
|
|
});
|
|
return {
|
|
filteredData,
|
|
checkableData,
|
|
checkedSummary,
|
|
isIndeterminate,
|
|
updateAllChecked,
|
|
handleAllCheckedChange
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/transfer/src/transfer-panel2.mjs
|
|
var __default__96 = defineComponent({
|
|
name: "ElTransferPanel"
|
|
});
|
|
var _sfc_main132 = defineComponent({
|
|
...__default__96,
|
|
props: transferPanelProps,
|
|
emits: transferPanelEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const slots = useSlots();
|
|
const OptionContent = ({ option }) => option;
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("transfer");
|
|
const panelState = reactive({
|
|
checked: [],
|
|
allChecked: false,
|
|
query: "",
|
|
checkChangeByUser: true
|
|
});
|
|
const propsAlias = usePropsAlias(props2);
|
|
const {
|
|
filteredData,
|
|
checkedSummary,
|
|
isIndeterminate,
|
|
handleAllCheckedChange
|
|
} = useCheck(props2, panelState, emit);
|
|
const hasNoMatch = computed(() => !isEmpty2(panelState.query) && isEmpty2(filteredData.value));
|
|
const hasFooter = computed(() => !isEmpty2(slots.default()[0].children));
|
|
const { checked, allChecked, query } = toRefs(panelState);
|
|
expose({
|
|
query
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(unref(ns).b("panel"))
|
|
}, [
|
|
createBaseVNode("p", {
|
|
class: normalizeClass(unref(ns).be("panel", "header"))
|
|
}, [
|
|
createVNode(unref(ElCheckbox), {
|
|
modelValue: unref(allChecked),
|
|
"onUpdate:modelValue": ($event) => isRef(allChecked) ? allChecked.value = $event : null,
|
|
indeterminate: unref(isIndeterminate),
|
|
"validate-event": false,
|
|
onChange: unref(handleAllCheckedChange)
|
|
}, {
|
|
default: withCtx(() => [
|
|
createTextVNode(toDisplayString(_ctx.title) + " ", 1),
|
|
createBaseVNode("span", null, toDisplayString(unref(checkedSummary)), 1)
|
|
]),
|
|
_: 1
|
|
}, 8, ["modelValue", "onUpdate:modelValue", "indeterminate", "onChange"])
|
|
], 2),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([unref(ns).be("panel", "body"), unref(ns).is("with-footer", unref(hasFooter))])
|
|
}, [
|
|
_ctx.filterable ? (openBlock(), createBlock(unref(ElInput), {
|
|
key: 0,
|
|
modelValue: unref(query),
|
|
"onUpdate:modelValue": ($event) => isRef(query) ? query.value = $event : null,
|
|
class: normalizeClass(unref(ns).be("panel", "filter")),
|
|
size: "default",
|
|
placeholder: _ctx.placeholder,
|
|
"prefix-icon": unref(search_default),
|
|
clearable: "",
|
|
"validate-event": false
|
|
}, null, 8, ["modelValue", "onUpdate:modelValue", "class", "placeholder", "prefix-icon"])) : createCommentVNode("v-if", true),
|
|
withDirectives(createVNode(unref(ElCheckboxGroup), {
|
|
modelValue: unref(checked),
|
|
"onUpdate:modelValue": ($event) => isRef(checked) ? checked.value = $event : null,
|
|
"validate-event": false,
|
|
class: normalizeClass([unref(ns).is("filterable", _ctx.filterable), unref(ns).be("panel", "list")])
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(filteredData), (item) => {
|
|
return openBlock(), createBlock(unref(ElCheckbox), {
|
|
key: item[unref(propsAlias).key],
|
|
class: normalizeClass(unref(ns).be("panel", "item")),
|
|
value: item[unref(propsAlias).key],
|
|
disabled: item[unref(propsAlias).disabled],
|
|
"validate-event": false
|
|
}, {
|
|
default: withCtx(() => {
|
|
var _a2;
|
|
return [
|
|
createVNode(OptionContent, {
|
|
option: (_a2 = _ctx.optionRender) == null ? void 0 : _a2.call(_ctx, item)
|
|
}, null, 8, ["option"])
|
|
];
|
|
}),
|
|
_: 2
|
|
}, 1032, ["class", "value", "disabled"]);
|
|
}), 128))
|
|
]),
|
|
_: 1
|
|
}, 8, ["modelValue", "onUpdate:modelValue", "class"]), [
|
|
[vShow, !unref(hasNoMatch) && !unref(isEmpty2)(_ctx.data)]
|
|
]),
|
|
withDirectives(createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).be("panel", "empty"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "empty", {}, () => [
|
|
createTextVNode(toDisplayString(unref(hasNoMatch) ? unref(t)("el.transfer.noMatch") : unref(t)("el.transfer.noData")), 1)
|
|
])
|
|
], 2), [
|
|
[vShow, unref(hasNoMatch) || unref(isEmpty2)(_ctx.data)]
|
|
])
|
|
], 2),
|
|
unref(hasFooter) ? (openBlock(), createElementBlock("p", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).be("panel", "footer"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var TransferPanel = _export_sfc(_sfc_main132, [["__file", "transfer-panel.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/transfer/src/composables/use-computed-data.mjs
|
|
var useComputedData = (props2) => {
|
|
const propsAlias = usePropsAlias(props2);
|
|
const dataObj = computed(() => props2.data.reduce((o2, cur) => (o2[cur[propsAlias.value.key]] = cur) && o2, {}));
|
|
const sourceData = computed(() => props2.data.filter((item) => !props2.modelValue.includes(item[propsAlias.value.key])));
|
|
const targetData = computed(() => {
|
|
if (props2.targetOrder === "original") {
|
|
return props2.data.filter((item) => props2.modelValue.includes(item[propsAlias.value.key]));
|
|
} else {
|
|
return props2.modelValue.reduce((arr, cur) => {
|
|
const val = dataObj.value[cur];
|
|
if (val) {
|
|
arr.push(val);
|
|
}
|
|
return arr;
|
|
}, []);
|
|
}
|
|
});
|
|
return {
|
|
sourceData,
|
|
targetData
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/transfer/src/composables/use-move.mjs
|
|
var useMove = (props2, checkedState, emit) => {
|
|
const propsAlias = usePropsAlias(props2);
|
|
const _emit = (value, direction2, movedKeys) => {
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emit(CHANGE_EVENT, value, direction2, movedKeys);
|
|
};
|
|
const addToLeft = () => {
|
|
const currentValue = props2.modelValue.slice();
|
|
checkedState.rightChecked.forEach((item) => {
|
|
const index = currentValue.indexOf(item);
|
|
if (index > -1) {
|
|
currentValue.splice(index, 1);
|
|
}
|
|
});
|
|
_emit(currentValue, "left", checkedState.rightChecked);
|
|
};
|
|
const addToRight = () => {
|
|
let currentValue = props2.modelValue.slice();
|
|
const itemsToBeMoved = props2.data.filter((item) => {
|
|
const itemKey = item[propsAlias.value.key];
|
|
return checkedState.leftChecked.includes(itemKey) && !props2.modelValue.includes(itemKey);
|
|
}).map((item) => item[propsAlias.value.key]);
|
|
currentValue = props2.targetOrder === "unshift" ? itemsToBeMoved.concat(currentValue) : currentValue.concat(itemsToBeMoved);
|
|
if (props2.targetOrder === "original") {
|
|
currentValue = props2.data.filter((item) => currentValue.includes(item[propsAlias.value.key])).map((item) => item[propsAlias.value.key]);
|
|
}
|
|
_emit(currentValue, "right", checkedState.leftChecked);
|
|
};
|
|
return {
|
|
addToLeft,
|
|
addToRight
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/transfer/src/composables/use-checked-change.mjs
|
|
var useCheckedChange = (checkedState, emit) => {
|
|
const onSourceCheckedChange = (val, movedKeys) => {
|
|
checkedState.leftChecked = val;
|
|
if (!movedKeys)
|
|
return;
|
|
emit(LEFT_CHECK_CHANGE_EVENT, val, movedKeys);
|
|
};
|
|
const onTargetCheckedChange = (val, movedKeys) => {
|
|
checkedState.rightChecked = val;
|
|
if (!movedKeys)
|
|
return;
|
|
emit(RIGHT_CHECK_CHANGE_EVENT, val, movedKeys);
|
|
};
|
|
return {
|
|
onSourceCheckedChange,
|
|
onTargetCheckedChange
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/transfer/src/transfer2.mjs
|
|
var __default__97 = defineComponent({
|
|
name: "ElTransfer"
|
|
});
|
|
var _sfc_main133 = defineComponent({
|
|
...__default__97,
|
|
props: transferProps,
|
|
emits: transferEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const slots = useSlots();
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("transfer");
|
|
const { formItem } = useFormItem();
|
|
const checkedState = reactive({
|
|
leftChecked: [],
|
|
rightChecked: []
|
|
});
|
|
const propsAlias = usePropsAlias(props2);
|
|
const { sourceData, targetData } = useComputedData(props2);
|
|
const { onSourceCheckedChange, onTargetCheckedChange } = useCheckedChange(checkedState, emit);
|
|
const { addToLeft, addToRight } = useMove(props2, checkedState, emit);
|
|
const leftPanel = ref();
|
|
const rightPanel = ref();
|
|
const clearQuery = (which) => {
|
|
switch (which) {
|
|
case "left":
|
|
leftPanel.value.query = "";
|
|
break;
|
|
case "right":
|
|
rightPanel.value.query = "";
|
|
break;
|
|
}
|
|
};
|
|
const hasButtonTexts = computed(() => props2.buttonTexts.length === 2);
|
|
const leftPanelTitle = computed(() => props2.titles[0] || t("el.transfer.titles.0"));
|
|
const rightPanelTitle = computed(() => props2.titles[1] || t("el.transfer.titles.1"));
|
|
const panelFilterPlaceholder = computed(() => props2.filterPlaceholder || t("el.transfer.filterPlaceholder"));
|
|
watch(() => props2.modelValue, () => {
|
|
var _a2;
|
|
if (props2.validateEvent) {
|
|
(_a2 = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a2.call(formItem, "change").catch((err) => debugWarn(err));
|
|
}
|
|
});
|
|
const optionRender = computed(() => (option) => {
|
|
var _a2;
|
|
if (props2.renderContent)
|
|
return props2.renderContent(h, option);
|
|
const defaultSlotVNodes = (((_a2 = slots.default) == null ? void 0 : _a2.call(slots, { option })) || []).filter((node) => node.type !== Comment);
|
|
if (defaultSlotVNodes.length) {
|
|
return defaultSlotVNodes;
|
|
}
|
|
return h("span", option[propsAlias.value.label] || option[propsAlias.value.key]);
|
|
});
|
|
expose({
|
|
clearQuery,
|
|
leftPanel,
|
|
rightPanel
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(unref(ns).b())
|
|
}, [
|
|
createVNode(TransferPanel, {
|
|
ref_key: "leftPanel",
|
|
ref: leftPanel,
|
|
data: unref(sourceData),
|
|
"option-render": unref(optionRender),
|
|
placeholder: unref(panelFilterPlaceholder),
|
|
title: unref(leftPanelTitle),
|
|
filterable: _ctx.filterable,
|
|
format: _ctx.format,
|
|
"filter-method": _ctx.filterMethod,
|
|
"default-checked": _ctx.leftDefaultChecked,
|
|
props: props2.props,
|
|
onCheckedChange: unref(onSourceCheckedChange)
|
|
}, {
|
|
empty: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "left-empty")
|
|
]),
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "left-footer")
|
|
]),
|
|
_: 3
|
|
}, 8, ["data", "option-render", "placeholder", "title", "filterable", "format", "filter-method", "default-checked", "props", "onCheckedChange"]),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("buttons"))
|
|
}, [
|
|
createVNode(unref(ElButton), {
|
|
type: "primary",
|
|
class: normalizeClass([unref(ns).e("button"), unref(ns).is("with-texts", unref(hasButtonTexts))]),
|
|
disabled: unref(isEmpty2)(checkedState.rightChecked),
|
|
onClick: unref(addToLeft)
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(arrow_left_default))
|
|
]),
|
|
_: 1
|
|
}),
|
|
!unref(isUndefined2)(_ctx.buttonTexts[0]) ? (openBlock(), createElementBlock("span", { key: 0 }, toDisplayString(_ctx.buttonTexts[0]), 1)) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "disabled", "onClick"]),
|
|
createVNode(unref(ElButton), {
|
|
type: "primary",
|
|
class: normalizeClass([unref(ns).e("button"), unref(ns).is("with-texts", unref(hasButtonTexts))]),
|
|
disabled: unref(isEmpty2)(checkedState.leftChecked),
|
|
onClick: unref(addToRight)
|
|
}, {
|
|
default: withCtx(() => [
|
|
!unref(isUndefined2)(_ctx.buttonTexts[1]) ? (openBlock(), createElementBlock("span", { key: 0 }, toDisplayString(_ctx.buttonTexts[1]), 1)) : createCommentVNode("v-if", true),
|
|
createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(arrow_right_default))
|
|
]),
|
|
_: 1
|
|
})
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "disabled", "onClick"])
|
|
], 2),
|
|
createVNode(TransferPanel, {
|
|
ref_key: "rightPanel",
|
|
ref: rightPanel,
|
|
data: unref(targetData),
|
|
"option-render": unref(optionRender),
|
|
placeholder: unref(panelFilterPlaceholder),
|
|
filterable: _ctx.filterable,
|
|
format: _ctx.format,
|
|
"filter-method": _ctx.filterMethod,
|
|
title: unref(rightPanelTitle),
|
|
"default-checked": _ctx.rightDefaultChecked,
|
|
props: props2.props,
|
|
onCheckedChange: unref(onTargetCheckedChange)
|
|
}, {
|
|
empty: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "right-empty")
|
|
]),
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "right-footer")
|
|
]),
|
|
_: 3
|
|
}, 8, ["data", "option-render", "placeholder", "filterable", "format", "filter-method", "title", "default-checked", "props", "onCheckedChange"])
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Transfer = _export_sfc(_sfc_main133, [["__file", "transfer.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/transfer/index.mjs
|
|
var ElTransfer = withInstall(Transfer);
|
|
|
|
// node_modules/element-plus/es/components/tree/src/model/util.mjs
|
|
var NODE_KEY = "$treeNodeId";
|
|
var markNodeData = function(node, data) {
|
|
if (!data || data[NODE_KEY])
|
|
return;
|
|
Object.defineProperty(data, NODE_KEY, {
|
|
value: node.id,
|
|
enumerable: false,
|
|
configurable: false,
|
|
writable: false
|
|
});
|
|
};
|
|
var getNodeKey = (key, data) => data == null ? void 0 : data[key || NODE_KEY];
|
|
var handleCurrentChange = (store, emit, setCurrent) => {
|
|
const preCurrentNode = store.value.currentNode;
|
|
setCurrent();
|
|
const currentNode = store.value.currentNode;
|
|
if (preCurrentNode === currentNode)
|
|
return;
|
|
emit("current-change", currentNode ? currentNode.data : null, currentNode);
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/tree/src/model/node.mjs
|
|
var getChildState = (node) => {
|
|
let all = true;
|
|
let none = true;
|
|
let allWithoutDisable = true;
|
|
for (let i = 0, j = node.length; i < j; i++) {
|
|
const n = node[i];
|
|
if (n.checked !== true || n.indeterminate) {
|
|
all = false;
|
|
if (!n.disabled) {
|
|
allWithoutDisable = false;
|
|
}
|
|
}
|
|
if (n.checked !== false || n.indeterminate) {
|
|
none = false;
|
|
}
|
|
}
|
|
return { all, none, allWithoutDisable, half: !all && !none };
|
|
};
|
|
var reInitChecked = function(node) {
|
|
if (node.childNodes.length === 0 || node.loading)
|
|
return;
|
|
const { all, none, half } = getChildState(node.childNodes);
|
|
if (all) {
|
|
node.checked = true;
|
|
node.indeterminate = false;
|
|
} else if (half) {
|
|
node.checked = false;
|
|
node.indeterminate = true;
|
|
} else if (none) {
|
|
node.checked = false;
|
|
node.indeterminate = false;
|
|
}
|
|
const parent2 = node.parent;
|
|
if (!parent2 || parent2.level === 0)
|
|
return;
|
|
if (!node.store.checkStrictly) {
|
|
reInitChecked(parent2);
|
|
}
|
|
};
|
|
var getPropertyFromData = function(node, prop) {
|
|
const props2 = node.store.props;
|
|
const data = node.data || {};
|
|
const config = props2[prop];
|
|
if (isFunction(config)) {
|
|
return config(data, node);
|
|
} else if (isString(config)) {
|
|
return data[config];
|
|
} else if (isUndefined2(config)) {
|
|
const dataProp = data[prop];
|
|
return isUndefined2(dataProp) ? "" : dataProp;
|
|
}
|
|
};
|
|
var nodeIdSeed = 0;
|
|
var Node3 = class {
|
|
constructor(options) {
|
|
this.id = nodeIdSeed++;
|
|
this.text = null;
|
|
this.checked = false;
|
|
this.indeterminate = false;
|
|
this.data = null;
|
|
this.expanded = false;
|
|
this.parent = null;
|
|
this.visible = true;
|
|
this.isCurrent = false;
|
|
this.canFocus = false;
|
|
for (const name in options) {
|
|
if (hasOwn(options, name)) {
|
|
this[name] = options[name];
|
|
}
|
|
}
|
|
this.level = 0;
|
|
this.loaded = false;
|
|
this.childNodes = [];
|
|
this.loading = false;
|
|
if (this.parent) {
|
|
this.level = this.parent.level + 1;
|
|
}
|
|
}
|
|
initialize() {
|
|
const store = this.store;
|
|
if (!store) {
|
|
throw new Error("[Node]store is required!");
|
|
}
|
|
store.registerNode(this);
|
|
const props2 = store.props;
|
|
if (props2 && typeof props2.isLeaf !== "undefined") {
|
|
const isLeaf2 = getPropertyFromData(this, "isLeaf");
|
|
if (isBoolean2(isLeaf2)) {
|
|
this.isLeafByUser = isLeaf2;
|
|
}
|
|
}
|
|
if (store.lazy !== true && this.data) {
|
|
this.setData(this.data);
|
|
if (store.defaultExpandAll) {
|
|
this.expanded = true;
|
|
this.canFocus = true;
|
|
}
|
|
} else if (this.level > 0 && store.lazy && store.defaultExpandAll && !this.isLeafByUser) {
|
|
this.expand();
|
|
}
|
|
if (!isArray(this.data)) {
|
|
markNodeData(this, this.data);
|
|
}
|
|
if (!this.data)
|
|
return;
|
|
const defaultExpandedKeys = store.defaultExpandedKeys;
|
|
const key = store.key;
|
|
if (key && defaultExpandedKeys && defaultExpandedKeys.includes(this.key)) {
|
|
this.expand(null, store.autoExpandParent);
|
|
}
|
|
if (key && store.currentNodeKey !== void 0 && this.key === store.currentNodeKey) {
|
|
store.currentNode = this;
|
|
store.currentNode.isCurrent = true;
|
|
}
|
|
if (store.lazy) {
|
|
store._initDefaultCheckedNode(this);
|
|
}
|
|
this.updateLeafState();
|
|
if (this.parent && (this.level === 1 || this.parent.expanded === true))
|
|
this.canFocus = true;
|
|
}
|
|
setData(data) {
|
|
if (!isArray(data)) {
|
|
markNodeData(this, data);
|
|
}
|
|
this.data = data;
|
|
this.childNodes = [];
|
|
let children;
|
|
if (this.level === 0 && isArray(this.data)) {
|
|
children = this.data;
|
|
} else {
|
|
children = getPropertyFromData(this, "children") || [];
|
|
}
|
|
for (let i = 0, j = children.length; i < j; i++) {
|
|
this.insertChild({ data: children[i] });
|
|
}
|
|
}
|
|
get label() {
|
|
return getPropertyFromData(this, "label");
|
|
}
|
|
get key() {
|
|
const nodeKey = this.store.key;
|
|
if (this.data)
|
|
return this.data[nodeKey];
|
|
return null;
|
|
}
|
|
get disabled() {
|
|
return getPropertyFromData(this, "disabled");
|
|
}
|
|
get nextSibling() {
|
|
const parent2 = this.parent;
|
|
if (parent2) {
|
|
const index = parent2.childNodes.indexOf(this);
|
|
if (index > -1) {
|
|
return parent2.childNodes[index + 1];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
get previousSibling() {
|
|
const parent2 = this.parent;
|
|
if (parent2) {
|
|
const index = parent2.childNodes.indexOf(this);
|
|
if (index > -1) {
|
|
return index > 0 ? parent2.childNodes[index - 1] : null;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
contains(target2, deep = true) {
|
|
return (this.childNodes || []).some((child) => child === target2 || deep && child.contains(target2));
|
|
}
|
|
remove() {
|
|
const parent2 = this.parent;
|
|
if (parent2) {
|
|
parent2.removeChild(this);
|
|
}
|
|
}
|
|
insertChild(child, index, batch) {
|
|
if (!child)
|
|
throw new Error("InsertChild error: child is required.");
|
|
if (!(child instanceof Node3)) {
|
|
if (!batch) {
|
|
const children = this.getChildren(true);
|
|
if (!children.includes(child.data)) {
|
|
if (isUndefined2(index) || index < 0) {
|
|
children.push(child.data);
|
|
} else {
|
|
children.splice(index, 0, child.data);
|
|
}
|
|
}
|
|
}
|
|
Object.assign(child, {
|
|
parent: this,
|
|
store: this.store
|
|
});
|
|
child = reactive(new Node3(child));
|
|
if (child instanceof Node3) {
|
|
child.initialize();
|
|
}
|
|
}
|
|
child.level = this.level + 1;
|
|
if (isUndefined2(index) || index < 0) {
|
|
this.childNodes.push(child);
|
|
} else {
|
|
this.childNodes.splice(index, 0, child);
|
|
}
|
|
this.updateLeafState();
|
|
}
|
|
insertBefore(child, ref2) {
|
|
let index;
|
|
if (ref2) {
|
|
index = this.childNodes.indexOf(ref2);
|
|
}
|
|
this.insertChild(child, index);
|
|
}
|
|
insertAfter(child, ref2) {
|
|
let index;
|
|
if (ref2) {
|
|
index = this.childNodes.indexOf(ref2);
|
|
if (index !== -1)
|
|
index += 1;
|
|
}
|
|
this.insertChild(child, index);
|
|
}
|
|
removeChild(child) {
|
|
const children = this.getChildren() || [];
|
|
const dataIndex = children.indexOf(child.data);
|
|
if (dataIndex > -1) {
|
|
children.splice(dataIndex, 1);
|
|
}
|
|
const index = this.childNodes.indexOf(child);
|
|
if (index > -1) {
|
|
this.store && this.store.deregisterNode(child);
|
|
child.parent = null;
|
|
this.childNodes.splice(index, 1);
|
|
}
|
|
this.updateLeafState();
|
|
}
|
|
removeChildByData(data) {
|
|
let targetNode = null;
|
|
for (let i = 0; i < this.childNodes.length; i++) {
|
|
if (this.childNodes[i].data === data) {
|
|
targetNode = this.childNodes[i];
|
|
break;
|
|
}
|
|
}
|
|
if (targetNode) {
|
|
this.removeChild(targetNode);
|
|
}
|
|
}
|
|
expand(callback, expandParent) {
|
|
const done = () => {
|
|
if (expandParent) {
|
|
let parent2 = this.parent;
|
|
while (parent2.level > 0) {
|
|
parent2.expanded = true;
|
|
parent2 = parent2.parent;
|
|
}
|
|
}
|
|
this.expanded = true;
|
|
if (callback)
|
|
callback();
|
|
this.childNodes.forEach((item) => {
|
|
item.canFocus = true;
|
|
});
|
|
};
|
|
if (this.shouldLoadData()) {
|
|
this.loadData((data) => {
|
|
if (isArray(data)) {
|
|
if (this.checked) {
|
|
this.setChecked(true, true);
|
|
} else if (!this.store.checkStrictly) {
|
|
reInitChecked(this);
|
|
}
|
|
done();
|
|
}
|
|
});
|
|
} else {
|
|
done();
|
|
}
|
|
}
|
|
doCreateChildren(array4, defaultProps6 = {}) {
|
|
array4.forEach((item) => {
|
|
this.insertChild(Object.assign({ data: item }, defaultProps6), void 0, true);
|
|
});
|
|
}
|
|
collapse() {
|
|
this.expanded = false;
|
|
this.childNodes.forEach((item) => {
|
|
item.canFocus = false;
|
|
});
|
|
}
|
|
shouldLoadData() {
|
|
return this.store.lazy === true && this.store.load && !this.loaded;
|
|
}
|
|
updateLeafState() {
|
|
if (this.store.lazy === true && this.loaded !== true && typeof this.isLeafByUser !== "undefined") {
|
|
this.isLeaf = this.isLeafByUser;
|
|
return;
|
|
}
|
|
const childNodes = this.childNodes;
|
|
if (!this.store.lazy || this.store.lazy === true && this.loaded === true) {
|
|
this.isLeaf = !childNodes || childNodes.length === 0;
|
|
return;
|
|
}
|
|
this.isLeaf = false;
|
|
}
|
|
setChecked(value, deep, recursion, passValue) {
|
|
this.indeterminate = value === "half";
|
|
this.checked = value === true;
|
|
if (this.store.checkStrictly)
|
|
return;
|
|
if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
|
|
const { all, allWithoutDisable } = getChildState(this.childNodes);
|
|
if (!this.isLeaf && !all && allWithoutDisable) {
|
|
this.checked = false;
|
|
value = false;
|
|
}
|
|
const handleDescendants = () => {
|
|
if (deep) {
|
|
const childNodes = this.childNodes;
|
|
for (let i = 0, j = childNodes.length; i < j; i++) {
|
|
const child = childNodes[i];
|
|
passValue = passValue || value !== false;
|
|
const isCheck = child.disabled ? child.checked : passValue;
|
|
child.setChecked(isCheck, deep, true, passValue);
|
|
}
|
|
const { half, all: all2 } = getChildState(childNodes);
|
|
if (!all2) {
|
|
this.checked = all2;
|
|
this.indeterminate = half;
|
|
}
|
|
}
|
|
};
|
|
if (this.shouldLoadData()) {
|
|
this.loadData(() => {
|
|
handleDescendants();
|
|
reInitChecked(this);
|
|
}, {
|
|
checked: value !== false
|
|
});
|
|
return;
|
|
} else {
|
|
handleDescendants();
|
|
}
|
|
}
|
|
const parent2 = this.parent;
|
|
if (!parent2 || parent2.level === 0)
|
|
return;
|
|
if (!recursion) {
|
|
reInitChecked(parent2);
|
|
}
|
|
}
|
|
getChildren(forceInit = false) {
|
|
if (this.level === 0)
|
|
return this.data;
|
|
const data = this.data;
|
|
if (!data)
|
|
return null;
|
|
const props2 = this.store.props;
|
|
let children = "children";
|
|
if (props2) {
|
|
children = props2.children || "children";
|
|
}
|
|
if (isUndefined2(data[children])) {
|
|
data[children] = null;
|
|
}
|
|
if (forceInit && !data[children]) {
|
|
data[children] = [];
|
|
}
|
|
return data[children];
|
|
}
|
|
updateChildren() {
|
|
const newData = this.getChildren() || [];
|
|
const oldData = this.childNodes.map((node) => node.data);
|
|
const newDataMap = {};
|
|
const newNodes = [];
|
|
newData.forEach((item, index) => {
|
|
const key = item[NODE_KEY];
|
|
const isNodeExists = !!key && oldData.findIndex((data) => data[NODE_KEY] === key) >= 0;
|
|
if (isNodeExists) {
|
|
newDataMap[key] = { index, data: item };
|
|
} else {
|
|
newNodes.push({ index, data: item });
|
|
}
|
|
});
|
|
if (!this.store.lazy) {
|
|
oldData.forEach((item) => {
|
|
if (!newDataMap[item[NODE_KEY]])
|
|
this.removeChildByData(item);
|
|
});
|
|
}
|
|
newNodes.forEach(({ index, data }) => {
|
|
this.insertChild({ data }, index);
|
|
});
|
|
this.updateLeafState();
|
|
}
|
|
loadData(callback, defaultProps6 = {}) {
|
|
if (this.store.lazy === true && this.store.load && !this.loaded && (!this.loading || Object.keys(defaultProps6).length)) {
|
|
this.loading = true;
|
|
const resolve = (children) => {
|
|
this.childNodes = [];
|
|
this.doCreateChildren(children, defaultProps6);
|
|
this.loaded = true;
|
|
this.loading = false;
|
|
this.updateLeafState();
|
|
if (callback) {
|
|
callback.call(this, children);
|
|
}
|
|
};
|
|
const reject2 = () => {
|
|
this.loading = false;
|
|
};
|
|
this.store.load(this, resolve, reject2);
|
|
} else {
|
|
if (callback) {
|
|
callback.call(this);
|
|
}
|
|
}
|
|
}
|
|
eachNode(callback) {
|
|
const arr = [this];
|
|
while (arr.length) {
|
|
const node = arr.shift();
|
|
arr.unshift(...node.childNodes);
|
|
callback(node);
|
|
}
|
|
}
|
|
reInitChecked() {
|
|
if (this.store.checkStrictly)
|
|
return;
|
|
reInitChecked(this);
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/tree/src/model/tree-store.mjs
|
|
var TreeStore = class {
|
|
constructor(options) {
|
|
this.currentNode = null;
|
|
this.currentNodeKey = null;
|
|
for (const option in options) {
|
|
if (hasOwn(options, option)) {
|
|
this[option] = options[option];
|
|
}
|
|
}
|
|
this.nodesMap = {};
|
|
}
|
|
initialize() {
|
|
this.root = new Node3({
|
|
data: this.data,
|
|
store: this
|
|
});
|
|
this.root.initialize();
|
|
if (this.lazy && this.load) {
|
|
const loadFn = this.load;
|
|
loadFn(this.root, (data) => {
|
|
this.root.doCreateChildren(data);
|
|
this._initDefaultCheckedNodes();
|
|
});
|
|
} else {
|
|
this._initDefaultCheckedNodes();
|
|
}
|
|
}
|
|
filter(value) {
|
|
const filterNodeMethod = this.filterNodeMethod;
|
|
const lazy = this.lazy;
|
|
const traverse = async function(node) {
|
|
const childNodes = node.root ? node.root.childNodes : node.childNodes;
|
|
for (const [index, child] of childNodes.entries()) {
|
|
child.visible = filterNodeMethod.call(child, value, child.data, child);
|
|
if (index % 80 === 0 && index > 0) {
|
|
await nextTick();
|
|
}
|
|
await traverse(child);
|
|
}
|
|
if (!node.visible && childNodes.length) {
|
|
let allHidden = true;
|
|
allHidden = !childNodes.some((child) => child.visible);
|
|
if (node.root) {
|
|
node.root.visible = allHidden === false;
|
|
} else {
|
|
node.visible = allHidden === false;
|
|
}
|
|
}
|
|
if (!value)
|
|
return;
|
|
if (node.visible && !node.isLeaf) {
|
|
if (!lazy || node.loaded) {
|
|
node.expand();
|
|
}
|
|
}
|
|
};
|
|
traverse(this);
|
|
}
|
|
setData(newVal) {
|
|
const instanceChanged = newVal !== this.root.data;
|
|
if (instanceChanged) {
|
|
this.nodesMap = {};
|
|
this.root.setData(newVal);
|
|
this._initDefaultCheckedNodes();
|
|
this.setCurrentNodeKey(this.currentNodeKey);
|
|
} else {
|
|
this.root.updateChildren();
|
|
}
|
|
}
|
|
getNode(data) {
|
|
if (data instanceof Node3)
|
|
return data;
|
|
const key = isObject(data) ? getNodeKey(this.key, data) : data;
|
|
return this.nodesMap[key] || null;
|
|
}
|
|
insertBefore(data, refData) {
|
|
const refNode = this.getNode(refData);
|
|
refNode.parent.insertBefore({ data }, refNode);
|
|
}
|
|
insertAfter(data, refData) {
|
|
const refNode = this.getNode(refData);
|
|
refNode.parent.insertAfter({ data }, refNode);
|
|
}
|
|
remove(data) {
|
|
const node = this.getNode(data);
|
|
if (node && node.parent) {
|
|
if (node === this.currentNode) {
|
|
this.currentNode = null;
|
|
}
|
|
node.parent.removeChild(node);
|
|
}
|
|
}
|
|
append(data, parentData) {
|
|
const parentNode = !isPropAbsent(parentData) ? this.getNode(parentData) : this.root;
|
|
if (parentNode) {
|
|
parentNode.insertChild({ data });
|
|
}
|
|
}
|
|
_initDefaultCheckedNodes() {
|
|
const defaultCheckedKeys = this.defaultCheckedKeys || [];
|
|
const nodesMap = this.nodesMap;
|
|
defaultCheckedKeys.forEach((checkedKey) => {
|
|
const node = nodesMap[checkedKey];
|
|
if (node) {
|
|
node.setChecked(true, !this.checkStrictly);
|
|
}
|
|
});
|
|
}
|
|
_initDefaultCheckedNode(node) {
|
|
const defaultCheckedKeys = this.defaultCheckedKeys || [];
|
|
if (defaultCheckedKeys.includes(node.key)) {
|
|
node.setChecked(true, !this.checkStrictly);
|
|
}
|
|
}
|
|
setDefaultCheckedKey(newVal) {
|
|
if (newVal !== this.defaultCheckedKeys) {
|
|
this.defaultCheckedKeys = newVal;
|
|
this._initDefaultCheckedNodes();
|
|
}
|
|
}
|
|
registerNode(node) {
|
|
const key = this.key;
|
|
if (!node || !node.data)
|
|
return;
|
|
if (!key) {
|
|
this.nodesMap[node.id] = node;
|
|
} else {
|
|
const nodeKey = node.key;
|
|
if (nodeKey !== void 0)
|
|
this.nodesMap[node.key] = node;
|
|
}
|
|
}
|
|
deregisterNode(node) {
|
|
const key = this.key;
|
|
if (!key || !node || !node.data)
|
|
return;
|
|
node.childNodes.forEach((child) => {
|
|
this.deregisterNode(child);
|
|
});
|
|
delete this.nodesMap[node.key];
|
|
}
|
|
getCheckedNodes(leafOnly = false, includeHalfChecked = false) {
|
|
const checkedNodes = [];
|
|
const traverse = function(node) {
|
|
const childNodes = node.root ? node.root.childNodes : node.childNodes;
|
|
childNodes.forEach((child) => {
|
|
if ((child.checked || includeHalfChecked && child.indeterminate) && (!leafOnly || leafOnly && child.isLeaf)) {
|
|
checkedNodes.push(child.data);
|
|
}
|
|
traverse(child);
|
|
});
|
|
};
|
|
traverse(this);
|
|
return checkedNodes;
|
|
}
|
|
getCheckedKeys(leafOnly = false) {
|
|
return this.getCheckedNodes(leafOnly).map((data) => (data || {})[this.key]);
|
|
}
|
|
getHalfCheckedNodes() {
|
|
const nodes = [];
|
|
const traverse = function(node) {
|
|
const childNodes = node.root ? node.root.childNodes : node.childNodes;
|
|
childNodes.forEach((child) => {
|
|
if (child.indeterminate) {
|
|
nodes.push(child.data);
|
|
}
|
|
traverse(child);
|
|
});
|
|
};
|
|
traverse(this);
|
|
return nodes;
|
|
}
|
|
getHalfCheckedKeys() {
|
|
return this.getHalfCheckedNodes().map((data) => (data || {})[this.key]);
|
|
}
|
|
_getAllNodes() {
|
|
const allNodes = [];
|
|
const nodesMap = this.nodesMap;
|
|
for (const nodeKey in nodesMap) {
|
|
if (hasOwn(nodesMap, nodeKey)) {
|
|
allNodes.push(nodesMap[nodeKey]);
|
|
}
|
|
}
|
|
return allNodes;
|
|
}
|
|
updateChildren(key, data) {
|
|
const node = this.nodesMap[key];
|
|
if (!node)
|
|
return;
|
|
const childNodes = node.childNodes;
|
|
for (let i = childNodes.length - 1; i >= 0; i--) {
|
|
const child = childNodes[i];
|
|
this.remove(child.data);
|
|
}
|
|
for (let i = 0, j = data.length; i < j; i++) {
|
|
const child = data[i];
|
|
this.append(child, node.data);
|
|
}
|
|
}
|
|
_setCheckedKeys(key, leafOnly = false, checkedKeys) {
|
|
const allNodes = this._getAllNodes().sort((a2, b2) => a2.level - b2.level);
|
|
const cache2 = Object.create(null);
|
|
const keys3 = Object.keys(checkedKeys);
|
|
allNodes.forEach((node) => node.setChecked(false, false));
|
|
const cacheCheckedChild = (node) => {
|
|
node.childNodes.forEach((child) => {
|
|
var _a2;
|
|
cache2[child.data[key]] = true;
|
|
if ((_a2 = child.childNodes) == null ? void 0 : _a2.length) {
|
|
cacheCheckedChild(child);
|
|
}
|
|
});
|
|
};
|
|
for (let i = 0, j = allNodes.length; i < j; i++) {
|
|
const node = allNodes[i];
|
|
const nodeKey = node.data[key].toString();
|
|
const checked = keys3.includes(nodeKey);
|
|
if (!checked) {
|
|
if (node.checked && !cache2[nodeKey]) {
|
|
node.setChecked(false, false);
|
|
}
|
|
continue;
|
|
}
|
|
if (node.childNodes.length) {
|
|
cacheCheckedChild(node);
|
|
}
|
|
if (node.isLeaf || this.checkStrictly) {
|
|
node.setChecked(true, false);
|
|
continue;
|
|
}
|
|
node.setChecked(true, true);
|
|
if (leafOnly) {
|
|
node.setChecked(false, false);
|
|
const traverse = function(node2) {
|
|
const childNodes = node2.childNodes;
|
|
childNodes.forEach((child) => {
|
|
if (!child.isLeaf) {
|
|
child.setChecked(false, false);
|
|
}
|
|
traverse(child);
|
|
});
|
|
};
|
|
traverse(node);
|
|
}
|
|
}
|
|
}
|
|
setCheckedNodes(array4, leafOnly = false) {
|
|
const key = this.key;
|
|
const checkedKeys = {};
|
|
array4.forEach((item) => {
|
|
checkedKeys[(item || {})[key]] = true;
|
|
});
|
|
this._setCheckedKeys(key, leafOnly, checkedKeys);
|
|
}
|
|
setCheckedKeys(keys3, leafOnly = false) {
|
|
this.defaultCheckedKeys = keys3;
|
|
const key = this.key;
|
|
const checkedKeys = {};
|
|
keys3.forEach((key2) => {
|
|
checkedKeys[key2] = true;
|
|
});
|
|
this._setCheckedKeys(key, leafOnly, checkedKeys);
|
|
}
|
|
setDefaultExpandedKeys(keys3) {
|
|
keys3 = keys3 || [];
|
|
this.defaultExpandedKeys = keys3;
|
|
keys3.forEach((key) => {
|
|
const node = this.getNode(key);
|
|
if (node)
|
|
node.expand(null, this.autoExpandParent);
|
|
});
|
|
}
|
|
setChecked(data, checked, deep) {
|
|
const node = this.getNode(data);
|
|
if (node) {
|
|
node.setChecked(!!checked, deep);
|
|
}
|
|
}
|
|
getCurrentNode() {
|
|
return this.currentNode;
|
|
}
|
|
setCurrentNode(currentNode) {
|
|
const prevCurrentNode = this.currentNode;
|
|
if (prevCurrentNode) {
|
|
prevCurrentNode.isCurrent = false;
|
|
}
|
|
this.currentNode = currentNode;
|
|
this.currentNode.isCurrent = true;
|
|
}
|
|
setUserCurrentNode(node, shouldAutoExpandParent = true) {
|
|
const key = node[this.key];
|
|
const currNode = this.nodesMap[key];
|
|
this.setCurrentNode(currNode);
|
|
if (shouldAutoExpandParent && this.currentNode.level > 1) {
|
|
this.currentNode.parent.expand(null, true);
|
|
}
|
|
}
|
|
setCurrentNodeKey(key, shouldAutoExpandParent = true) {
|
|
this.currentNodeKey = key;
|
|
if (isPropAbsent(key)) {
|
|
this.currentNode && (this.currentNode.isCurrent = false);
|
|
this.currentNode = null;
|
|
return;
|
|
}
|
|
const node = this.getNode(key);
|
|
if (node) {
|
|
this.setCurrentNode(node);
|
|
if (shouldAutoExpandParent && this.currentNode.level > 1) {
|
|
this.currentNode.parent.expand(null, true);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/tree/src/tree-node-content.mjs
|
|
var _sfc_main134 = defineComponent({
|
|
name: "ElTreeNodeContent",
|
|
props: {
|
|
node: {
|
|
type: Object,
|
|
required: true
|
|
},
|
|
renderContent: Function
|
|
},
|
|
setup(props2) {
|
|
const ns = useNamespace("tree");
|
|
const nodeInstance = inject("NodeInstance");
|
|
const tree = inject("RootTree");
|
|
return () => {
|
|
const node = props2.node;
|
|
const { data, store } = node;
|
|
return props2.renderContent ? props2.renderContent(h, { _self: nodeInstance, node, data, store }) : renderSlot(tree.ctx.slots, "default", { node, data }, () => [
|
|
h(ElText, { tag: "span", truncated: true, class: ns.be("node", "label") }, () => [node.label])
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
var NodeContent2 = _export_sfc(_sfc_main134, [["__file", "tree-node-content.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tree/src/model/useNodeExpandEventBroadcast.mjs
|
|
function useNodeExpandEventBroadcast(props2) {
|
|
const parentNodeMap = inject("TreeNodeMap", null);
|
|
const currentNodeMap = {
|
|
treeNodeExpand: (node) => {
|
|
if (props2.node !== node) {
|
|
props2.node.collapse();
|
|
}
|
|
},
|
|
children: []
|
|
};
|
|
if (parentNodeMap) {
|
|
parentNodeMap.children.push(currentNodeMap);
|
|
}
|
|
provide("TreeNodeMap", currentNodeMap);
|
|
return {
|
|
broadcastExpanded: (node) => {
|
|
if (!props2.accordion)
|
|
return;
|
|
for (const childNode of currentNodeMap.children) {
|
|
childNode.treeNodeExpand(node);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/tree/src/model/useDragNode.mjs
|
|
var dragEventsKey = Symbol("dragEvents");
|
|
function useDragNodeHandler({ props: props2, ctx, el$, dropIndicator$, store }) {
|
|
const ns = useNamespace("tree");
|
|
const dragState = ref({
|
|
showDropIndicator: false,
|
|
draggingNode: null,
|
|
dropNode: null,
|
|
allowDrop: true,
|
|
dropType: null
|
|
});
|
|
const treeNodeDragStart = ({ event, treeNode }) => {
|
|
if (isFunction(props2.allowDrag) && !props2.allowDrag(treeNode.node)) {
|
|
event.preventDefault();
|
|
return false;
|
|
}
|
|
event.dataTransfer.effectAllowed = "move";
|
|
try {
|
|
event.dataTransfer.setData("text/plain", "");
|
|
} catch (e) {
|
|
}
|
|
dragState.value.draggingNode = treeNode;
|
|
ctx.emit("node-drag-start", treeNode.node, event);
|
|
};
|
|
const treeNodeDragOver = ({ event, treeNode }) => {
|
|
const dropNode = treeNode;
|
|
const oldDropNode = dragState.value.dropNode;
|
|
if (oldDropNode && oldDropNode.node.id !== dropNode.node.id) {
|
|
removeClass(oldDropNode.$el, ns.is("drop-inner"));
|
|
}
|
|
const draggingNode = dragState.value.draggingNode;
|
|
if (!draggingNode || !dropNode)
|
|
return;
|
|
let dropPrev = true;
|
|
let dropInner = true;
|
|
let dropNext = true;
|
|
let userAllowDropInner = true;
|
|
if (isFunction(props2.allowDrop)) {
|
|
dropPrev = props2.allowDrop(draggingNode.node, dropNode.node, "prev");
|
|
userAllowDropInner = dropInner = props2.allowDrop(draggingNode.node, dropNode.node, "inner");
|
|
dropNext = props2.allowDrop(draggingNode.node, dropNode.node, "next");
|
|
}
|
|
event.dataTransfer.dropEffect = dropInner || dropPrev || dropNext ? "move" : "none";
|
|
if ((dropPrev || dropInner || dropNext) && (oldDropNode == null ? void 0 : oldDropNode.node.id) !== dropNode.node.id) {
|
|
if (oldDropNode) {
|
|
ctx.emit("node-drag-leave", draggingNode.node, oldDropNode.node, event);
|
|
}
|
|
ctx.emit("node-drag-enter", draggingNode.node, dropNode.node, event);
|
|
}
|
|
if (dropPrev || dropInner || dropNext) {
|
|
dragState.value.dropNode = dropNode;
|
|
} else {
|
|
dragState.value.dropNode = null;
|
|
}
|
|
if (dropNode.node.nextSibling === draggingNode.node) {
|
|
dropNext = false;
|
|
}
|
|
if (dropNode.node.previousSibling === draggingNode.node) {
|
|
dropPrev = false;
|
|
}
|
|
if (dropNode.node.contains(draggingNode.node, false)) {
|
|
dropInner = false;
|
|
}
|
|
if (draggingNode.node === dropNode.node || draggingNode.node.contains(dropNode.node)) {
|
|
dropPrev = false;
|
|
dropInner = false;
|
|
dropNext = false;
|
|
}
|
|
const targetPosition = dropNode.$el.querySelector(`.${ns.be("node", "content")}`).getBoundingClientRect();
|
|
const treePosition = el$.value.getBoundingClientRect();
|
|
let dropType;
|
|
const prevPercent = dropPrev ? dropInner ? 0.25 : dropNext ? 0.45 : 1 : -1;
|
|
const nextPercent = dropNext ? dropInner ? 0.75 : dropPrev ? 0.55 : 0 : 1;
|
|
let indicatorTop = -9999;
|
|
const distance = event.clientY - targetPosition.top;
|
|
if (distance < targetPosition.height * prevPercent) {
|
|
dropType = "before";
|
|
} else if (distance > targetPosition.height * nextPercent) {
|
|
dropType = "after";
|
|
} else if (dropInner) {
|
|
dropType = "inner";
|
|
} else {
|
|
dropType = "none";
|
|
}
|
|
const iconPosition = dropNode.$el.querySelector(`.${ns.be("node", "expand-icon")}`).getBoundingClientRect();
|
|
const dropIndicator = dropIndicator$.value;
|
|
if (dropType === "before") {
|
|
indicatorTop = iconPosition.top - treePosition.top;
|
|
} else if (dropType === "after") {
|
|
indicatorTop = iconPosition.bottom - treePosition.top;
|
|
}
|
|
dropIndicator.style.top = `${indicatorTop}px`;
|
|
dropIndicator.style.left = `${iconPosition.right - treePosition.left}px`;
|
|
if (dropType === "inner") {
|
|
addClass(dropNode.$el, ns.is("drop-inner"));
|
|
} else {
|
|
removeClass(dropNode.$el, ns.is("drop-inner"));
|
|
}
|
|
dragState.value.showDropIndicator = dropType === "before" || dropType === "after";
|
|
dragState.value.allowDrop = dragState.value.showDropIndicator || userAllowDropInner;
|
|
dragState.value.dropType = dropType;
|
|
ctx.emit("node-drag-over", draggingNode.node, dropNode.node, event);
|
|
};
|
|
const treeNodeDragEnd = (event) => {
|
|
const { draggingNode, dropType, dropNode } = dragState.value;
|
|
event.preventDefault();
|
|
if (event.dataTransfer) {
|
|
event.dataTransfer.dropEffect = "move";
|
|
}
|
|
if (draggingNode && dropNode) {
|
|
const draggingNodeCopy = { data: draggingNode.node.data };
|
|
if (dropType !== "none") {
|
|
draggingNode.node.remove();
|
|
}
|
|
if (dropType === "before") {
|
|
dropNode.node.parent.insertBefore(draggingNodeCopy, dropNode.node);
|
|
} else if (dropType === "after") {
|
|
dropNode.node.parent.insertAfter(draggingNodeCopy, dropNode.node);
|
|
} else if (dropType === "inner") {
|
|
dropNode.node.insertChild(draggingNodeCopy);
|
|
}
|
|
if (dropType !== "none") {
|
|
store.value.registerNode(draggingNodeCopy);
|
|
if (store.value.key) {
|
|
draggingNode.node.eachNode((node) => {
|
|
var _a2;
|
|
(_a2 = store.value.nodesMap[node.data[store.value.key]]) == null ? void 0 : _a2.setChecked(node.checked, !store.value.checkStrictly);
|
|
});
|
|
}
|
|
}
|
|
removeClass(dropNode.$el, ns.is("drop-inner"));
|
|
ctx.emit("node-drag-end", draggingNode.node, dropNode.node, dropType, event);
|
|
if (dropType !== "none") {
|
|
ctx.emit("node-drop", draggingNode.node, dropNode.node, dropType, event);
|
|
}
|
|
}
|
|
if (draggingNode && !dropNode) {
|
|
ctx.emit("node-drag-end", draggingNode.node, null, dropType, event);
|
|
}
|
|
dragState.value.showDropIndicator = false;
|
|
dragState.value.draggingNode = null;
|
|
dragState.value.dropNode = null;
|
|
dragState.value.allowDrop = true;
|
|
};
|
|
provide(dragEventsKey, {
|
|
treeNodeDragStart,
|
|
treeNodeDragOver,
|
|
treeNodeDragEnd
|
|
});
|
|
return {
|
|
dragState
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/tree/src/tree-node.mjs
|
|
var _sfc_main135 = defineComponent({
|
|
name: "ElTreeNode",
|
|
components: {
|
|
ElCollapseTransition,
|
|
ElCheckbox,
|
|
NodeContent: NodeContent2,
|
|
ElIcon,
|
|
Loading: loading_default
|
|
},
|
|
props: {
|
|
node: {
|
|
type: Node3,
|
|
default: () => ({})
|
|
},
|
|
props: {
|
|
type: Object,
|
|
default: () => ({})
|
|
},
|
|
accordion: Boolean,
|
|
renderContent: Function,
|
|
renderAfterExpand: Boolean,
|
|
showCheckbox: {
|
|
type: Boolean,
|
|
default: false
|
|
}
|
|
},
|
|
emits: ["node-expand"],
|
|
setup(props2, ctx) {
|
|
const ns = useNamespace("tree");
|
|
const { broadcastExpanded } = useNodeExpandEventBroadcast(props2);
|
|
const tree = inject("RootTree");
|
|
const expanded = ref(false);
|
|
const childNodeRendered = ref(false);
|
|
const oldChecked = ref();
|
|
const oldIndeterminate = ref();
|
|
const node$ = ref();
|
|
const dragEvents = inject(dragEventsKey);
|
|
const instance = getCurrentInstance();
|
|
provide("NodeInstance", instance);
|
|
if (!tree) {
|
|
debugWarn("Tree", "Can not find node's tree.");
|
|
}
|
|
if (props2.node.expanded) {
|
|
expanded.value = true;
|
|
childNodeRendered.value = true;
|
|
}
|
|
const childrenKey = tree.props.props["children"] || "children";
|
|
watch(() => {
|
|
var _a2;
|
|
const children = (_a2 = props2.node.data) == null ? void 0 : _a2[childrenKey];
|
|
return children && [...children];
|
|
}, () => {
|
|
props2.node.updateChildren();
|
|
});
|
|
watch(() => props2.node.indeterminate, (val) => {
|
|
handleSelectChange(props2.node.checked, val);
|
|
});
|
|
watch(() => props2.node.checked, (val) => {
|
|
handleSelectChange(val, props2.node.indeterminate);
|
|
});
|
|
watch(() => props2.node.childNodes.length, () => props2.node.reInitChecked());
|
|
watch(() => props2.node.expanded, (val) => {
|
|
nextTick(() => expanded.value = val);
|
|
if (val) {
|
|
childNodeRendered.value = true;
|
|
}
|
|
});
|
|
const getNodeKey$1 = (node) => {
|
|
return getNodeKey(tree.props.nodeKey, node.data);
|
|
};
|
|
const getNodeClass = (node) => {
|
|
const nodeClassFunc = props2.props.class;
|
|
if (!nodeClassFunc) {
|
|
return {};
|
|
}
|
|
let className;
|
|
if (isFunction(nodeClassFunc)) {
|
|
const { data } = node;
|
|
className = nodeClassFunc(data, node);
|
|
} else {
|
|
className = nodeClassFunc;
|
|
}
|
|
if (isString(className)) {
|
|
return { [className]: true };
|
|
} else {
|
|
return className;
|
|
}
|
|
};
|
|
const handleSelectChange = (checked, indeterminate) => {
|
|
if (oldChecked.value !== checked || oldIndeterminate.value !== indeterminate) {
|
|
tree.ctx.emit("check-change", props2.node.data, checked, indeterminate);
|
|
}
|
|
oldChecked.value = checked;
|
|
oldIndeterminate.value = indeterminate;
|
|
};
|
|
const handleClick = (e) => {
|
|
handleCurrentChange(tree.store, tree.ctx.emit, () => {
|
|
var _a2;
|
|
const nodeKeyProp = (_a2 = tree == null ? void 0 : tree.props) == null ? void 0 : _a2.nodeKey;
|
|
if (nodeKeyProp) {
|
|
const curNodeKey = getNodeKey$1(props2.node);
|
|
tree.store.value.setCurrentNodeKey(curNodeKey);
|
|
} else {
|
|
tree.store.value.setCurrentNode(props2.node);
|
|
}
|
|
});
|
|
tree.currentNode.value = props2.node;
|
|
if (tree.props.expandOnClickNode) {
|
|
handleExpandIconClick();
|
|
}
|
|
if ((tree.props.checkOnClickNode || props2.node.isLeaf && tree.props.checkOnClickLeaf && props2.showCheckbox) && !props2.node.disabled) {
|
|
handleCheckChange(!props2.node.checked);
|
|
}
|
|
tree.ctx.emit("node-click", props2.node.data, props2.node, instance, e);
|
|
};
|
|
const handleContextMenu = (event) => {
|
|
var _a2;
|
|
if ((_a2 = tree.instance.vnode.props) == null ? void 0 : _a2["onNodeContextmenu"]) {
|
|
event.stopPropagation();
|
|
event.preventDefault();
|
|
}
|
|
tree.ctx.emit("node-contextmenu", event, props2.node.data, props2.node, instance);
|
|
};
|
|
const handleExpandIconClick = () => {
|
|
if (props2.node.isLeaf)
|
|
return;
|
|
if (expanded.value) {
|
|
tree.ctx.emit("node-collapse", props2.node.data, props2.node, instance);
|
|
props2.node.collapse();
|
|
} else {
|
|
props2.node.expand(() => {
|
|
ctx.emit("node-expand", props2.node.data, props2.node, instance);
|
|
});
|
|
}
|
|
};
|
|
const handleCheckChange = (value) => {
|
|
props2.node.setChecked(value, !(tree == null ? void 0 : tree.props.checkStrictly));
|
|
nextTick(() => {
|
|
const store = tree.store.value;
|
|
tree.ctx.emit("check", props2.node.data, {
|
|
checkedNodes: store.getCheckedNodes(),
|
|
checkedKeys: store.getCheckedKeys(),
|
|
halfCheckedNodes: store.getHalfCheckedNodes(),
|
|
halfCheckedKeys: store.getHalfCheckedKeys()
|
|
});
|
|
});
|
|
};
|
|
const handleChildNodeExpand = (nodeData, node, instance2) => {
|
|
broadcastExpanded(node);
|
|
tree.ctx.emit("node-expand", nodeData, node, instance2);
|
|
};
|
|
const handleDragStart = (event) => {
|
|
if (!tree.props.draggable)
|
|
return;
|
|
dragEvents.treeNodeDragStart({ event, treeNode: props2 });
|
|
};
|
|
const handleDragOver = (event) => {
|
|
event.preventDefault();
|
|
if (!tree.props.draggable)
|
|
return;
|
|
dragEvents.treeNodeDragOver({
|
|
event,
|
|
treeNode: { $el: node$.value, node: props2.node }
|
|
});
|
|
};
|
|
const handleDrop = (event) => {
|
|
event.preventDefault();
|
|
};
|
|
const handleDragEnd = (event) => {
|
|
if (!tree.props.draggable)
|
|
return;
|
|
dragEvents.treeNodeDragEnd(event);
|
|
};
|
|
return {
|
|
ns,
|
|
node$,
|
|
tree,
|
|
expanded,
|
|
childNodeRendered,
|
|
oldChecked,
|
|
oldIndeterminate,
|
|
getNodeKey: getNodeKey$1,
|
|
getNodeClass,
|
|
handleSelectChange,
|
|
handleClick,
|
|
handleContextMenu,
|
|
handleExpandIconClick,
|
|
handleCheckChange,
|
|
handleChildNodeExpand,
|
|
handleDragStart,
|
|
handleDragOver,
|
|
handleDrop,
|
|
handleDragEnd,
|
|
CaretRight: caret_right_default
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render26(_ctx, _cache, $props, $setup, $data, $options) {
|
|
const _component_el_icon = resolveComponent("el-icon");
|
|
const _component_el_checkbox = resolveComponent("el-checkbox");
|
|
const _component_loading = resolveComponent("loading");
|
|
const _component_node_content = resolveComponent("node-content");
|
|
const _component_el_tree_node = resolveComponent("el-tree-node");
|
|
const _component_el_collapse_transition = resolveComponent("el-collapse-transition");
|
|
return withDirectives((openBlock(), createElementBlock("div", {
|
|
ref: "node$",
|
|
class: normalizeClass([
|
|
_ctx.ns.b("node"),
|
|
_ctx.ns.is("expanded", _ctx.expanded),
|
|
_ctx.ns.is("current", _ctx.node.isCurrent),
|
|
_ctx.ns.is("hidden", !_ctx.node.visible),
|
|
_ctx.ns.is("focusable", !_ctx.node.disabled),
|
|
_ctx.ns.is("checked", !_ctx.node.disabled && _ctx.node.checked),
|
|
_ctx.getNodeClass(_ctx.node)
|
|
]),
|
|
role: "treeitem",
|
|
tabindex: "-1",
|
|
"aria-expanded": _ctx.expanded,
|
|
"aria-disabled": _ctx.node.disabled,
|
|
"aria-checked": _ctx.node.checked,
|
|
draggable: _ctx.tree.props.draggable,
|
|
"data-key": _ctx.getNodeKey(_ctx.node),
|
|
onClick: withModifiers(_ctx.handleClick, ["stop"]),
|
|
onContextmenu: _ctx.handleContextMenu,
|
|
onDragstart: withModifiers(_ctx.handleDragStart, ["stop"]),
|
|
onDragover: withModifiers(_ctx.handleDragOver, ["stop"]),
|
|
onDragend: withModifiers(_ctx.handleDragEnd, ["stop"]),
|
|
onDrop: withModifiers(_ctx.handleDrop, ["stop"])
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.ns.be("node", "content")),
|
|
style: normalizeStyle({ paddingLeft: (_ctx.node.level - 1) * _ctx.tree.props.indent + "px" })
|
|
}, [
|
|
_ctx.tree.props.icon || _ctx.CaretRight ? (openBlock(), createBlock(_component_el_icon, {
|
|
key: 0,
|
|
class: normalizeClass([
|
|
_ctx.ns.be("node", "expand-icon"),
|
|
_ctx.ns.is("leaf", _ctx.node.isLeaf),
|
|
{
|
|
expanded: !_ctx.node.isLeaf && _ctx.expanded
|
|
}
|
|
]),
|
|
onClick: withModifiers(_ctx.handleExpandIconClick, ["stop"])
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.tree.props.icon || _ctx.CaretRight)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "onClick"])) : createCommentVNode("v-if", true),
|
|
_ctx.showCheckbox ? (openBlock(), createBlock(_component_el_checkbox, {
|
|
key: 1,
|
|
"model-value": _ctx.node.checked,
|
|
indeterminate: _ctx.node.indeterminate,
|
|
disabled: !!_ctx.node.disabled,
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"]),
|
|
onChange: _ctx.handleCheckChange
|
|
}, null, 8, ["model-value", "indeterminate", "disabled", "onClick", "onChange"])) : createCommentVNode("v-if", true),
|
|
_ctx.node.loading ? (openBlock(), createBlock(_component_el_icon, {
|
|
key: 2,
|
|
class: normalizeClass([_ctx.ns.be("node", "loading-icon"), _ctx.ns.is("loading")])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(_component_loading)
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true),
|
|
createVNode(_component_node_content, {
|
|
node: _ctx.node,
|
|
"render-content": _ctx.renderContent
|
|
}, null, 8, ["node", "render-content"])
|
|
], 6),
|
|
createVNode(_component_el_collapse_transition, null, {
|
|
default: withCtx(() => [
|
|
!_ctx.renderAfterExpand || _ctx.childNodeRendered ? withDirectives((openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(_ctx.ns.be("node", "children")),
|
|
role: "group",
|
|
"aria-expanded": _ctx.expanded,
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.node.childNodes, (child) => {
|
|
return openBlock(), createBlock(_component_el_tree_node, {
|
|
key: _ctx.getNodeKey(child),
|
|
"render-content": _ctx.renderContent,
|
|
"render-after-expand": _ctx.renderAfterExpand,
|
|
"show-checkbox": _ctx.showCheckbox,
|
|
node: child,
|
|
accordion: _ctx.accordion,
|
|
props: _ctx.props,
|
|
onNodeExpand: _ctx.handleChildNodeExpand
|
|
}, null, 8, ["render-content", "render-after-expand", "show-checkbox", "node", "accordion", "props", "onNodeExpand"]);
|
|
}), 128))
|
|
], 10, ["aria-expanded", "onClick"])), [
|
|
[vShow, _ctx.expanded]
|
|
]) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 1
|
|
})
|
|
], 42, ["aria-expanded", "aria-disabled", "aria-checked", "draggable", "data-key", "onClick", "onContextmenu", "onDragstart", "onDragover", "onDragend", "onDrop"])), [
|
|
[vShow, _ctx.node.visible]
|
|
]);
|
|
}
|
|
var ElTreeNode = _export_sfc(_sfc_main135, [["render", _sfc_render26], ["__file", "tree-node.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tree/src/model/useKeydown.mjs
|
|
function useKeydown({ el$ }, store) {
|
|
const ns = useNamespace("tree");
|
|
onMounted(() => {
|
|
initTabIndex();
|
|
});
|
|
onUpdated(() => {
|
|
const checkboxItems = Array.from(el$.value.querySelectorAll("input[type=checkbox]"));
|
|
checkboxItems.forEach((checkbox) => {
|
|
checkbox.setAttribute("tabindex", "-1");
|
|
});
|
|
});
|
|
const handleKeydown = (ev) => {
|
|
const currentItem = ev.target;
|
|
if (!currentItem.className.includes(ns.b("node")))
|
|
return;
|
|
const code = ev.code;
|
|
const treeItems = Array.from(el$.value.querySelectorAll(`.${ns.is("focusable")}[role=treeitem]`));
|
|
const currentIndex = treeItems.indexOf(currentItem);
|
|
let nextIndex;
|
|
if ([EVENT_CODE.up, EVENT_CODE.down].includes(code)) {
|
|
ev.preventDefault();
|
|
if (code === EVENT_CODE.up) {
|
|
nextIndex = currentIndex === -1 ? 0 : currentIndex !== 0 ? currentIndex - 1 : treeItems.length - 1;
|
|
const startIndex = nextIndex;
|
|
while (true) {
|
|
if (store.value.getNode(treeItems[nextIndex].dataset.key).canFocus)
|
|
break;
|
|
nextIndex--;
|
|
if (nextIndex === startIndex) {
|
|
nextIndex = -1;
|
|
break;
|
|
}
|
|
if (nextIndex < 0) {
|
|
nextIndex = treeItems.length - 1;
|
|
}
|
|
}
|
|
} else {
|
|
nextIndex = currentIndex === -1 ? 0 : currentIndex < treeItems.length - 1 ? currentIndex + 1 : 0;
|
|
const startIndex = nextIndex;
|
|
while (true) {
|
|
if (store.value.getNode(treeItems[nextIndex].dataset.key).canFocus)
|
|
break;
|
|
nextIndex++;
|
|
if (nextIndex === startIndex) {
|
|
nextIndex = -1;
|
|
break;
|
|
}
|
|
if (nextIndex >= treeItems.length) {
|
|
nextIndex = 0;
|
|
}
|
|
}
|
|
}
|
|
nextIndex !== -1 && treeItems[nextIndex].focus();
|
|
}
|
|
if ([EVENT_CODE.left, EVENT_CODE.right].includes(code)) {
|
|
ev.preventDefault();
|
|
currentItem.click();
|
|
}
|
|
const hasInput = currentItem.querySelector('[type="checkbox"]');
|
|
if ([EVENT_CODE.enter, EVENT_CODE.numpadEnter, EVENT_CODE.space].includes(code) && hasInput) {
|
|
ev.preventDefault();
|
|
hasInput.click();
|
|
}
|
|
};
|
|
useEventListener(el$, "keydown", handleKeydown);
|
|
const initTabIndex = () => {
|
|
var _a2;
|
|
const treeItems = Array.from(el$.value.querySelectorAll(`.${ns.is("focusable")}[role=treeitem]`));
|
|
const checkboxItems = Array.from(el$.value.querySelectorAll("input[type=checkbox]"));
|
|
checkboxItems.forEach((checkbox) => {
|
|
checkbox.setAttribute("tabindex", "-1");
|
|
});
|
|
const checkedItem = el$.value.querySelectorAll(`.${ns.is("checked")}[role=treeitem]`);
|
|
if (checkedItem.length) {
|
|
checkedItem[0].setAttribute("tabindex", "0");
|
|
return;
|
|
}
|
|
(_a2 = treeItems[0]) == null ? void 0 : _a2.setAttribute("tabindex", "0");
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/tree/src/tree.mjs
|
|
var _sfc_main136 = defineComponent({
|
|
name: "ElTree",
|
|
components: { ElTreeNode },
|
|
props: {
|
|
data: {
|
|
type: Array,
|
|
default: () => []
|
|
},
|
|
emptyText: {
|
|
type: String
|
|
},
|
|
renderAfterExpand: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
nodeKey: String,
|
|
checkStrictly: Boolean,
|
|
defaultExpandAll: Boolean,
|
|
expandOnClickNode: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
checkOnClickNode: Boolean,
|
|
checkOnClickLeaf: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
checkDescendants: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
autoExpandParent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
defaultCheckedKeys: Array,
|
|
defaultExpandedKeys: Array,
|
|
currentNodeKey: [String, Number],
|
|
renderContent: Function,
|
|
showCheckbox: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
draggable: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
allowDrag: Function,
|
|
allowDrop: Function,
|
|
props: {
|
|
type: Object,
|
|
default: () => ({
|
|
children: "children",
|
|
label: "label",
|
|
disabled: "disabled"
|
|
})
|
|
},
|
|
lazy: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
highlightCurrent: Boolean,
|
|
load: Function,
|
|
filterNodeMethod: Function,
|
|
accordion: Boolean,
|
|
indent: {
|
|
type: Number,
|
|
default: 18
|
|
},
|
|
icon: {
|
|
type: iconPropType
|
|
}
|
|
},
|
|
emits: [
|
|
"check-change",
|
|
"current-change",
|
|
"node-click",
|
|
"node-contextmenu",
|
|
"node-collapse",
|
|
"node-expand",
|
|
"check",
|
|
"node-drag-start",
|
|
"node-drag-end",
|
|
"node-drop",
|
|
"node-drag-leave",
|
|
"node-drag-enter",
|
|
"node-drag-over"
|
|
],
|
|
setup(props2, ctx) {
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("tree");
|
|
const selectInfo = inject(selectKey, null);
|
|
const store = ref(new TreeStore({
|
|
key: props2.nodeKey,
|
|
data: props2.data,
|
|
lazy: props2.lazy,
|
|
props: props2.props,
|
|
load: props2.load,
|
|
currentNodeKey: props2.currentNodeKey,
|
|
checkStrictly: props2.checkStrictly,
|
|
checkDescendants: props2.checkDescendants,
|
|
defaultCheckedKeys: props2.defaultCheckedKeys,
|
|
defaultExpandedKeys: props2.defaultExpandedKeys,
|
|
autoExpandParent: props2.autoExpandParent,
|
|
defaultExpandAll: props2.defaultExpandAll,
|
|
filterNodeMethod: props2.filterNodeMethod
|
|
}));
|
|
store.value.initialize();
|
|
const root2 = ref(store.value.root);
|
|
const currentNode = ref(null);
|
|
const el$ = ref(null);
|
|
const dropIndicator$ = ref(null);
|
|
const { broadcastExpanded } = useNodeExpandEventBroadcast(props2);
|
|
const { dragState } = useDragNodeHandler({
|
|
props: props2,
|
|
ctx,
|
|
el$,
|
|
dropIndicator$,
|
|
store
|
|
});
|
|
useKeydown({ el$ }, store);
|
|
const isEmpty3 = computed(() => {
|
|
const { childNodes } = root2.value;
|
|
const hasFilteredOptions = selectInfo ? selectInfo.hasFilteredOptions !== 0 : false;
|
|
return (!childNodes || childNodes.length === 0 || childNodes.every(({ visible }) => !visible)) && !hasFilteredOptions;
|
|
});
|
|
watch(() => props2.currentNodeKey, (newVal) => {
|
|
store.value.setCurrentNodeKey(newVal);
|
|
});
|
|
watch(() => props2.defaultCheckedKeys, (newVal) => {
|
|
store.value.setDefaultCheckedKey(newVal);
|
|
});
|
|
watch(() => props2.defaultExpandedKeys, (newVal) => {
|
|
store.value.setDefaultExpandedKeys(newVal);
|
|
});
|
|
watch(() => props2.data, (newVal) => {
|
|
store.value.setData(newVal);
|
|
}, { deep: true });
|
|
watch(() => props2.checkStrictly, (newVal) => {
|
|
store.value.checkStrictly = newVal;
|
|
});
|
|
const filter2 = (value) => {
|
|
if (!props2.filterNodeMethod)
|
|
throw new Error("[Tree] filterNodeMethod is required when filter");
|
|
store.value.filter(value);
|
|
};
|
|
const getNodeKey$1 = (node) => {
|
|
return getNodeKey(props2.nodeKey, node.data);
|
|
};
|
|
const getNodePath = (data) => {
|
|
if (!props2.nodeKey)
|
|
throw new Error("[Tree] nodeKey is required in getNodePath");
|
|
const node = store.value.getNode(data);
|
|
if (!node)
|
|
return [];
|
|
const path = [node.data];
|
|
let parent2 = node.parent;
|
|
while (parent2 && parent2 !== root2.value) {
|
|
path.push(parent2.data);
|
|
parent2 = parent2.parent;
|
|
}
|
|
return path.reverse();
|
|
};
|
|
const getCheckedNodes = (leafOnly, includeHalfChecked) => {
|
|
return store.value.getCheckedNodes(leafOnly, includeHalfChecked);
|
|
};
|
|
const getCheckedKeys = (leafOnly) => {
|
|
return store.value.getCheckedKeys(leafOnly);
|
|
};
|
|
const getCurrentNode = () => {
|
|
const currentNode2 = store.value.getCurrentNode();
|
|
return currentNode2 ? currentNode2.data : null;
|
|
};
|
|
const getCurrentKey = () => {
|
|
if (!props2.nodeKey)
|
|
throw new Error("[Tree] nodeKey is required in getCurrentKey");
|
|
const currentNode2 = getCurrentNode();
|
|
return currentNode2 ? currentNode2[props2.nodeKey] : null;
|
|
};
|
|
const setCheckedNodes = (nodes, leafOnly) => {
|
|
if (!props2.nodeKey)
|
|
throw new Error("[Tree] nodeKey is required in setCheckedNodes");
|
|
store.value.setCheckedNodes(nodes, leafOnly);
|
|
};
|
|
const setCheckedKeys = (keys3, leafOnly) => {
|
|
if (!props2.nodeKey)
|
|
throw new Error("[Tree] nodeKey is required in setCheckedKeys");
|
|
store.value.setCheckedKeys(keys3, leafOnly);
|
|
};
|
|
const setChecked = (data, checked, deep) => {
|
|
store.value.setChecked(data, checked, deep);
|
|
};
|
|
const getHalfCheckedNodes = () => {
|
|
return store.value.getHalfCheckedNodes();
|
|
};
|
|
const getHalfCheckedKeys = () => {
|
|
return store.value.getHalfCheckedKeys();
|
|
};
|
|
const setCurrentNode = (node, shouldAutoExpandParent = true) => {
|
|
if (!props2.nodeKey)
|
|
throw new Error("[Tree] nodeKey is required in setCurrentNode");
|
|
handleCurrentChange(store, ctx.emit, () => {
|
|
broadcastExpanded(node);
|
|
store.value.setUserCurrentNode(node, shouldAutoExpandParent);
|
|
});
|
|
};
|
|
const setCurrentKey = (key, shouldAutoExpandParent = true) => {
|
|
if (!props2.nodeKey)
|
|
throw new Error("[Tree] nodeKey is required in setCurrentKey");
|
|
handleCurrentChange(store, ctx.emit, () => {
|
|
broadcastExpanded();
|
|
store.value.setCurrentNodeKey(key, shouldAutoExpandParent);
|
|
});
|
|
};
|
|
const getNode = (data) => {
|
|
return store.value.getNode(data);
|
|
};
|
|
const remove2 = (data) => {
|
|
store.value.remove(data);
|
|
};
|
|
const append = (data, parentNode) => {
|
|
store.value.append(data, parentNode);
|
|
};
|
|
const insertBefore = (data, refNode) => {
|
|
store.value.insertBefore(data, refNode);
|
|
};
|
|
const insertAfter = (data, refNode) => {
|
|
store.value.insertAfter(data, refNode);
|
|
};
|
|
const handleNodeExpand = (nodeData, node, instance) => {
|
|
broadcastExpanded(node);
|
|
ctx.emit("node-expand", nodeData, node, instance);
|
|
};
|
|
const updateKeyChildren = (key, data) => {
|
|
if (!props2.nodeKey)
|
|
throw new Error("[Tree] nodeKey is required in updateKeyChild");
|
|
store.value.updateChildren(key, data);
|
|
};
|
|
provide("RootTree", {
|
|
ctx,
|
|
props: props2,
|
|
store,
|
|
root: root2,
|
|
currentNode,
|
|
instance: getCurrentInstance()
|
|
});
|
|
provide(formItemContextKey, void 0);
|
|
return {
|
|
ns,
|
|
store,
|
|
root: root2,
|
|
currentNode,
|
|
dragState,
|
|
el$,
|
|
dropIndicator$,
|
|
isEmpty: isEmpty3,
|
|
filter: filter2,
|
|
getNodeKey: getNodeKey$1,
|
|
getNodePath,
|
|
getCheckedNodes,
|
|
getCheckedKeys,
|
|
getCurrentNode,
|
|
getCurrentKey,
|
|
setCheckedNodes,
|
|
setCheckedKeys,
|
|
setChecked,
|
|
getHalfCheckedNodes,
|
|
getHalfCheckedKeys,
|
|
setCurrentNode,
|
|
setCurrentKey,
|
|
t,
|
|
getNode,
|
|
remove: remove2,
|
|
append,
|
|
insertBefore,
|
|
insertAfter,
|
|
handleNodeExpand,
|
|
updateKeyChildren
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render27(_ctx, _cache, $props, $setup, $data, $options) {
|
|
const _component_el_tree_node = resolveComponent("el-tree-node");
|
|
return openBlock(), createElementBlock("div", {
|
|
ref: "el$",
|
|
class: normalizeClass([
|
|
_ctx.ns.b(),
|
|
_ctx.ns.is("dragging", !!_ctx.dragState.draggingNode),
|
|
_ctx.ns.is("drop-not-allow", !_ctx.dragState.allowDrop),
|
|
_ctx.ns.is("drop-inner", _ctx.dragState.dropType === "inner"),
|
|
{ [_ctx.ns.m("highlight-current")]: _ctx.highlightCurrent }
|
|
]),
|
|
role: "tree"
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.root.childNodes, (child) => {
|
|
return openBlock(), createBlock(_component_el_tree_node, {
|
|
key: _ctx.getNodeKey(child),
|
|
node: child,
|
|
props: _ctx.props,
|
|
accordion: _ctx.accordion,
|
|
"render-after-expand": _ctx.renderAfterExpand,
|
|
"show-checkbox": _ctx.showCheckbox,
|
|
"render-content": _ctx.renderContent,
|
|
onNodeExpand: _ctx.handleNodeExpand
|
|
}, null, 8, ["node", "props", "accordion", "render-after-expand", "show-checkbox", "render-content", "onNodeExpand"]);
|
|
}), 128)),
|
|
_ctx.isEmpty ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(_ctx.ns.e("empty-block"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "empty", {}, () => {
|
|
var _a2;
|
|
return [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(_ctx.ns.e("empty-text"))
|
|
}, toDisplayString((_a2 = _ctx.emptyText) != null ? _a2 : _ctx.t("el.tree.emptyText")), 3)
|
|
];
|
|
})
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
withDirectives(createBaseVNode("div", {
|
|
ref: "dropIndicator$",
|
|
class: normalizeClass(_ctx.ns.e("drop-indicator"))
|
|
}, null, 2), [
|
|
[vShow, _ctx.dragState.showDropIndicator]
|
|
])
|
|
], 2);
|
|
}
|
|
var Tree = _export_sfc(_sfc_main136, [["render", _sfc_render27], ["__file", "tree.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tree/index.mjs
|
|
var ElTree = withInstall(Tree);
|
|
|
|
// node_modules/element-plus/es/components/tree-select/src/select.mjs
|
|
var useSelect3 = (props2, { attrs, emit }, {
|
|
select,
|
|
tree,
|
|
key
|
|
}) => {
|
|
const ns = useNamespace("tree-select");
|
|
watch(() => props2.data, () => {
|
|
if (props2.filterable) {
|
|
nextTick(() => {
|
|
var _a2, _b;
|
|
(_b = tree.value) == null ? void 0 : _b.filter((_a2 = select.value) == null ? void 0 : _a2.states.inputValue);
|
|
});
|
|
}
|
|
}, { flush: "post" });
|
|
const result2 = {
|
|
...pick_default(toRefs(props2), Object.keys(ElSelect.props)),
|
|
...attrs,
|
|
class: computed(() => attrs.class),
|
|
style: computed(() => attrs.style),
|
|
"onUpdate:modelValue": (value) => emit(UPDATE_MODEL_EVENT, value),
|
|
valueKey: key,
|
|
popperClass: computed(() => {
|
|
const classes = [ns.e("popper")];
|
|
if (props2.popperClass)
|
|
classes.push(props2.popperClass);
|
|
return classes.join(" ");
|
|
}),
|
|
filterMethod: (keyword = "") => {
|
|
var _a2;
|
|
if (props2.filterMethod) {
|
|
props2.filterMethod(keyword);
|
|
} else if (props2.remoteMethod) {
|
|
props2.remoteMethod(keyword);
|
|
} else {
|
|
(_a2 = tree.value) == null ? void 0 : _a2.filter(keyword);
|
|
}
|
|
}
|
|
};
|
|
return result2;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/tree-select/src/tree-select-option.mjs
|
|
var component = defineComponent({
|
|
extends: ElOption,
|
|
setup(props2, ctx) {
|
|
const result2 = ElOption.setup(props2, ctx);
|
|
delete result2.selectOptionClick;
|
|
const vm = getCurrentInstance().proxy;
|
|
nextTick(() => {
|
|
if (!result2.select.states.cachedOptions.get(vm.value)) {
|
|
result2.select.onOptionCreate(vm);
|
|
}
|
|
});
|
|
watch(() => ctx.attrs.visible, (val) => {
|
|
nextTick(() => {
|
|
result2.states.visible = val;
|
|
});
|
|
}, {
|
|
immediate: true
|
|
});
|
|
return result2;
|
|
},
|
|
methods: {
|
|
selectOptionClick() {
|
|
this.$el.parentElement.click();
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tree-select/src/utils.mjs
|
|
function isValidValue2(val) {
|
|
return val || val === 0;
|
|
}
|
|
function isValidArray(val) {
|
|
return isArray(val) && val.length;
|
|
}
|
|
function toValidArray(val) {
|
|
return isArray(val) ? val : isValidValue2(val) ? [val] : [];
|
|
}
|
|
function treeFind(treeData, findCallback, getChildren, resultCallback, parent2) {
|
|
for (let i = 0; i < treeData.length; i++) {
|
|
const data = treeData[i];
|
|
if (findCallback(data, i, treeData, parent2)) {
|
|
return resultCallback ? resultCallback(data, i, treeData, parent2) : data;
|
|
} else {
|
|
const children = getChildren(data);
|
|
if (isValidArray(children)) {
|
|
const find2 = treeFind(children, findCallback, getChildren, resultCallback, data);
|
|
if (find2)
|
|
return find2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function treeEach(treeData, callback, getChildren, parent2) {
|
|
for (let i = 0; i < treeData.length; i++) {
|
|
const data = treeData[i];
|
|
callback(data, i, treeData, parent2);
|
|
const children = getChildren(data);
|
|
if (isValidArray(children)) {
|
|
treeEach(children, callback, getChildren, data);
|
|
}
|
|
}
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/tree-select/src/tree.mjs
|
|
var useTree2 = (props2, { attrs, slots, emit }, {
|
|
select,
|
|
tree,
|
|
key
|
|
}) => {
|
|
watch(() => props2.modelValue, () => {
|
|
if (props2.showCheckbox) {
|
|
nextTick(() => {
|
|
const treeInstance = tree.value;
|
|
if (treeInstance && !isEqual_default(treeInstance.getCheckedKeys(), toValidArray(props2.modelValue))) {
|
|
treeInstance.setCheckedKeys(toValidArray(props2.modelValue));
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
immediate: true,
|
|
deep: true
|
|
});
|
|
const propsMap = computed(() => ({
|
|
value: key.value,
|
|
label: "label",
|
|
children: "children",
|
|
disabled: "disabled",
|
|
isLeaf: "isLeaf",
|
|
...props2.props
|
|
}));
|
|
const getNodeValByProp = (prop, data) => {
|
|
var _a2;
|
|
const propVal = propsMap.value[prop];
|
|
if (isFunction(propVal)) {
|
|
return propVal(data, (_a2 = tree.value) == null ? void 0 : _a2.getNode(getNodeValByProp("value", data)));
|
|
} else {
|
|
return data[propVal];
|
|
}
|
|
};
|
|
const defaultExpandedParentKeys = toValidArray(props2.modelValue).map((value) => {
|
|
return treeFind(props2.data || [], (data) => getNodeValByProp("value", data) === value, (data) => getNodeValByProp("children", data), (data, index, array4, parent2) => parent2 && getNodeValByProp("value", parent2));
|
|
}).filter((item) => isValidValue2(item));
|
|
const cacheOptions = computed(() => {
|
|
if (!props2.renderAfterExpand && !props2.lazy)
|
|
return [];
|
|
const options = [];
|
|
treeEach(props2.data.concat(props2.cacheData), (node) => {
|
|
const value = getNodeValByProp("value", node);
|
|
options.push({
|
|
value,
|
|
currentLabel: getNodeValByProp("label", node),
|
|
isDisabled: getNodeValByProp("disabled", node)
|
|
});
|
|
}, (data) => getNodeValByProp("children", data));
|
|
return options;
|
|
});
|
|
const getChildCheckedKeys = () => {
|
|
var _a2;
|
|
return (_a2 = tree.value) == null ? void 0 : _a2.getCheckedKeys().filter((checkedKey) => {
|
|
var _a22;
|
|
const node = (_a22 = tree.value) == null ? void 0 : _a22.getNode(checkedKey);
|
|
return !isNil_default(node) && isEmpty2(node.childNodes);
|
|
});
|
|
};
|
|
return {
|
|
...pick_default(toRefs(props2), Object.keys(ElTree.props)),
|
|
...attrs,
|
|
nodeKey: key,
|
|
expandOnClickNode: computed(() => {
|
|
return !props2.checkStrictly && props2.expandOnClickNode;
|
|
}),
|
|
defaultExpandedKeys: computed(() => {
|
|
return props2.defaultExpandedKeys ? props2.defaultExpandedKeys.concat(defaultExpandedParentKeys) : defaultExpandedParentKeys;
|
|
}),
|
|
renderContent: (h3, { node, data, store }) => {
|
|
return h3(component, {
|
|
value: getNodeValByProp("value", data),
|
|
label: getNodeValByProp("label", data),
|
|
disabled: getNodeValByProp("disabled", data),
|
|
visible: node.visible
|
|
}, props2.renderContent ? () => props2.renderContent(h3, { node, data, store }) : slots.default ? () => slots.default({ node, data, store }) : void 0);
|
|
},
|
|
filterNodeMethod: (value, data, node) => {
|
|
if (props2.filterNodeMethod)
|
|
return props2.filterNodeMethod(value, data, node);
|
|
if (!value)
|
|
return true;
|
|
const regexp4 = new RegExp(escapeStringRegexp(value), "i");
|
|
return regexp4.test(getNodeValByProp("label", data) || "");
|
|
},
|
|
onNodeClick: (data, node, e) => {
|
|
var _a2, _b, _c, _d;
|
|
(_a2 = attrs.onNodeClick) == null ? void 0 : _a2.call(attrs, data, node, e);
|
|
if (props2.showCheckbox && props2.checkOnClickNode)
|
|
return;
|
|
if (!props2.showCheckbox && (props2.checkStrictly || node.isLeaf)) {
|
|
if (!getNodeValByProp("disabled", data)) {
|
|
const option = (_b = select.value) == null ? void 0 : _b.states.options.get(getNodeValByProp("value", data));
|
|
(_c = select.value) == null ? void 0 : _c.handleOptionSelect(option);
|
|
}
|
|
} else if (props2.expandOnClickNode) {
|
|
e.proxy.handleExpandIconClick();
|
|
}
|
|
(_d = select.value) == null ? void 0 : _d.focus();
|
|
},
|
|
onCheck: (data, params) => {
|
|
var _a2;
|
|
if (!props2.showCheckbox)
|
|
return;
|
|
const dataValue = getNodeValByProp("value", data);
|
|
const dataMap = {};
|
|
treeEach([tree.value.store.root], (node) => dataMap[node.key] = node, (node) => node.childNodes);
|
|
const uncachedCheckedKeys = params.checkedKeys;
|
|
const cachedKeys = props2.multiple ? toValidArray(props2.modelValue).filter((item) => !(item in dataMap) && !uncachedCheckedKeys.includes(item)) : [];
|
|
const checkedKeys = cachedKeys.concat(uncachedCheckedKeys);
|
|
if (props2.checkStrictly) {
|
|
emit(UPDATE_MODEL_EVENT, props2.multiple ? checkedKeys : checkedKeys.includes(dataValue) ? dataValue : void 0);
|
|
} else {
|
|
if (props2.multiple) {
|
|
const childKeys = getChildCheckedKeys();
|
|
emit(UPDATE_MODEL_EVENT, cachedKeys.concat(childKeys));
|
|
} else {
|
|
const firstLeaf = treeFind([data], (data2) => !isValidArray(getNodeValByProp("children", data2)) && !getNodeValByProp("disabled", data2), (data2) => getNodeValByProp("children", data2));
|
|
const firstLeafKey = firstLeaf ? getNodeValByProp("value", firstLeaf) : void 0;
|
|
const hasCheckedChild = isValidValue2(props2.modelValue) && !!treeFind([data], (data2) => getNodeValByProp("value", data2) === props2.modelValue, (data2) => getNodeValByProp("children", data2));
|
|
emit(UPDATE_MODEL_EVENT, firstLeafKey === props2.modelValue || hasCheckedChild ? void 0 : firstLeafKey);
|
|
}
|
|
}
|
|
nextTick(() => {
|
|
var _a22;
|
|
const checkedKeys2 = toValidArray(props2.modelValue);
|
|
tree.value.setCheckedKeys(checkedKeys2);
|
|
(_a22 = attrs.onCheck) == null ? void 0 : _a22.call(attrs, data, {
|
|
checkedKeys: tree.value.getCheckedKeys(),
|
|
checkedNodes: tree.value.getCheckedNodes(),
|
|
halfCheckedKeys: tree.value.getHalfCheckedKeys(),
|
|
halfCheckedNodes: tree.value.getHalfCheckedNodes()
|
|
});
|
|
});
|
|
(_a2 = select.value) == null ? void 0 : _a2.focus();
|
|
},
|
|
onNodeExpand: (data, node, e) => {
|
|
var _a2;
|
|
(_a2 = attrs.onNodeExpand) == null ? void 0 : _a2.call(attrs, data, node, e);
|
|
nextTick(() => {
|
|
if (!props2.checkStrictly && props2.lazy && props2.multiple && node.checked) {
|
|
const dataMap = {};
|
|
const uncachedCheckedKeys = tree.value.getCheckedKeys();
|
|
treeEach([tree.value.store.root], (node2) => dataMap[node2.key] = node2, (node2) => node2.childNodes);
|
|
const cachedKeys = toValidArray(props2.modelValue).filter((item) => !(item in dataMap) && !uncachedCheckedKeys.includes(item));
|
|
const childKeys = getChildCheckedKeys();
|
|
emit(UPDATE_MODEL_EVENT, cachedKeys.concat(childKeys));
|
|
}
|
|
});
|
|
},
|
|
cacheOptions
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/tree-select/src/cache-options.mjs
|
|
var CacheOptions = defineComponent({
|
|
props: {
|
|
data: {
|
|
type: Array,
|
|
default: () => []
|
|
}
|
|
},
|
|
setup(props2) {
|
|
const select = inject(selectKey);
|
|
watch(() => props2.data, () => {
|
|
var _a2;
|
|
props2.data.forEach((item) => {
|
|
if (!select.states.cachedOptions.has(item.value)) {
|
|
select.states.cachedOptions.set(item.value, item);
|
|
}
|
|
});
|
|
const inputs = ((_a2 = select.selectRef) == null ? void 0 : _a2.querySelectorAll("input")) || [];
|
|
if (isClient && !Array.from(inputs).includes(document.activeElement)) {
|
|
select.setSelected();
|
|
}
|
|
}, { flush: "post", immediate: true });
|
|
return () => void 0;
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tree-select/src/tree-select.mjs
|
|
var _sfc_main137 = defineComponent({
|
|
name: "ElTreeSelect",
|
|
inheritAttrs: false,
|
|
props: {
|
|
...ElSelect.props,
|
|
...ElTree.props,
|
|
cacheData: {
|
|
type: Array,
|
|
default: () => []
|
|
}
|
|
},
|
|
setup(props2, context) {
|
|
const { slots, expose } = context;
|
|
const select = ref();
|
|
const tree = ref();
|
|
const key = computed(() => props2.nodeKey || props2.valueKey || "value");
|
|
const selectProps = useSelect3(props2, context, { select, tree, key });
|
|
const { cacheOptions, ...treeProps2 } = useTree2(props2, context, {
|
|
select,
|
|
tree,
|
|
key
|
|
});
|
|
const methods = reactive({});
|
|
expose(methods);
|
|
onMounted(() => {
|
|
Object.assign(methods, {
|
|
...pick_default(tree.value, [
|
|
"filter",
|
|
"updateKeyChildren",
|
|
"getCheckedNodes",
|
|
"setCheckedNodes",
|
|
"getCheckedKeys",
|
|
"setCheckedKeys",
|
|
"setChecked",
|
|
"getHalfCheckedNodes",
|
|
"getHalfCheckedKeys",
|
|
"getCurrentKey",
|
|
"getCurrentNode",
|
|
"setCurrentKey",
|
|
"setCurrentNode",
|
|
"getNode",
|
|
"remove",
|
|
"append",
|
|
"insertBefore",
|
|
"insertAfter"
|
|
]),
|
|
...pick_default(select.value, ["focus", "blur", "selectedLabel"])
|
|
});
|
|
});
|
|
return () => h(ElSelect, reactive({
|
|
...selectProps,
|
|
ref: (ref2) => select.value = ref2
|
|
}), {
|
|
...slots,
|
|
default: () => [
|
|
h(CacheOptions, { data: cacheOptions.value }),
|
|
h(ElTree, reactive({
|
|
...treeProps2,
|
|
ref: (ref2) => tree.value = ref2
|
|
}))
|
|
]
|
|
});
|
|
}
|
|
});
|
|
var TreeSelect = _export_sfc(_sfc_main137, [["__file", "tree-select.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tree-select/index.mjs
|
|
var ElTreeSelect = withInstall(TreeSelect);
|
|
|
|
// node_modules/element-plus/es/components/tree-v2/src/virtual-tree.mjs
|
|
var ROOT_TREE_INJECTION_KEY = Symbol();
|
|
var EMPTY_NODE = {
|
|
key: -1,
|
|
level: -1,
|
|
data: {}
|
|
};
|
|
var TreeOptionsEnum = ((TreeOptionsEnum2) => {
|
|
TreeOptionsEnum2["KEY"] = "id";
|
|
TreeOptionsEnum2["LABEL"] = "label";
|
|
TreeOptionsEnum2["CHILDREN"] = "children";
|
|
TreeOptionsEnum2["DISABLED"] = "disabled";
|
|
TreeOptionsEnum2["CLASS"] = "";
|
|
return TreeOptionsEnum2;
|
|
})(TreeOptionsEnum || {});
|
|
var SetOperationEnum = ((SetOperationEnum2) => {
|
|
SetOperationEnum2["ADD"] = "add";
|
|
SetOperationEnum2["DELETE"] = "delete";
|
|
return SetOperationEnum2;
|
|
})(SetOperationEnum || {});
|
|
var itemSize2 = {
|
|
type: Number,
|
|
default: 26
|
|
};
|
|
var treeProps = buildProps({
|
|
data: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([])
|
|
},
|
|
emptyText: {
|
|
type: String
|
|
},
|
|
height: {
|
|
type: Number,
|
|
default: 200
|
|
},
|
|
props: {
|
|
type: definePropType(Object),
|
|
default: () => mutable({
|
|
children: "children",
|
|
label: "label",
|
|
disabled: "disabled",
|
|
value: "id",
|
|
class: ""
|
|
})
|
|
},
|
|
highlightCurrent: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
showCheckbox: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
defaultCheckedKeys: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([])
|
|
},
|
|
checkStrictly: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
defaultExpandedKeys: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([])
|
|
},
|
|
indent: {
|
|
type: Number,
|
|
default: 16
|
|
},
|
|
itemSize: itemSize2,
|
|
icon: {
|
|
type: iconPropType
|
|
},
|
|
expandOnClickNode: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
checkOnClickNode: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
checkOnClickLeaf: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
currentNodeKey: {
|
|
type: definePropType([String, Number])
|
|
},
|
|
accordion: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
filterMethod: {
|
|
type: definePropType(Function)
|
|
},
|
|
perfMode: {
|
|
type: Boolean,
|
|
default: true
|
|
}
|
|
});
|
|
var treeNodeProps = buildProps({
|
|
node: {
|
|
type: definePropType(Object),
|
|
default: () => mutable(EMPTY_NODE)
|
|
},
|
|
expanded: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
checked: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
indeterminate: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
showCheckbox: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
disabled: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
current: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
hiddenExpandIcon: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
itemSize: itemSize2
|
|
});
|
|
var treeNodeContentProps = buildProps({
|
|
node: {
|
|
type: definePropType(Object),
|
|
required: true
|
|
}
|
|
});
|
|
var NODE_CLICK = "node-click";
|
|
var NODE_DROP = "node-drop";
|
|
var NODE_EXPAND = "node-expand";
|
|
var NODE_COLLAPSE = "node-collapse";
|
|
var CURRENT_CHANGE = "current-change";
|
|
var NODE_CHECK = "check";
|
|
var NODE_CHECK_CHANGE = "check-change";
|
|
var NODE_CONTEXTMENU = "node-contextmenu";
|
|
var treeEmits = {
|
|
[NODE_CLICK]: (data, node, e) => data && node && e,
|
|
[NODE_DROP]: (data, node, e) => data && node && e,
|
|
[NODE_EXPAND]: (data, node) => data && node,
|
|
[NODE_COLLAPSE]: (data, node) => data && node,
|
|
[CURRENT_CHANGE]: (data, node) => data && node,
|
|
[NODE_CHECK]: (data, checkedInfo) => data && checkedInfo,
|
|
[NODE_CHECK_CHANGE]: (data, checked) => data && isBoolean2(checked),
|
|
[NODE_CONTEXTMENU]: (evt, data, node) => evt && data && node
|
|
};
|
|
var treeNodeEmits = {
|
|
click: (node, e) => !!(node && e),
|
|
drop: (node, e) => !!(node && e),
|
|
toggle: (node) => !!node,
|
|
check: (node, checked) => node && isBoolean2(checked)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/tree-v2/src/composables/useCheck.mjs
|
|
function useCheck2(props2, tree) {
|
|
const checkedKeys = ref(new Set());
|
|
const indeterminateKeys = ref(new Set());
|
|
const { emit } = getCurrentInstance();
|
|
watch([() => tree.value, () => props2.defaultCheckedKeys], () => {
|
|
return nextTick(() => {
|
|
_setCheckedKeys(props2.defaultCheckedKeys);
|
|
});
|
|
}, {
|
|
immediate: true
|
|
});
|
|
const updateCheckedKeys = () => {
|
|
if (!tree.value || !props2.showCheckbox || props2.checkStrictly) {
|
|
return;
|
|
}
|
|
const { levelTreeNodeMap, maxLevel } = tree.value;
|
|
const checkedKeySet = checkedKeys.value;
|
|
const indeterminateKeySet = new Set();
|
|
for (let level = maxLevel - 1; level >= 1; --level) {
|
|
const nodes = levelTreeNodeMap.get(level);
|
|
if (!nodes)
|
|
continue;
|
|
nodes.forEach((node) => {
|
|
const children = node.children;
|
|
if (children) {
|
|
let allChecked = true;
|
|
let hasChecked = false;
|
|
for (const childNode of children) {
|
|
const key = childNode.key;
|
|
if (checkedKeySet.has(key)) {
|
|
hasChecked = true;
|
|
} else if (indeterminateKeySet.has(key)) {
|
|
allChecked = false;
|
|
hasChecked = true;
|
|
break;
|
|
} else {
|
|
allChecked = false;
|
|
}
|
|
}
|
|
if (allChecked) {
|
|
checkedKeySet.add(node.key);
|
|
} else if (hasChecked) {
|
|
indeterminateKeySet.add(node.key);
|
|
checkedKeySet.delete(node.key);
|
|
} else {
|
|
checkedKeySet.delete(node.key);
|
|
indeterminateKeySet.delete(node.key);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
indeterminateKeys.value = indeterminateKeySet;
|
|
};
|
|
const isChecked = (node) => checkedKeys.value.has(node.key);
|
|
const isIndeterminate = (node) => indeterminateKeys.value.has(node.key);
|
|
const toggleCheckbox = (node, isChecked2, nodeClick = true, immediateUpdate = true) => {
|
|
const checkedKeySet = checkedKeys.value;
|
|
const toggle = (node2, checked) => {
|
|
checkedKeySet[checked ? SetOperationEnum.ADD : SetOperationEnum.DELETE](node2.key);
|
|
const children = node2.children;
|
|
if (!props2.checkStrictly && children) {
|
|
children.forEach((childNode) => {
|
|
if (!childNode.disabled) {
|
|
toggle(childNode, checked);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
toggle(node, isChecked2);
|
|
if (immediateUpdate) {
|
|
updateCheckedKeys();
|
|
}
|
|
if (nodeClick) {
|
|
afterNodeCheck(node, isChecked2);
|
|
}
|
|
};
|
|
const afterNodeCheck = (node, checked) => {
|
|
const { checkedNodes, checkedKeys: checkedKeys2 } = getChecked();
|
|
const { halfCheckedNodes, halfCheckedKeys } = getHalfChecked();
|
|
emit(NODE_CHECK, node.data, {
|
|
checkedKeys: checkedKeys2,
|
|
checkedNodes,
|
|
halfCheckedKeys,
|
|
halfCheckedNodes
|
|
});
|
|
emit(NODE_CHECK_CHANGE, node.data, checked);
|
|
};
|
|
function getCheckedKeys(leafOnly = false) {
|
|
return getChecked(leafOnly).checkedKeys;
|
|
}
|
|
function getCheckedNodes(leafOnly = false) {
|
|
return getChecked(leafOnly).checkedNodes;
|
|
}
|
|
function getHalfCheckedKeys() {
|
|
return getHalfChecked().halfCheckedKeys;
|
|
}
|
|
function getHalfCheckedNodes() {
|
|
return getHalfChecked().halfCheckedNodes;
|
|
}
|
|
function getChecked(leafOnly = false) {
|
|
const checkedNodes = [];
|
|
const keys3 = [];
|
|
if ((tree == null ? void 0 : tree.value) && props2.showCheckbox) {
|
|
const { treeNodeMap } = tree.value;
|
|
checkedKeys.value.forEach((key) => {
|
|
const node = treeNodeMap.get(key);
|
|
if (node && (!leafOnly || leafOnly && node.isLeaf)) {
|
|
keys3.push(key);
|
|
checkedNodes.push(node.data);
|
|
}
|
|
});
|
|
}
|
|
return {
|
|
checkedKeys: keys3,
|
|
checkedNodes
|
|
};
|
|
}
|
|
function getHalfChecked() {
|
|
const halfCheckedNodes = [];
|
|
const halfCheckedKeys = [];
|
|
if ((tree == null ? void 0 : tree.value) && props2.showCheckbox) {
|
|
const { treeNodeMap } = tree.value;
|
|
indeterminateKeys.value.forEach((key) => {
|
|
const node = treeNodeMap.get(key);
|
|
if (node) {
|
|
halfCheckedKeys.push(key);
|
|
halfCheckedNodes.push(node.data);
|
|
}
|
|
});
|
|
}
|
|
return {
|
|
halfCheckedNodes,
|
|
halfCheckedKeys
|
|
};
|
|
}
|
|
function setCheckedKeys(keys3) {
|
|
checkedKeys.value.clear();
|
|
indeterminateKeys.value.clear();
|
|
nextTick(() => {
|
|
_setCheckedKeys(keys3);
|
|
});
|
|
}
|
|
function setChecked(key, isChecked2) {
|
|
if ((tree == null ? void 0 : tree.value) && props2.showCheckbox) {
|
|
const node = tree.value.treeNodeMap.get(key);
|
|
if (node) {
|
|
toggleCheckbox(node, isChecked2, false);
|
|
}
|
|
}
|
|
}
|
|
function _setCheckedKeys(keys3) {
|
|
if (tree == null ? void 0 : tree.value) {
|
|
const { treeNodeMap } = tree.value;
|
|
if (props2.showCheckbox && treeNodeMap && (keys3 == null ? void 0 : keys3.length) > 0) {
|
|
for (const key of keys3) {
|
|
const node = treeNodeMap.get(key);
|
|
if (node && !isChecked(node)) {
|
|
toggleCheckbox(node, true, false, false);
|
|
}
|
|
}
|
|
updateCheckedKeys();
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
updateCheckedKeys,
|
|
toggleCheckbox,
|
|
isChecked,
|
|
isIndeterminate,
|
|
getCheckedKeys,
|
|
getCheckedNodes,
|
|
getHalfCheckedKeys,
|
|
getHalfCheckedNodes,
|
|
setChecked,
|
|
setCheckedKeys
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/tree-v2/src/composables/useFilter.mjs
|
|
function useFilter(props2, tree) {
|
|
const hiddenNodeKeySet = ref(new Set([]));
|
|
const hiddenExpandIconKeySet = ref(new Set([]));
|
|
const filterable = computed(() => {
|
|
return isFunction(props2.filterMethod);
|
|
});
|
|
function doFilter(query) {
|
|
var _a2;
|
|
if (!filterable.value) {
|
|
return;
|
|
}
|
|
const expandKeySet = new Set();
|
|
const hiddenExpandIconKeys = hiddenExpandIconKeySet.value;
|
|
const hiddenKeys = hiddenNodeKeySet.value;
|
|
const family = [];
|
|
const nodes = ((_a2 = tree.value) == null ? void 0 : _a2.treeNodes) || [];
|
|
const filter2 = props2.filterMethod;
|
|
hiddenKeys.clear();
|
|
function traverse(nodes2) {
|
|
nodes2.forEach((node) => {
|
|
family.push(node);
|
|
if (filter2 == null ? void 0 : filter2(query, node.data, node)) {
|
|
family.forEach((member) => {
|
|
expandKeySet.add(member.key);
|
|
});
|
|
} else if (node.isLeaf) {
|
|
hiddenKeys.add(node.key);
|
|
}
|
|
const children = node.children;
|
|
if (children) {
|
|
traverse(children);
|
|
}
|
|
if (!node.isLeaf) {
|
|
if (!expandKeySet.has(node.key)) {
|
|
hiddenKeys.add(node.key);
|
|
} else if (children) {
|
|
let allHidden = true;
|
|
for (const childNode of children) {
|
|
if (!hiddenKeys.has(childNode.key)) {
|
|
allHidden = false;
|
|
break;
|
|
}
|
|
}
|
|
if (allHidden) {
|
|
hiddenExpandIconKeys.add(node.key);
|
|
} else {
|
|
hiddenExpandIconKeys.delete(node.key);
|
|
}
|
|
}
|
|
}
|
|
family.pop();
|
|
});
|
|
}
|
|
traverse(nodes);
|
|
return expandKeySet;
|
|
}
|
|
function isForceHiddenExpandIcon(node) {
|
|
return hiddenExpandIconKeySet.value.has(node.key);
|
|
}
|
|
return {
|
|
hiddenExpandIconKeySet,
|
|
hiddenNodeKeySet,
|
|
doFilter,
|
|
isForceHiddenExpandIcon
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/tree-v2/src/composables/useTree.mjs
|
|
function useTree3(props2, emit) {
|
|
const expandedKeySet = ref(new Set(props2.defaultExpandedKeys));
|
|
const currentKey = ref();
|
|
const tree = shallowRef();
|
|
const listRef = ref();
|
|
const {
|
|
isIndeterminate,
|
|
isChecked,
|
|
toggleCheckbox,
|
|
getCheckedKeys,
|
|
getCheckedNodes,
|
|
getHalfCheckedKeys,
|
|
getHalfCheckedNodes,
|
|
setChecked,
|
|
setCheckedKeys
|
|
} = useCheck2(props2, tree);
|
|
const { doFilter, hiddenNodeKeySet, isForceHiddenExpandIcon } = useFilter(props2, tree);
|
|
const valueKey = computed(() => {
|
|
var _a2;
|
|
return ((_a2 = props2.props) == null ? void 0 : _a2.value) || TreeOptionsEnum.KEY;
|
|
});
|
|
const childrenKey = computed(() => {
|
|
var _a2;
|
|
return ((_a2 = props2.props) == null ? void 0 : _a2.children) || TreeOptionsEnum.CHILDREN;
|
|
});
|
|
const disabledKey = computed(() => {
|
|
var _a2;
|
|
return ((_a2 = props2.props) == null ? void 0 : _a2.disabled) || TreeOptionsEnum.DISABLED;
|
|
});
|
|
const labelKey = computed(() => {
|
|
var _a2;
|
|
return ((_a2 = props2.props) == null ? void 0 : _a2.label) || TreeOptionsEnum.LABEL;
|
|
});
|
|
const flattenTree = computed(() => {
|
|
var _a2;
|
|
const expandedKeys = expandedKeySet.value;
|
|
const hiddenKeys = hiddenNodeKeySet.value;
|
|
const flattenNodes = [];
|
|
const nodes = ((_a2 = tree.value) == null ? void 0 : _a2.treeNodes) || [];
|
|
const stack = [];
|
|
for (let i = nodes.length - 1; i >= 0; --i) {
|
|
stack.push(nodes[i]);
|
|
}
|
|
while (stack.length) {
|
|
const node = stack.pop();
|
|
if (hiddenKeys.has(node.key))
|
|
continue;
|
|
flattenNodes.push(node);
|
|
if (node.children && expandedKeys.has(node.key)) {
|
|
for (let i = node.children.length - 1; i >= 0; --i) {
|
|
stack.push(node.children[i]);
|
|
}
|
|
}
|
|
}
|
|
return flattenNodes;
|
|
});
|
|
const isNotEmpty = computed(() => {
|
|
return flattenTree.value.length > 0;
|
|
});
|
|
function createTree(data) {
|
|
const treeNodeMap = new Map();
|
|
const levelTreeNodeMap = new Map();
|
|
let maxLevel = 1;
|
|
function traverse(nodes, level = 1, parent2 = void 0) {
|
|
var _a2;
|
|
const siblings = [];
|
|
for (const rawNode of nodes) {
|
|
const value = getKey(rawNode);
|
|
const node = {
|
|
level,
|
|
key: value,
|
|
data: rawNode
|
|
};
|
|
node.label = getLabel(rawNode);
|
|
node.parent = parent2;
|
|
const children = getChildren(rawNode);
|
|
node.disabled = getDisabled(rawNode);
|
|
node.isLeaf = !children || children.length === 0;
|
|
if (children && children.length) {
|
|
node.children = traverse(children, level + 1, node);
|
|
}
|
|
siblings.push(node);
|
|
treeNodeMap.set(value, node);
|
|
if (!levelTreeNodeMap.has(level)) {
|
|
levelTreeNodeMap.set(level, []);
|
|
}
|
|
(_a2 = levelTreeNodeMap.get(level)) == null ? void 0 : _a2.push(node);
|
|
}
|
|
if (level > maxLevel) {
|
|
maxLevel = level;
|
|
}
|
|
return siblings;
|
|
}
|
|
const treeNodes = traverse(data);
|
|
return {
|
|
treeNodeMap,
|
|
levelTreeNodeMap,
|
|
maxLevel,
|
|
treeNodes
|
|
};
|
|
}
|
|
function filter2(query) {
|
|
const keys3 = doFilter(query);
|
|
if (keys3) {
|
|
expandedKeySet.value = keys3;
|
|
}
|
|
}
|
|
function getChildren(node) {
|
|
return node[childrenKey.value];
|
|
}
|
|
function getKey(node) {
|
|
if (!node) {
|
|
return "";
|
|
}
|
|
return node[valueKey.value];
|
|
}
|
|
function getDisabled(node) {
|
|
return node[disabledKey.value];
|
|
}
|
|
function getLabel(node) {
|
|
return node[labelKey.value];
|
|
}
|
|
function toggleExpand(node) {
|
|
const expandedKeys = expandedKeySet.value;
|
|
if (expandedKeys.has(node.key)) {
|
|
collapseNode(node);
|
|
} else {
|
|
expandNode(node);
|
|
}
|
|
}
|
|
function setExpandedKeys(keys3) {
|
|
const expandedKeys = new Set();
|
|
const nodeMap = tree.value.treeNodeMap;
|
|
keys3.forEach((k) => {
|
|
let node = nodeMap.get(k);
|
|
while (node && !expandedKeys.has(node.key)) {
|
|
expandedKeys.add(node.key);
|
|
node = node.parent;
|
|
}
|
|
});
|
|
expandedKeySet.value = expandedKeys;
|
|
}
|
|
function handleNodeClick(node, e) {
|
|
emit(NODE_CLICK, node.data, node, e);
|
|
handleCurrentChange2(node);
|
|
if (props2.expandOnClickNode) {
|
|
toggleExpand(node);
|
|
}
|
|
if (props2.showCheckbox && (props2.checkOnClickNode || node.isLeaf && props2.checkOnClickLeaf) && !node.disabled) {
|
|
toggleCheckbox(node, !isChecked(node), true);
|
|
}
|
|
}
|
|
function handleNodeDrop(node, e) {
|
|
emit(NODE_DROP, node.data, node, e);
|
|
}
|
|
function handleCurrentChange2(node) {
|
|
if (!isCurrent(node)) {
|
|
currentKey.value = node.key;
|
|
emit(CURRENT_CHANGE, node.data, node);
|
|
}
|
|
}
|
|
function handleNodeCheck(node, checked) {
|
|
toggleCheckbox(node, checked);
|
|
}
|
|
function expandNode(node) {
|
|
const keySet = expandedKeySet.value;
|
|
if (tree.value && props2.accordion) {
|
|
const { treeNodeMap } = tree.value;
|
|
keySet.forEach((key) => {
|
|
const treeNode = treeNodeMap.get(key);
|
|
if (node && node.level === (treeNode == null ? void 0 : treeNode.level)) {
|
|
keySet.delete(key);
|
|
}
|
|
});
|
|
}
|
|
keySet.add(node.key);
|
|
emit(NODE_EXPAND, node.data, node);
|
|
}
|
|
function collapseNode(node) {
|
|
expandedKeySet.value.delete(node.key);
|
|
emit(NODE_COLLAPSE, node.data, node);
|
|
}
|
|
function isExpanded(node) {
|
|
return expandedKeySet.value.has(node.key);
|
|
}
|
|
function isDisabled(node) {
|
|
return !!node.disabled;
|
|
}
|
|
function isCurrent(node) {
|
|
const current = currentKey.value;
|
|
return current !== void 0 && current === node.key;
|
|
}
|
|
function getCurrentNode() {
|
|
var _a2, _b;
|
|
if (!currentKey.value)
|
|
return void 0;
|
|
return (_b = (_a2 = tree.value) == null ? void 0 : _a2.treeNodeMap.get(currentKey.value)) == null ? void 0 : _b.data;
|
|
}
|
|
function getCurrentKey() {
|
|
return currentKey.value;
|
|
}
|
|
function setCurrentKey(key) {
|
|
currentKey.value = key;
|
|
}
|
|
function setData2(data) {
|
|
tree.value = createTree(data);
|
|
}
|
|
function getNode(data) {
|
|
var _a2;
|
|
const key = isObject(data) ? getKey(data) : data;
|
|
return (_a2 = tree.value) == null ? void 0 : _a2.treeNodeMap.get(key);
|
|
}
|
|
function scrollToNode(key, strategy = "auto") {
|
|
const node = getNode(key);
|
|
if (node && listRef.value) {
|
|
listRef.value.scrollToItem(flattenTree.value.indexOf(node), strategy);
|
|
}
|
|
}
|
|
function scrollTo(offset3) {
|
|
var _a2;
|
|
(_a2 = listRef.value) == null ? void 0 : _a2.scrollTo(offset3);
|
|
}
|
|
watch(() => props2.currentNodeKey, (key) => {
|
|
currentKey.value = key;
|
|
}, {
|
|
immediate: true
|
|
});
|
|
watch(() => props2.data, (data) => {
|
|
setData2(data);
|
|
}, {
|
|
immediate: true
|
|
});
|
|
return {
|
|
tree,
|
|
flattenTree,
|
|
isNotEmpty,
|
|
listRef,
|
|
getKey,
|
|
getChildren,
|
|
toggleExpand,
|
|
toggleCheckbox,
|
|
isExpanded,
|
|
isChecked,
|
|
isIndeterminate,
|
|
isDisabled,
|
|
isCurrent,
|
|
isForceHiddenExpandIcon,
|
|
handleNodeClick,
|
|
handleNodeDrop,
|
|
handleNodeCheck,
|
|
getCurrentNode,
|
|
getCurrentKey,
|
|
setCurrentKey,
|
|
getCheckedKeys,
|
|
getCheckedNodes,
|
|
getHalfCheckedKeys,
|
|
getHalfCheckedNodes,
|
|
setChecked,
|
|
setCheckedKeys,
|
|
filter: filter2,
|
|
setData: setData2,
|
|
getNode,
|
|
expandNode,
|
|
collapseNode,
|
|
setExpandedKeys,
|
|
scrollToNode,
|
|
scrollTo
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/tree-v2/src/tree-node-content.mjs
|
|
var ElNodeContent = defineComponent({
|
|
name: "ElTreeNodeContent",
|
|
props: treeNodeContentProps,
|
|
setup(props2) {
|
|
const tree = inject(ROOT_TREE_INJECTION_KEY);
|
|
const ns = useNamespace("tree");
|
|
return () => {
|
|
const node = props2.node;
|
|
const { data } = node;
|
|
return (tree == null ? void 0 : tree.ctx.slots.default) ? tree.ctx.slots.default({ node, data }) : h(ElText, { tag: "span", truncated: true, class: ns.be("node", "label") }, () => [node == null ? void 0 : node.label]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tree-v2/src/tree-node.mjs
|
|
var __default__98 = defineComponent({
|
|
name: "ElTreeNode"
|
|
});
|
|
var _sfc_main138 = defineComponent({
|
|
...__default__98,
|
|
props: treeNodeProps,
|
|
emits: treeNodeEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const tree = inject(ROOT_TREE_INJECTION_KEY);
|
|
const ns = useNamespace("tree");
|
|
const indent = computed(() => {
|
|
var _a2;
|
|
return (_a2 = tree == null ? void 0 : tree.props.indent) != null ? _a2 : 16;
|
|
});
|
|
const icon = computed(() => {
|
|
var _a2;
|
|
return (_a2 = tree == null ? void 0 : tree.props.icon) != null ? _a2 : caret_right_default;
|
|
});
|
|
const getNodeClass = (node) => {
|
|
const nodeClassFunc = tree == null ? void 0 : tree.props.props.class;
|
|
if (!nodeClassFunc)
|
|
return {};
|
|
let className;
|
|
if (isFunction(nodeClassFunc)) {
|
|
const { data } = node;
|
|
className = nodeClassFunc(data, node);
|
|
} else {
|
|
className = nodeClassFunc;
|
|
}
|
|
return isString(className) ? { [className]: true } : className;
|
|
};
|
|
const handleClick = (e) => {
|
|
emit("click", props2.node, e);
|
|
};
|
|
const handleDrop = (e) => {
|
|
emit("drop", props2.node, e);
|
|
};
|
|
const handleExpandIconClick = () => {
|
|
emit("toggle", props2.node);
|
|
};
|
|
const handleCheckChange = (value) => {
|
|
emit("check", props2.node, value);
|
|
};
|
|
const handleContextMenu = (event) => {
|
|
var _a2, _b, _c, _d;
|
|
if ((_c = (_b = (_a2 = tree == null ? void 0 : tree.instance) == null ? void 0 : _a2.vnode) == null ? void 0 : _b.props) == null ? void 0 : _c["onNodeContextmenu"]) {
|
|
event.stopPropagation();
|
|
event.preventDefault();
|
|
}
|
|
tree == null ? void 0 : tree.ctx.emit(NODE_CONTEXTMENU, event, (_d = props2.node) == null ? void 0 : _d.data, props2.node);
|
|
};
|
|
return (_ctx, _cache) => {
|
|
var _a2, _b, _c;
|
|
return openBlock(), createElementBlock("div", {
|
|
ref: "node$",
|
|
class: normalizeClass([
|
|
unref(ns).b("node"),
|
|
unref(ns).is("expanded", _ctx.expanded),
|
|
unref(ns).is("current", _ctx.current),
|
|
unref(ns).is("focusable", !_ctx.disabled),
|
|
unref(ns).is("checked", !_ctx.disabled && _ctx.checked),
|
|
getNodeClass(_ctx.node)
|
|
]),
|
|
role: "treeitem",
|
|
tabindex: "-1",
|
|
"aria-expanded": _ctx.expanded,
|
|
"aria-disabled": _ctx.disabled,
|
|
"aria-checked": _ctx.checked,
|
|
"data-key": (_a2 = _ctx.node) == null ? void 0 : _a2.key,
|
|
onClick: withModifiers(handleClick, ["stop"]),
|
|
onContextmenu: handleContextMenu,
|
|
onDragover: withModifiers(() => {
|
|
}, ["prevent"]),
|
|
onDragenter: withModifiers(() => {
|
|
}, ["prevent"]),
|
|
onDrop: withModifiers(handleDrop, ["stop"])
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).be("node", "content")),
|
|
style: normalizeStyle({
|
|
paddingLeft: `${(_ctx.node.level - 1) * unref(indent)}px`,
|
|
height: _ctx.itemSize + "px"
|
|
})
|
|
}, [
|
|
unref(icon) ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass([
|
|
unref(ns).is("leaf", !!((_b = _ctx.node) == null ? void 0 : _b.isLeaf)),
|
|
unref(ns).is("hidden", _ctx.hiddenExpandIcon),
|
|
{
|
|
expanded: !((_c = _ctx.node) == null ? void 0 : _c.isLeaf) && _ctx.expanded
|
|
},
|
|
unref(ns).be("node", "expand-icon")
|
|
]),
|
|
onClick: withModifiers(handleExpandIconClick, ["stop"])
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(unref(icon))))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "onClick"])) : createCommentVNode("v-if", true),
|
|
_ctx.showCheckbox ? (openBlock(), createBlock(unref(ElCheckbox), {
|
|
key: 1,
|
|
"model-value": _ctx.checked,
|
|
indeterminate: _ctx.indeterminate,
|
|
disabled: _ctx.disabled,
|
|
onChange: handleCheckChange,
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, null, 8, ["model-value", "indeterminate", "disabled", "onClick"])) : createCommentVNode("v-if", true),
|
|
createVNode(unref(ElNodeContent), { node: _ctx.node }, null, 8, ["node"])
|
|
], 6)
|
|
], 42, ["aria-expanded", "aria-disabled", "aria-checked", "data-key", "onClick", "onDragover", "onDragenter", "onDrop"]);
|
|
};
|
|
}
|
|
});
|
|
var ElTreeNode2 = _export_sfc(_sfc_main138, [["__file", "tree-node.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tree-v2/src/tree.mjs
|
|
var __default__99 = defineComponent({
|
|
name: "ElTreeV2"
|
|
});
|
|
var _sfc_main139 = defineComponent({
|
|
...__default__99,
|
|
props: treeProps,
|
|
emits: treeEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const slots = useSlots();
|
|
const treeNodeSize = computed(() => props2.itemSize);
|
|
provide(ROOT_TREE_INJECTION_KEY, {
|
|
ctx: {
|
|
emit,
|
|
slots
|
|
},
|
|
props: props2,
|
|
instance: getCurrentInstance()
|
|
});
|
|
provide(formItemContextKey, void 0);
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("tree");
|
|
const {
|
|
flattenTree,
|
|
isNotEmpty,
|
|
listRef,
|
|
toggleExpand,
|
|
isExpanded,
|
|
isIndeterminate,
|
|
isChecked,
|
|
isDisabled,
|
|
isCurrent,
|
|
isForceHiddenExpandIcon,
|
|
handleNodeClick,
|
|
handleNodeDrop,
|
|
handleNodeCheck,
|
|
toggleCheckbox,
|
|
getCurrentNode,
|
|
getCurrentKey,
|
|
setCurrentKey,
|
|
getCheckedKeys,
|
|
getCheckedNodes,
|
|
getHalfCheckedKeys,
|
|
getHalfCheckedNodes,
|
|
setChecked,
|
|
setCheckedKeys,
|
|
filter: filter2,
|
|
setData: setData2,
|
|
getNode,
|
|
expandNode,
|
|
collapseNode,
|
|
setExpandedKeys,
|
|
scrollToNode,
|
|
scrollTo
|
|
} = useTree3(props2, emit);
|
|
expose({
|
|
toggleCheckbox,
|
|
getCurrentNode,
|
|
getCurrentKey,
|
|
setCurrentKey,
|
|
getCheckedKeys,
|
|
getCheckedNodes,
|
|
getHalfCheckedKeys,
|
|
getHalfCheckedNodes,
|
|
setChecked,
|
|
setCheckedKeys,
|
|
filter: filter2,
|
|
setData: setData2,
|
|
getNode,
|
|
expandNode,
|
|
collapseNode,
|
|
setExpandedKeys,
|
|
scrollToNode,
|
|
scrollTo
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([unref(ns).b(), { [unref(ns).m("highlight-current")]: _ctx.highlightCurrent }]),
|
|
role: "tree"
|
|
}, [
|
|
unref(isNotEmpty) ? (openBlock(), createBlock(unref(FixedSizeList), {
|
|
key: 0,
|
|
ref_key: "listRef",
|
|
ref: listRef,
|
|
"class-name": unref(ns).b("virtual-list"),
|
|
data: unref(flattenTree),
|
|
total: unref(flattenTree).length,
|
|
height: _ctx.height,
|
|
"item-size": unref(treeNodeSize),
|
|
"perf-mode": _ctx.perfMode
|
|
}, {
|
|
default: withCtx(({ data, index, style }) => [
|
|
(openBlock(), createBlock(ElTreeNode2, {
|
|
key: data[index].key,
|
|
style: normalizeStyle(style),
|
|
node: data[index],
|
|
expanded: unref(isExpanded)(data[index]),
|
|
"show-checkbox": _ctx.showCheckbox,
|
|
checked: unref(isChecked)(data[index]),
|
|
indeterminate: unref(isIndeterminate)(data[index]),
|
|
"item-size": unref(treeNodeSize),
|
|
disabled: unref(isDisabled)(data[index]),
|
|
current: unref(isCurrent)(data[index]),
|
|
"hidden-expand-icon": unref(isForceHiddenExpandIcon)(data[index]),
|
|
onClick: unref(handleNodeClick),
|
|
onToggle: unref(toggleExpand),
|
|
onCheck: unref(handleNodeCheck),
|
|
onDrop: unref(handleNodeDrop)
|
|
}, null, 8, ["style", "node", "expanded", "show-checkbox", "checked", "indeterminate", "item-size", "disabled", "current", "hidden-expand-icon", "onClick", "onToggle", "onCheck", "onDrop"]))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class-name", "data", "total", "height", "item-size", "perf-mode"])) : (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("empty-block"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "empty", {}, () => {
|
|
var _a2;
|
|
return [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(ns).e("empty-text"))
|
|
}, toDisplayString((_a2 = _ctx.emptyText) != null ? _a2 : unref(t)("el.tree.emptyText")), 3)
|
|
];
|
|
})
|
|
], 2))
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var TreeV2 = _export_sfc(_sfc_main139, [["__file", "tree.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tree-v2/index.mjs
|
|
var ElTreeV2 = withInstall(TreeV2);
|
|
|
|
// node_modules/element-plus/es/components/upload/src/constants.mjs
|
|
var uploadContextKey = Symbol("uploadContextKey");
|
|
|
|
// node_modules/element-plus/es/components/upload/src/ajax.mjs
|
|
var SCOPE9 = "ElUpload";
|
|
var UploadAjaxError = class extends Error {
|
|
constructor(message2, status, method5, url2) {
|
|
super(message2);
|
|
this.name = "UploadAjaxError";
|
|
this.status = status;
|
|
this.method = method5;
|
|
this.url = url2;
|
|
}
|
|
};
|
|
function getError(action, option, xhr) {
|
|
let msg;
|
|
if (xhr.response) {
|
|
msg = `${xhr.response.error || xhr.response}`;
|
|
} else if (xhr.responseText) {
|
|
msg = `${xhr.responseText}`;
|
|
} else {
|
|
msg = `fail to ${option.method} ${action} ${xhr.status}`;
|
|
}
|
|
return new UploadAjaxError(msg, xhr.status, option.method, action);
|
|
}
|
|
function getBody(xhr) {
|
|
const text = xhr.responseText || xhr.response;
|
|
if (!text) {
|
|
return text;
|
|
}
|
|
try {
|
|
return JSON.parse(text);
|
|
} catch (e) {
|
|
return text;
|
|
}
|
|
}
|
|
var ajaxUpload = (option) => {
|
|
if (typeof XMLHttpRequest === "undefined")
|
|
throwError(SCOPE9, "XMLHttpRequest is undefined");
|
|
const xhr = new XMLHttpRequest();
|
|
const action = option.action;
|
|
if (xhr.upload) {
|
|
xhr.upload.addEventListener("progress", (evt) => {
|
|
const progressEvt = evt;
|
|
progressEvt.percent = evt.total > 0 ? evt.loaded / evt.total * 100 : 0;
|
|
option.onProgress(progressEvt);
|
|
});
|
|
}
|
|
const formData = new FormData();
|
|
if (option.data) {
|
|
for (const [key, value] of Object.entries(option.data)) {
|
|
if (isArray(value) && value.length)
|
|
formData.append(key, ...value);
|
|
else
|
|
formData.append(key, value);
|
|
}
|
|
}
|
|
formData.append(option.filename, option.file, option.file.name);
|
|
xhr.addEventListener("error", () => {
|
|
option.onError(getError(action, option, xhr));
|
|
});
|
|
xhr.addEventListener("load", () => {
|
|
if (xhr.status < 200 || xhr.status >= 300) {
|
|
return option.onError(getError(action, option, xhr));
|
|
}
|
|
option.onSuccess(getBody(xhr));
|
|
});
|
|
xhr.open(option.method, action, true);
|
|
if (option.withCredentials && "withCredentials" in xhr) {
|
|
xhr.withCredentials = true;
|
|
}
|
|
const headers = option.headers || {};
|
|
if (headers instanceof Headers) {
|
|
headers.forEach((value, key) => xhr.setRequestHeader(key, value));
|
|
} else {
|
|
for (const [key, value] of Object.entries(headers)) {
|
|
if (isNil_default(value))
|
|
continue;
|
|
xhr.setRequestHeader(key, String(value));
|
|
}
|
|
}
|
|
xhr.send(formData);
|
|
return xhr;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/upload/src/upload.mjs
|
|
var uploadListTypes = ["text", "picture", "picture-card"];
|
|
var fileId = 1;
|
|
var genFileId = () => Date.now() + fileId++;
|
|
var uploadBaseProps = buildProps({
|
|
action: {
|
|
type: String,
|
|
default: "#"
|
|
},
|
|
headers: {
|
|
type: definePropType(Object)
|
|
},
|
|
method: {
|
|
type: String,
|
|
default: "post"
|
|
},
|
|
data: {
|
|
type: definePropType([Object, Function, Promise]),
|
|
default: () => mutable({})
|
|
},
|
|
multiple: Boolean,
|
|
name: {
|
|
type: String,
|
|
default: "file"
|
|
},
|
|
drag: Boolean,
|
|
withCredentials: Boolean,
|
|
showFileList: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
accept: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
fileList: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([])
|
|
},
|
|
autoUpload: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
listType: {
|
|
type: String,
|
|
values: uploadListTypes,
|
|
default: "text"
|
|
},
|
|
httpRequest: {
|
|
type: definePropType(Function),
|
|
default: ajaxUpload
|
|
},
|
|
disabled: Boolean,
|
|
limit: Number
|
|
});
|
|
var uploadProps = buildProps({
|
|
...uploadBaseProps,
|
|
beforeUpload: {
|
|
type: definePropType(Function),
|
|
default: NOOP
|
|
},
|
|
beforeRemove: {
|
|
type: definePropType(Function)
|
|
},
|
|
onRemove: {
|
|
type: definePropType(Function),
|
|
default: NOOP
|
|
},
|
|
onChange: {
|
|
type: definePropType(Function),
|
|
default: NOOP
|
|
},
|
|
onPreview: {
|
|
type: definePropType(Function),
|
|
default: NOOP
|
|
},
|
|
onSuccess: {
|
|
type: definePropType(Function),
|
|
default: NOOP
|
|
},
|
|
onProgress: {
|
|
type: definePropType(Function),
|
|
default: NOOP
|
|
},
|
|
onError: {
|
|
type: definePropType(Function),
|
|
default: NOOP
|
|
},
|
|
onExceed: {
|
|
type: definePropType(Function),
|
|
default: NOOP
|
|
},
|
|
crossorigin: {
|
|
type: definePropType(String)
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/upload/src/upload-list.mjs
|
|
var uploadListProps = buildProps({
|
|
files: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([])
|
|
},
|
|
disabled: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
handlePreview: {
|
|
type: definePropType(Function),
|
|
default: NOOP
|
|
},
|
|
listType: {
|
|
type: String,
|
|
values: uploadListTypes,
|
|
default: "text"
|
|
},
|
|
crossorigin: {
|
|
type: definePropType(String)
|
|
}
|
|
});
|
|
var uploadListEmits = {
|
|
remove: (file) => !!file
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/upload/src/upload-dragger.mjs
|
|
var uploadDraggerProps = buildProps({
|
|
disabled: {
|
|
type: Boolean,
|
|
default: false
|
|
}
|
|
});
|
|
var uploadDraggerEmits = {
|
|
file: (file) => isArray(file)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/upload/src/upload-content.mjs
|
|
var uploadContentProps = buildProps({
|
|
...uploadBaseProps,
|
|
beforeUpload: {
|
|
type: definePropType(Function),
|
|
default: NOOP
|
|
},
|
|
onRemove: {
|
|
type: definePropType(Function),
|
|
default: NOOP
|
|
},
|
|
onStart: {
|
|
type: definePropType(Function),
|
|
default: NOOP
|
|
},
|
|
onSuccess: {
|
|
type: definePropType(Function),
|
|
default: NOOP
|
|
},
|
|
onProgress: {
|
|
type: definePropType(Function),
|
|
default: NOOP
|
|
},
|
|
onError: {
|
|
type: definePropType(Function),
|
|
default: NOOP
|
|
},
|
|
onExceed: {
|
|
type: definePropType(Function),
|
|
default: NOOP
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/upload/src/upload-list2.mjs
|
|
var __default__100 = defineComponent({
|
|
name: "ElUploadList"
|
|
});
|
|
var _sfc_main140 = defineComponent({
|
|
...__default__100,
|
|
props: uploadListProps,
|
|
emits: uploadListEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const { t } = useLocale();
|
|
const nsUpload = useNamespace("upload");
|
|
const nsIcon = useNamespace("icon");
|
|
const nsList = useNamespace("list");
|
|
const disabled = useFormDisabled();
|
|
const focusing = ref(false);
|
|
const containerKls = computed(() => [
|
|
nsUpload.b("list"),
|
|
nsUpload.bm("list", props2.listType),
|
|
nsUpload.is("disabled", props2.disabled)
|
|
]);
|
|
const handleRemove = (file) => {
|
|
emit("remove", file);
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(TransitionGroup, {
|
|
tag: "ul",
|
|
class: normalizeClass(unref(containerKls)),
|
|
name: unref(nsList).b()
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.files, (file, index) => {
|
|
return openBlock(), createElementBlock("li", {
|
|
key: file.uid || file.name,
|
|
class: normalizeClass([
|
|
unref(nsUpload).be("list", "item"),
|
|
unref(nsUpload).is(file.status),
|
|
{ focusing: focusing.value }
|
|
]),
|
|
tabindex: "0",
|
|
onKeydown: withKeys(($event) => !unref(disabled) && handleRemove(file), ["delete"]),
|
|
onFocus: ($event) => focusing.value = true,
|
|
onBlur: ($event) => focusing.value = false,
|
|
onClick: ($event) => focusing.value = false
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default", {
|
|
file,
|
|
index
|
|
}, () => [
|
|
_ctx.listType === "picture" || file.status !== "uploading" && _ctx.listType === "picture-card" ? (openBlock(), createElementBlock("img", {
|
|
key: 0,
|
|
class: normalizeClass(unref(nsUpload).be("list", "item-thumbnail")),
|
|
src: file.url,
|
|
crossorigin: _ctx.crossorigin,
|
|
alt: ""
|
|
}, null, 10, ["src", "crossorigin"])) : createCommentVNode("v-if", true),
|
|
file.status === "uploading" || _ctx.listType !== "picture-card" ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(nsUpload).be("list", "item-info"))
|
|
}, [
|
|
createBaseVNode("a", {
|
|
class: normalizeClass(unref(nsUpload).be("list", "item-name")),
|
|
onClick: withModifiers(($event) => _ctx.handlePreview(file), ["prevent"])
|
|
}, [
|
|
createVNode(unref(ElIcon), {
|
|
class: normalizeClass(unref(nsIcon).m("document"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(document_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"]),
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(nsUpload).be("list", "item-file-name")),
|
|
title: file.name
|
|
}, toDisplayString(file.name), 11, ["title"])
|
|
], 10, ["onClick"]),
|
|
file.status === "uploading" ? (openBlock(), createBlock(unref(ElProgress), {
|
|
key: 0,
|
|
type: _ctx.listType === "picture-card" ? "circle" : "line",
|
|
"stroke-width": _ctx.listType === "picture-card" ? 6 : 2,
|
|
percentage: Number(file.percentage),
|
|
style: normalizeStyle(_ctx.listType === "picture-card" ? "" : "margin-top: 0.5rem")
|
|
}, null, 8, ["type", "stroke-width", "percentage", "style"])) : createCommentVNode("v-if", true)
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("label", {
|
|
class: normalizeClass(unref(nsUpload).be("list", "item-status-label"))
|
|
}, [
|
|
_ctx.listType === "text" ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass([unref(nsIcon).m("upload-success"), unref(nsIcon).m("circle-check")])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(circle_check_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : ["picture-card", "picture"].includes(_ctx.listType) ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 1,
|
|
class: normalizeClass([unref(nsIcon).m("upload-success"), unref(nsIcon).m("check")])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(check_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true)
|
|
], 2),
|
|
!unref(disabled) ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 2,
|
|
class: normalizeClass(unref(nsIcon).m("close")),
|
|
onClick: ($event) => handleRemove(file)
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(close_default))
|
|
]),
|
|
_: 2
|
|
}, 1032, ["class", "onClick"])) : createCommentVNode("v-if", true),
|
|
createCommentVNode(" Due to close btn only appears when li gets focused disappears after li gets blurred, thus keyboard navigation can never reach close btn"),
|
|
createCommentVNode(" This is a bug which needs to be fixed "),
|
|
createCommentVNode(" TODO: Fix the incorrect navigation interaction "),
|
|
!unref(disabled) ? (openBlock(), createElementBlock("i", {
|
|
key: 3,
|
|
class: normalizeClass(unref(nsIcon).m("close-tip"))
|
|
}, toDisplayString(unref(t)("el.upload.deleteTip")), 3)) : createCommentVNode("v-if", true),
|
|
_ctx.listType === "picture-card" ? (openBlock(), createElementBlock("span", {
|
|
key: 4,
|
|
class: normalizeClass(unref(nsUpload).be("list", "item-actions"))
|
|
}, [
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(nsUpload).be("list", "item-preview")),
|
|
onClick: ($event) => _ctx.handlePreview(file)
|
|
}, [
|
|
createVNode(unref(ElIcon), {
|
|
class: normalizeClass(unref(nsIcon).m("zoom-in"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(zoom_in_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])
|
|
], 10, ["onClick"]),
|
|
!unref(disabled) ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
class: normalizeClass(unref(nsUpload).be("list", "item-delete")),
|
|
onClick: ($event) => handleRemove(file)
|
|
}, [
|
|
createVNode(unref(ElIcon), {
|
|
class: normalizeClass(unref(nsIcon).m("delete"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(delete_default))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])
|
|
], 10, ["onClick"])) : createCommentVNode("v-if", true)
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
])
|
|
], 42, ["onKeydown", "onFocus", "onBlur", "onClick"]);
|
|
}), 128)),
|
|
renderSlot(_ctx.$slots, "append")
|
|
]),
|
|
_: 3
|
|
}, 8, ["class", "name"]);
|
|
};
|
|
}
|
|
});
|
|
var UploadList = _export_sfc(_sfc_main140, [["__file", "upload-list.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/upload/src/upload-dragger2.mjs
|
|
var COMPONENT_NAME26 = "ElUploadDrag";
|
|
var __default__101 = defineComponent({
|
|
name: COMPONENT_NAME26
|
|
});
|
|
var _sfc_main141 = defineComponent({
|
|
...__default__101,
|
|
props: uploadDraggerProps,
|
|
emits: uploadDraggerEmits,
|
|
setup(__props, { emit }) {
|
|
const uploaderContext = inject(uploadContextKey);
|
|
if (!uploaderContext) {
|
|
throwError(COMPONENT_NAME26, "usage: <el-upload><el-upload-dragger /></el-upload>");
|
|
}
|
|
const ns = useNamespace("upload");
|
|
const dragover = ref(false);
|
|
const disabled = useFormDisabled();
|
|
const onDrop = (e) => {
|
|
if (disabled.value)
|
|
return;
|
|
dragover.value = false;
|
|
e.stopPropagation();
|
|
const files = Array.from(e.dataTransfer.files);
|
|
const items = e.dataTransfer.items || [];
|
|
files.forEach((file, index) => {
|
|
var _a2;
|
|
const item = items[index];
|
|
const entry = (_a2 = item == null ? void 0 : item.webkitGetAsEntry) == null ? void 0 : _a2.call(item);
|
|
if (entry) {
|
|
file.isDirectory = entry.isDirectory;
|
|
}
|
|
});
|
|
emit("file", files);
|
|
};
|
|
const onDragover = () => {
|
|
if (!disabled.value)
|
|
dragover.value = true;
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([unref(ns).b("dragger"), unref(ns).is("dragover", dragover.value)]),
|
|
onDrop: withModifiers(onDrop, ["prevent"]),
|
|
onDragover: withModifiers(onDragover, ["prevent"]),
|
|
onDragleave: withModifiers(($event) => dragover.value = false, ["prevent"])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 42, ["onDrop", "onDragover", "onDragleave"]);
|
|
};
|
|
}
|
|
});
|
|
var UploadDragger = _export_sfc(_sfc_main141, [["__file", "upload-dragger.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/upload/src/upload-content2.mjs
|
|
var __default__102 = defineComponent({
|
|
name: "ElUploadContent",
|
|
inheritAttrs: false
|
|
});
|
|
var _sfc_main142 = defineComponent({
|
|
...__default__102,
|
|
props: uploadContentProps,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("upload");
|
|
const disabled = useFormDisabled();
|
|
const requests = shallowRef({});
|
|
const inputRef = shallowRef();
|
|
const uploadFiles = (files) => {
|
|
if (files.length === 0)
|
|
return;
|
|
const { autoUpload, limit, fileList, multiple, onStart, onExceed } = props2;
|
|
if (limit && fileList.length + files.length > limit) {
|
|
onExceed(files, fileList);
|
|
return;
|
|
}
|
|
if (!multiple) {
|
|
files = files.slice(0, 1);
|
|
}
|
|
for (const file of files) {
|
|
const rawFile = file;
|
|
rawFile.uid = genFileId();
|
|
onStart(rawFile);
|
|
if (autoUpload)
|
|
upload(rawFile);
|
|
}
|
|
};
|
|
const upload = async (rawFile) => {
|
|
inputRef.value.value = "";
|
|
if (!props2.beforeUpload) {
|
|
return doUpload(rawFile);
|
|
}
|
|
let hookResult;
|
|
let beforeData = {};
|
|
try {
|
|
const originData = props2.data;
|
|
const beforeUploadPromise = props2.beforeUpload(rawFile);
|
|
beforeData = isPlainObject(props2.data) ? cloneDeep_default(props2.data) : props2.data;
|
|
hookResult = await beforeUploadPromise;
|
|
if (isPlainObject(props2.data) && isEqual_default(originData, beforeData)) {
|
|
beforeData = cloneDeep_default(props2.data);
|
|
}
|
|
} catch (e) {
|
|
hookResult = false;
|
|
}
|
|
if (hookResult === false) {
|
|
props2.onRemove(rawFile);
|
|
return;
|
|
}
|
|
let file = rawFile;
|
|
if (hookResult instanceof Blob) {
|
|
if (hookResult instanceof File) {
|
|
file = hookResult;
|
|
} else {
|
|
file = new File([hookResult], rawFile.name, {
|
|
type: rawFile.type
|
|
});
|
|
}
|
|
}
|
|
doUpload(Object.assign(file, {
|
|
uid: rawFile.uid
|
|
}), beforeData);
|
|
};
|
|
const resolveData = async (data, rawFile) => {
|
|
if (isFunction(data)) {
|
|
return data(rawFile);
|
|
}
|
|
return data;
|
|
};
|
|
const doUpload = async (rawFile, beforeData) => {
|
|
const {
|
|
headers,
|
|
data,
|
|
method: method5,
|
|
withCredentials,
|
|
name: filename,
|
|
action,
|
|
onProgress,
|
|
onSuccess,
|
|
onError,
|
|
httpRequest
|
|
} = props2;
|
|
try {
|
|
beforeData = await resolveData(beforeData != null ? beforeData : data, rawFile);
|
|
} catch (e) {
|
|
props2.onRemove(rawFile);
|
|
return;
|
|
}
|
|
const { uid: uid2 } = rawFile;
|
|
const options = {
|
|
headers: headers || {},
|
|
withCredentials,
|
|
file: rawFile,
|
|
data: beforeData,
|
|
method: method5,
|
|
filename,
|
|
action,
|
|
onProgress: (evt) => {
|
|
onProgress(evt, rawFile);
|
|
},
|
|
onSuccess: (res) => {
|
|
onSuccess(res, rawFile);
|
|
delete requests.value[uid2];
|
|
},
|
|
onError: (err) => {
|
|
onError(err, rawFile);
|
|
delete requests.value[uid2];
|
|
}
|
|
};
|
|
const request = httpRequest(options);
|
|
requests.value[uid2] = request;
|
|
if (request instanceof Promise) {
|
|
request.then(options.onSuccess, options.onError);
|
|
}
|
|
};
|
|
const handleChange = (e) => {
|
|
const files = e.target.files;
|
|
if (!files)
|
|
return;
|
|
uploadFiles(Array.from(files));
|
|
};
|
|
const handleClick = () => {
|
|
if (!disabled.value) {
|
|
inputRef.value.value = "";
|
|
inputRef.value.click();
|
|
}
|
|
};
|
|
const handleKeydown = () => {
|
|
handleClick();
|
|
};
|
|
const abort = (file) => {
|
|
const _reqs = entriesOf(requests.value).filter(file ? ([uid2]) => String(file.uid) === uid2 : () => true);
|
|
_reqs.forEach(([uid2, req]) => {
|
|
if (req instanceof XMLHttpRequest)
|
|
req.abort();
|
|
delete requests.value[uid2];
|
|
});
|
|
};
|
|
expose({
|
|
abort,
|
|
upload
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([
|
|
unref(ns).b(),
|
|
unref(ns).m(_ctx.listType),
|
|
unref(ns).is("drag", _ctx.drag),
|
|
unref(ns).is("disabled", unref(disabled))
|
|
]),
|
|
tabindex: unref(disabled) ? "-1" : "0",
|
|
onClick: handleClick,
|
|
onKeydown: withKeys(withModifiers(handleKeydown, ["self"]), ["enter", "space"])
|
|
}, [
|
|
_ctx.drag ? (openBlock(), createBlock(UploadDragger, {
|
|
key: 0,
|
|
disabled: unref(disabled),
|
|
onFile: uploadFiles
|
|
}, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 8, ["disabled"])) : renderSlot(_ctx.$slots, "default", { key: 1 }),
|
|
createBaseVNode("input", {
|
|
ref_key: "inputRef",
|
|
ref: inputRef,
|
|
class: normalizeClass(unref(ns).e("input")),
|
|
name: _ctx.name,
|
|
disabled: unref(disabled),
|
|
multiple: _ctx.multiple,
|
|
accept: _ctx.accept,
|
|
type: "file",
|
|
onChange: handleChange,
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, null, 42, ["name", "disabled", "multiple", "accept", "onClick"])
|
|
], 42, ["tabindex", "onKeydown"]);
|
|
};
|
|
}
|
|
});
|
|
var UploadContent = _export_sfc(_sfc_main142, [["__file", "upload-content.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/upload/src/use-handlers.mjs
|
|
var SCOPE10 = "ElUpload";
|
|
var revokeFileObjectURL = (file) => {
|
|
var _a2;
|
|
if ((_a2 = file.url) == null ? void 0 : _a2.startsWith("blob:")) {
|
|
URL.revokeObjectURL(file.url);
|
|
}
|
|
};
|
|
var useHandlers = (props2, uploadRef) => {
|
|
const uploadFiles = useVModel(props2, "fileList", void 0, { passive: true });
|
|
const getFile = (rawFile) => uploadFiles.value.find((file) => file.uid === rawFile.uid);
|
|
function abort(file) {
|
|
var _a2;
|
|
(_a2 = uploadRef.value) == null ? void 0 : _a2.abort(file);
|
|
}
|
|
function clearFiles(states = ["ready", "uploading", "success", "fail"]) {
|
|
uploadFiles.value = uploadFiles.value.filter((row) => !states.includes(row.status));
|
|
}
|
|
function removeFile(file) {
|
|
uploadFiles.value = uploadFiles.value.filter((uploadFile) => uploadFile.uid !== file.uid);
|
|
}
|
|
const handleError = (err, rawFile) => {
|
|
const file = getFile(rawFile);
|
|
if (!file)
|
|
return;
|
|
console.error(err);
|
|
file.status = "fail";
|
|
removeFile(file);
|
|
props2.onError(err, file, uploadFiles.value);
|
|
props2.onChange(file, uploadFiles.value);
|
|
};
|
|
const handleProgress = (evt, rawFile) => {
|
|
const file = getFile(rawFile);
|
|
if (!file)
|
|
return;
|
|
props2.onProgress(evt, file, uploadFiles.value);
|
|
file.status = "uploading";
|
|
file.percentage = Math.round(evt.percent);
|
|
};
|
|
const handleSuccess = (response, rawFile) => {
|
|
const file = getFile(rawFile);
|
|
if (!file)
|
|
return;
|
|
file.status = "success";
|
|
file.response = response;
|
|
props2.onSuccess(response, file, uploadFiles.value);
|
|
props2.onChange(file, uploadFiles.value);
|
|
};
|
|
const handleStart = (file) => {
|
|
if (isNil_default(file.uid))
|
|
file.uid = genFileId();
|
|
const uploadFile = {
|
|
name: file.name,
|
|
percentage: 0,
|
|
status: "ready",
|
|
size: file.size,
|
|
raw: file,
|
|
uid: file.uid
|
|
};
|
|
if (props2.listType === "picture-card" || props2.listType === "picture") {
|
|
try {
|
|
uploadFile.url = URL.createObjectURL(file);
|
|
} catch (err) {
|
|
debugWarn(SCOPE10, err.message);
|
|
props2.onError(err, uploadFile, uploadFiles.value);
|
|
}
|
|
}
|
|
uploadFiles.value = [...uploadFiles.value, uploadFile];
|
|
props2.onChange(uploadFile, uploadFiles.value);
|
|
};
|
|
const handleRemove = async (file) => {
|
|
const uploadFile = file instanceof File ? getFile(file) : file;
|
|
if (!uploadFile)
|
|
throwError(SCOPE10, "file to be removed not found");
|
|
const doRemove = (file2) => {
|
|
abort(file2);
|
|
removeFile(file2);
|
|
props2.onRemove(file2, uploadFiles.value);
|
|
revokeFileObjectURL(file2);
|
|
};
|
|
if (props2.beforeRemove) {
|
|
const before2 = await props2.beforeRemove(uploadFile, uploadFiles.value);
|
|
if (before2 !== false)
|
|
doRemove(uploadFile);
|
|
} else {
|
|
doRemove(uploadFile);
|
|
}
|
|
};
|
|
function submit() {
|
|
uploadFiles.value.filter(({ status }) => status === "ready").forEach(({ raw }) => {
|
|
var _a2;
|
|
return raw && ((_a2 = uploadRef.value) == null ? void 0 : _a2.upload(raw));
|
|
});
|
|
}
|
|
watch(() => props2.listType, (val) => {
|
|
if (val !== "picture-card" && val !== "picture") {
|
|
return;
|
|
}
|
|
uploadFiles.value = uploadFiles.value.map((file) => {
|
|
const { raw, url: url2 } = file;
|
|
if (!url2 && raw) {
|
|
try {
|
|
file.url = URL.createObjectURL(raw);
|
|
} catch (err) {
|
|
props2.onError(err, file, uploadFiles.value);
|
|
}
|
|
}
|
|
return file;
|
|
});
|
|
});
|
|
watch(uploadFiles, (files) => {
|
|
for (const file of files) {
|
|
file.uid || (file.uid = genFileId());
|
|
file.status || (file.status = "success");
|
|
}
|
|
}, { immediate: true, deep: true });
|
|
return {
|
|
uploadFiles,
|
|
abort,
|
|
clearFiles,
|
|
handleError,
|
|
handleProgress,
|
|
handleStart,
|
|
handleSuccess,
|
|
handleRemove,
|
|
submit,
|
|
revokeFileObjectURL
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/upload/src/upload2.mjs
|
|
var __default__103 = defineComponent({
|
|
name: "ElUpload"
|
|
});
|
|
var _sfc_main143 = defineComponent({
|
|
...__default__103,
|
|
props: uploadProps,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const disabled = useFormDisabled();
|
|
const uploadRef = shallowRef();
|
|
const {
|
|
abort,
|
|
submit,
|
|
clearFiles,
|
|
uploadFiles,
|
|
handleStart,
|
|
handleError,
|
|
handleRemove,
|
|
handleSuccess,
|
|
handleProgress,
|
|
revokeFileObjectURL: revokeFileObjectURL2
|
|
} = useHandlers(props2, uploadRef);
|
|
const isPictureCard = computed(() => props2.listType === "picture-card");
|
|
const uploadContentProps2 = computed(() => ({
|
|
...props2,
|
|
fileList: uploadFiles.value,
|
|
onStart: handleStart,
|
|
onProgress: handleProgress,
|
|
onSuccess: handleSuccess,
|
|
onError: handleError,
|
|
onRemove: handleRemove
|
|
}));
|
|
onBeforeUnmount(() => {
|
|
uploadFiles.value.forEach(revokeFileObjectURL2);
|
|
});
|
|
provide(uploadContextKey, {
|
|
accept: toRef(props2, "accept")
|
|
});
|
|
expose({
|
|
abort,
|
|
submit,
|
|
clearFiles,
|
|
handleStart,
|
|
handleRemove
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", null, [
|
|
unref(isPictureCard) && _ctx.showFileList ? (openBlock(), createBlock(UploadList, {
|
|
key: 0,
|
|
disabled: unref(disabled),
|
|
"list-type": _ctx.listType,
|
|
files: unref(uploadFiles),
|
|
crossorigin: _ctx.crossorigin,
|
|
"handle-preview": _ctx.onPreview,
|
|
onRemove: unref(handleRemove)
|
|
}, createSlots({
|
|
append: withCtx(() => [
|
|
createVNode(UploadContent, mergeProps({
|
|
ref_key: "uploadRef",
|
|
ref: uploadRef
|
|
}, unref(uploadContentProps2)), {
|
|
default: withCtx(() => [
|
|
_ctx.$slots.trigger ? renderSlot(_ctx.$slots, "trigger", { key: 0 }) : createCommentVNode("v-if", true),
|
|
!_ctx.$slots.trigger && _ctx.$slots.default ? renderSlot(_ctx.$slots, "default", { key: 1 }) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 16)
|
|
]),
|
|
_: 2
|
|
}, [
|
|
_ctx.$slots.file ? {
|
|
name: "default",
|
|
fn: withCtx(({ file, index }) => [
|
|
renderSlot(_ctx.$slots, "file", {
|
|
file,
|
|
index
|
|
})
|
|
])
|
|
} : void 0
|
|
]), 1032, ["disabled", "list-type", "files", "crossorigin", "handle-preview", "onRemove"])) : createCommentVNode("v-if", true),
|
|
!unref(isPictureCard) || unref(isPictureCard) && !_ctx.showFileList ? (openBlock(), createBlock(UploadContent, mergeProps({
|
|
key: 1,
|
|
ref_key: "uploadRef",
|
|
ref: uploadRef
|
|
}, unref(uploadContentProps2)), {
|
|
default: withCtx(() => [
|
|
_ctx.$slots.trigger ? renderSlot(_ctx.$slots, "trigger", { key: 0 }) : createCommentVNode("v-if", true),
|
|
!_ctx.$slots.trigger && _ctx.$slots.default ? renderSlot(_ctx.$slots, "default", { key: 1 }) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 16)) : createCommentVNode("v-if", true),
|
|
_ctx.$slots.trigger ? renderSlot(_ctx.$slots, "default", { key: 2 }) : createCommentVNode("v-if", true),
|
|
renderSlot(_ctx.$slots, "tip"),
|
|
!unref(isPictureCard) && _ctx.showFileList ? (openBlock(), createBlock(UploadList, {
|
|
key: 3,
|
|
disabled: unref(disabled),
|
|
"list-type": _ctx.listType,
|
|
files: unref(uploadFiles),
|
|
crossorigin: _ctx.crossorigin,
|
|
"handle-preview": _ctx.onPreview,
|
|
onRemove: unref(handleRemove)
|
|
}, createSlots({
|
|
_: 2
|
|
}, [
|
|
_ctx.$slots.file ? {
|
|
name: "default",
|
|
fn: withCtx(({ file, index }) => [
|
|
renderSlot(_ctx.$slots, "file", {
|
|
file,
|
|
index
|
|
})
|
|
])
|
|
} : void 0
|
|
]), 1032, ["disabled", "list-type", "files", "crossorigin", "handle-preview", "onRemove"])) : createCommentVNode("v-if", true)
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
var Upload = _export_sfc(_sfc_main143, [["__file", "upload.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/upload/index.mjs
|
|
var ElUpload = withInstall(Upload);
|
|
|
|
// node_modules/element-plus/es/components/watermark/src/watermark.mjs
|
|
var watermarkProps = buildProps({
|
|
zIndex: {
|
|
type: Number,
|
|
default: 9
|
|
},
|
|
rotate: {
|
|
type: Number,
|
|
default: -22
|
|
},
|
|
width: Number,
|
|
height: Number,
|
|
image: String,
|
|
content: {
|
|
type: definePropType([String, Array]),
|
|
default: "Element Plus"
|
|
},
|
|
font: {
|
|
type: definePropType(Object)
|
|
},
|
|
gap: {
|
|
type: definePropType(Array),
|
|
default: () => [100, 100]
|
|
},
|
|
offset: {
|
|
type: definePropType(Array)
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/watermark/src/utils.mjs
|
|
function toLowercaseSeparator(key) {
|
|
return key.replace(/([A-Z])/g, "-$1").toLowerCase();
|
|
}
|
|
function getStyleStr(style) {
|
|
return Object.keys(style).map((key) => `${toLowercaseSeparator(key)}: ${style[key]};`).join(" ");
|
|
}
|
|
function getPixelRatio() {
|
|
return window.devicePixelRatio || 1;
|
|
}
|
|
var reRendering = (mutation, watermarkElement) => {
|
|
let flag = false;
|
|
if (mutation.removedNodes.length && watermarkElement) {
|
|
flag = Array.from(mutation.removedNodes).includes(watermarkElement);
|
|
}
|
|
if (mutation.type === "attributes" && mutation.target === watermarkElement) {
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/watermark/src/useClips.mjs
|
|
var FontGap = 3;
|
|
function prepareCanvas(width, height, ratio = 1) {
|
|
const canvas = document.createElement("canvas");
|
|
const ctx = canvas.getContext("2d");
|
|
const realWidth = width * ratio;
|
|
const realHeight = height * ratio;
|
|
canvas.setAttribute("width", `${realWidth}px`);
|
|
canvas.setAttribute("height", `${realHeight}px`);
|
|
ctx.save();
|
|
return [ctx, canvas, realWidth, realHeight];
|
|
}
|
|
function useClips() {
|
|
function getClips(content, rotate, ratio, width, height, font, gapX, gapY) {
|
|
const [ctx, canvas, contentWidth, contentHeight] = prepareCanvas(width, height, ratio);
|
|
if (content instanceof HTMLImageElement) {
|
|
ctx.drawImage(content, 0, 0, contentWidth, contentHeight);
|
|
} else {
|
|
const {
|
|
color,
|
|
fontSize,
|
|
fontStyle,
|
|
fontWeight,
|
|
fontFamily,
|
|
textAlign,
|
|
textBaseline
|
|
} = font;
|
|
const mergedFontSize = Number(fontSize) * ratio;
|
|
ctx.font = `${fontStyle} normal ${fontWeight} ${mergedFontSize}px/${height}px ${fontFamily}`;
|
|
ctx.fillStyle = color;
|
|
ctx.textAlign = textAlign;
|
|
ctx.textBaseline = textBaseline;
|
|
const contents = isArray(content) ? content : [content];
|
|
contents == null ? void 0 : contents.forEach((item, index) => {
|
|
ctx.fillText(item != null ? item : "", contentWidth / 2, index * (mergedFontSize + FontGap * ratio));
|
|
});
|
|
}
|
|
const angle = Math.PI / 180 * Number(rotate);
|
|
const maxSize = Math.max(width, height);
|
|
const [rCtx, rCanvas, realMaxSize] = prepareCanvas(maxSize, maxSize, ratio);
|
|
rCtx.translate(realMaxSize / 2, realMaxSize / 2);
|
|
rCtx.rotate(angle);
|
|
if (contentWidth > 0 && contentHeight > 0) {
|
|
rCtx.drawImage(canvas, -contentWidth / 2, -contentHeight / 2);
|
|
}
|
|
function getRotatePos(x2, y) {
|
|
const targetX = x2 * Math.cos(angle) - y * Math.sin(angle);
|
|
const targetY = x2 * Math.sin(angle) + y * Math.cos(angle);
|
|
return [targetX, targetY];
|
|
}
|
|
let left = 0;
|
|
let right = 0;
|
|
let top = 0;
|
|
let bottom = 0;
|
|
const halfWidth = contentWidth / 2;
|
|
const halfHeight = contentHeight / 2;
|
|
const points = [
|
|
[0 - halfWidth, 0 - halfHeight],
|
|
[0 + halfWidth, 0 - halfHeight],
|
|
[0 + halfWidth, 0 + halfHeight],
|
|
[0 - halfWidth, 0 + halfHeight]
|
|
];
|
|
points.forEach(([x2, y]) => {
|
|
const [targetX, targetY] = getRotatePos(x2, y);
|
|
left = Math.min(left, targetX);
|
|
right = Math.max(right, targetX);
|
|
top = Math.min(top, targetY);
|
|
bottom = Math.max(bottom, targetY);
|
|
});
|
|
const cutLeft = left + realMaxSize / 2;
|
|
const cutTop = top + realMaxSize / 2;
|
|
const cutWidth = right - left;
|
|
const cutHeight = bottom - top;
|
|
const realGapX = gapX * ratio;
|
|
const realGapY = gapY * ratio;
|
|
const filledWidth = (cutWidth + realGapX) * 2;
|
|
const filledHeight = cutHeight + realGapY;
|
|
const [fCtx, fCanvas] = prepareCanvas(filledWidth, filledHeight);
|
|
function drawImg(targetX = 0, targetY = 0) {
|
|
fCtx.drawImage(rCanvas, cutLeft, cutTop, cutWidth, cutHeight, targetX, targetY, cutWidth, cutHeight);
|
|
}
|
|
drawImg();
|
|
drawImg(cutWidth + realGapX, -cutHeight / 2 - realGapY / 2);
|
|
drawImg(cutWidth + realGapX, +cutHeight / 2 + realGapY / 2);
|
|
return [fCanvas.toDataURL(), filledWidth / ratio, filledHeight / ratio];
|
|
}
|
|
return getClips;
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/watermark/src/watermark2.mjs
|
|
var __default__104 = defineComponent({
|
|
name: "ElWatermark"
|
|
});
|
|
var _sfc_main144 = defineComponent({
|
|
...__default__104,
|
|
props: watermarkProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const style = {
|
|
position: "relative"
|
|
};
|
|
const color = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = props2.font) == null ? void 0 : _a2.color) != null ? _b : "rgba(0,0,0,.15)";
|
|
});
|
|
const fontSize = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = props2.font) == null ? void 0 : _a2.fontSize) != null ? _b : 16;
|
|
});
|
|
const fontWeight = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = props2.font) == null ? void 0 : _a2.fontWeight) != null ? _b : "normal";
|
|
});
|
|
const fontStyle = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = props2.font) == null ? void 0 : _a2.fontStyle) != null ? _b : "normal";
|
|
});
|
|
const fontFamily = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = props2.font) == null ? void 0 : _a2.fontFamily) != null ? _b : "sans-serif";
|
|
});
|
|
const textAlign = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = props2.font) == null ? void 0 : _a2.textAlign) != null ? _b : "center";
|
|
});
|
|
const textBaseline = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = props2.font) == null ? void 0 : _a2.textBaseline) != null ? _b : "hanging";
|
|
});
|
|
const gapX = computed(() => props2.gap[0]);
|
|
const gapY = computed(() => props2.gap[1]);
|
|
const gapXCenter = computed(() => gapX.value / 2);
|
|
const gapYCenter = computed(() => gapY.value / 2);
|
|
const offsetLeft = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = props2.offset) == null ? void 0 : _a2[0]) != null ? _b : gapXCenter.value;
|
|
});
|
|
const offsetTop = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = props2.offset) == null ? void 0 : _a2[1]) != null ? _b : gapYCenter.value;
|
|
});
|
|
const getMarkStyle = () => {
|
|
const markStyle = {
|
|
zIndex: props2.zIndex,
|
|
position: "absolute",
|
|
left: 0,
|
|
top: 0,
|
|
width: "100%",
|
|
height: "100%",
|
|
pointerEvents: "none",
|
|
backgroundRepeat: "repeat"
|
|
};
|
|
let positionLeft = offsetLeft.value - gapXCenter.value;
|
|
let positionTop = offsetTop.value - gapYCenter.value;
|
|
if (positionLeft > 0) {
|
|
markStyle.left = `${positionLeft}px`;
|
|
markStyle.width = `calc(100% - ${positionLeft}px)`;
|
|
positionLeft = 0;
|
|
}
|
|
if (positionTop > 0) {
|
|
markStyle.top = `${positionTop}px`;
|
|
markStyle.height = `calc(100% - ${positionTop}px)`;
|
|
positionTop = 0;
|
|
}
|
|
markStyle.backgroundPosition = `${positionLeft}px ${positionTop}px`;
|
|
return markStyle;
|
|
};
|
|
const containerRef = shallowRef(null);
|
|
const watermarkRef = shallowRef();
|
|
const stopObservation = ref(false);
|
|
const destroyWatermark = () => {
|
|
if (watermarkRef.value) {
|
|
watermarkRef.value.remove();
|
|
watermarkRef.value = void 0;
|
|
}
|
|
};
|
|
const appendWatermark = (base64Url, markWidth) => {
|
|
var _a2;
|
|
if (containerRef.value && watermarkRef.value) {
|
|
stopObservation.value = true;
|
|
watermarkRef.value.setAttribute("style", getStyleStr({
|
|
...getMarkStyle(),
|
|
backgroundImage: `url('${base64Url}')`,
|
|
backgroundSize: `${Math.floor(markWidth)}px`
|
|
}));
|
|
(_a2 = containerRef.value) == null ? void 0 : _a2.append(watermarkRef.value);
|
|
setTimeout(() => {
|
|
stopObservation.value = false;
|
|
});
|
|
}
|
|
};
|
|
const getMarkSize = (ctx) => {
|
|
let defaultWidth = 120;
|
|
let defaultHeight = 64;
|
|
const { image, content, width, height, rotate } = props2;
|
|
if (!image && ctx.measureText) {
|
|
ctx.font = `${Number(fontSize.value)}px ${fontFamily.value}`;
|
|
const contents = isArray(content) ? content : [content];
|
|
let maxWidth = 0;
|
|
let maxHeight = 0;
|
|
contents.forEach((item) => {
|
|
const {
|
|
width: width2,
|
|
fontBoundingBoxAscent,
|
|
fontBoundingBoxDescent,
|
|
actualBoundingBoxAscent,
|
|
actualBoundingBoxDescent
|
|
} = ctx.measureText(item);
|
|
const height2 = isUndefined2(fontBoundingBoxAscent) ? actualBoundingBoxAscent + actualBoundingBoxDescent : fontBoundingBoxAscent + fontBoundingBoxDescent;
|
|
if (width2 > maxWidth)
|
|
maxWidth = Math.ceil(width2);
|
|
if (height2 > maxHeight)
|
|
maxHeight = Math.ceil(height2);
|
|
});
|
|
defaultWidth = maxWidth;
|
|
defaultHeight = maxHeight * contents.length + (contents.length - 1) * FontGap;
|
|
const angle = Math.PI / 180 * Number(rotate);
|
|
const space = Math.ceil(Math.abs(Math.sin(angle) * defaultHeight) / 2);
|
|
defaultWidth += space;
|
|
}
|
|
return [width != null ? width : defaultWidth, height != null ? height : defaultHeight];
|
|
};
|
|
const getClips = useClips();
|
|
const renderWatermark = () => {
|
|
const canvas = document.createElement("canvas");
|
|
const ctx = canvas.getContext("2d");
|
|
const image = props2.image;
|
|
const content = props2.content;
|
|
const rotate = props2.rotate;
|
|
if (ctx) {
|
|
if (!watermarkRef.value) {
|
|
watermarkRef.value = document.createElement("div");
|
|
}
|
|
const ratio = getPixelRatio();
|
|
const [markWidth, markHeight] = getMarkSize(ctx);
|
|
const drawCanvas = (drawContent) => {
|
|
const [textClips, clipWidth] = getClips(drawContent || "", rotate, ratio, markWidth, markHeight, {
|
|
color: color.value,
|
|
fontSize: fontSize.value,
|
|
fontStyle: fontStyle.value,
|
|
fontWeight: fontWeight.value,
|
|
fontFamily: fontFamily.value,
|
|
textAlign: textAlign.value,
|
|
textBaseline: textBaseline.value
|
|
}, gapX.value, gapY.value);
|
|
appendWatermark(textClips, clipWidth);
|
|
};
|
|
if (image) {
|
|
const img = new Image();
|
|
img.onload = () => {
|
|
drawCanvas(img);
|
|
};
|
|
img.onerror = () => {
|
|
drawCanvas(content);
|
|
};
|
|
img.crossOrigin = "anonymous";
|
|
img.referrerPolicy = "no-referrer";
|
|
img.src = image;
|
|
} else {
|
|
drawCanvas(content);
|
|
}
|
|
}
|
|
};
|
|
onMounted(() => {
|
|
renderWatermark();
|
|
});
|
|
watch(() => props2, () => {
|
|
renderWatermark();
|
|
}, {
|
|
deep: true,
|
|
flush: "post"
|
|
});
|
|
onBeforeUnmount(() => {
|
|
destroyWatermark();
|
|
});
|
|
const onMutate = (mutations) => {
|
|
if (stopObservation.value) {
|
|
return;
|
|
}
|
|
mutations.forEach((mutation) => {
|
|
if (reRendering(mutation, watermarkRef.value)) {
|
|
destroyWatermark();
|
|
renderWatermark();
|
|
}
|
|
});
|
|
};
|
|
useMutationObserver(containerRef, onMutate, {
|
|
attributes: true,
|
|
subtree: true,
|
|
childList: true
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "containerRef",
|
|
ref: containerRef,
|
|
style: normalizeStyle([style])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 4);
|
|
};
|
|
}
|
|
});
|
|
var Watermark = _export_sfc(_sfc_main144, [["__file", "watermark.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/watermark/index.mjs
|
|
var ElWatermark = withInstall(Watermark);
|
|
|
|
// node_modules/element-plus/es/components/tour/src/content.mjs
|
|
var tourStrategies = ["absolute", "fixed"];
|
|
var tourPlacements = [
|
|
"top-start",
|
|
"top-end",
|
|
"top",
|
|
"bottom-start",
|
|
"bottom-end",
|
|
"bottom",
|
|
"left-start",
|
|
"left-end",
|
|
"left",
|
|
"right-start",
|
|
"right-end",
|
|
"right"
|
|
];
|
|
var tourContentProps = buildProps({
|
|
placement: {
|
|
type: definePropType(String),
|
|
values: tourPlacements,
|
|
default: "bottom"
|
|
},
|
|
reference: {
|
|
type: definePropType(Object),
|
|
default: null
|
|
},
|
|
strategy: {
|
|
type: definePropType(String),
|
|
values: tourStrategies,
|
|
default: "absolute"
|
|
},
|
|
offset: {
|
|
type: Number,
|
|
default: 10
|
|
},
|
|
showArrow: Boolean,
|
|
zIndex: {
|
|
type: Number,
|
|
default: 2001
|
|
}
|
|
});
|
|
var tourContentEmits = {
|
|
close: () => true
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/tour/src/tour.mjs
|
|
var tourProps = buildProps({
|
|
modelValue: Boolean,
|
|
current: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
showArrow: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
showClose: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
closeIcon: {
|
|
type: iconPropType
|
|
},
|
|
placement: tourContentProps.placement,
|
|
contentStyle: {
|
|
type: definePropType([Object])
|
|
},
|
|
mask: {
|
|
type: definePropType([Boolean, Object]),
|
|
default: true
|
|
},
|
|
gap: {
|
|
type: definePropType(Object),
|
|
default: () => ({
|
|
offset: 6,
|
|
radius: 2
|
|
})
|
|
},
|
|
zIndex: {
|
|
type: Number
|
|
},
|
|
scrollIntoViewOptions: {
|
|
type: definePropType([Boolean, Object]),
|
|
default: () => ({
|
|
block: "center"
|
|
})
|
|
},
|
|
type: {
|
|
type: definePropType(String)
|
|
},
|
|
appendTo: {
|
|
type: teleportProps.to.type,
|
|
default: "body"
|
|
},
|
|
closeOnPressEscape: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
targetAreaClickable: {
|
|
type: Boolean,
|
|
default: true
|
|
}
|
|
});
|
|
var tourEmits = {
|
|
[UPDATE_MODEL_EVENT]: (value) => isBoolean2(value),
|
|
["update:current"]: (current) => isNumber2(current),
|
|
close: (current) => isNumber2(current),
|
|
finish: () => true,
|
|
change: (current) => isNumber2(current)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/tour/src/step2.mjs
|
|
var tourStepProps = buildProps({
|
|
target: {
|
|
type: definePropType([String, Object, Function])
|
|
},
|
|
title: String,
|
|
description: String,
|
|
showClose: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
closeIcon: {
|
|
type: iconPropType
|
|
},
|
|
showArrow: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
placement: tourContentProps.placement,
|
|
mask: {
|
|
type: definePropType([Boolean, Object]),
|
|
default: void 0
|
|
},
|
|
contentStyle: {
|
|
type: definePropType([Object])
|
|
},
|
|
prevButtonProps: {
|
|
type: definePropType(Object)
|
|
},
|
|
nextButtonProps: {
|
|
type: definePropType(Object)
|
|
},
|
|
scrollIntoViewOptions: {
|
|
type: definePropType([Boolean, Object]),
|
|
default: void 0
|
|
},
|
|
type: {
|
|
type: definePropType(String)
|
|
}
|
|
});
|
|
var tourStepEmits = {
|
|
close: () => true
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/tour/src/mask.mjs
|
|
var maskProps = buildProps({
|
|
zIndex: {
|
|
type: Number,
|
|
default: 1001
|
|
},
|
|
visible: Boolean,
|
|
fill: {
|
|
type: String,
|
|
default: "rgba(0,0,0,0.5)"
|
|
},
|
|
pos: {
|
|
type: definePropType(Object)
|
|
},
|
|
targetAreaClickable: {
|
|
type: Boolean,
|
|
default: true
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tour/src/helper.mjs
|
|
var useTarget = (target2, open, gap, mergedMask, scrollIntoViewOptions) => {
|
|
const posInfo = ref(null);
|
|
const getTargetEl = () => {
|
|
let targetEl;
|
|
if (isString(target2.value)) {
|
|
targetEl = document.querySelector(target2.value);
|
|
} else if (isFunction(target2.value)) {
|
|
targetEl = target2.value();
|
|
} else {
|
|
targetEl = target2.value;
|
|
}
|
|
return targetEl;
|
|
};
|
|
const updatePosInfo = () => {
|
|
const targetEl = getTargetEl();
|
|
if (!targetEl || !open.value) {
|
|
posInfo.value = null;
|
|
return;
|
|
}
|
|
if (!isInViewPort(targetEl)) {
|
|
targetEl.scrollIntoView(scrollIntoViewOptions.value);
|
|
}
|
|
const { left, top, width, height } = targetEl.getBoundingClientRect();
|
|
posInfo.value = {
|
|
left,
|
|
top,
|
|
width,
|
|
height,
|
|
radius: 0
|
|
};
|
|
};
|
|
onMounted(() => {
|
|
watch([open, target2], () => {
|
|
updatePosInfo();
|
|
}, {
|
|
immediate: true
|
|
});
|
|
window.addEventListener("resize", updatePosInfo);
|
|
});
|
|
onBeforeUnmount(() => {
|
|
window.removeEventListener("resize", updatePosInfo);
|
|
});
|
|
const getGapOffset = (index) => {
|
|
var _a2;
|
|
return (_a2 = isArray(gap.value.offset) ? gap.value.offset[index] : gap.value.offset) != null ? _a2 : 6;
|
|
};
|
|
const mergedPosInfo = computed(() => {
|
|
var _a2;
|
|
if (!posInfo.value)
|
|
return posInfo.value;
|
|
const gapOffsetX = getGapOffset(0);
|
|
const gapOffsetY = getGapOffset(1);
|
|
const gapRadius = ((_a2 = gap.value) == null ? void 0 : _a2.radius) || 2;
|
|
return {
|
|
left: posInfo.value.left - gapOffsetX,
|
|
top: posInfo.value.top - gapOffsetY,
|
|
width: posInfo.value.width + gapOffsetX * 2,
|
|
height: posInfo.value.height + gapOffsetY * 2,
|
|
radius: gapRadius
|
|
};
|
|
});
|
|
const triggerTarget = computed(() => {
|
|
const targetEl = getTargetEl();
|
|
if (!mergedMask.value || !targetEl || !window.DOMRect) {
|
|
return targetEl || void 0;
|
|
}
|
|
return {
|
|
getBoundingClientRect() {
|
|
var _a2, _b, _c, _d;
|
|
return window.DOMRect.fromRect({
|
|
width: ((_a2 = mergedPosInfo.value) == null ? void 0 : _a2.width) || 0,
|
|
height: ((_b = mergedPosInfo.value) == null ? void 0 : _b.height) || 0,
|
|
x: ((_c = mergedPosInfo.value) == null ? void 0 : _c.left) || 0,
|
|
y: ((_d = mergedPosInfo.value) == null ? void 0 : _d.top) || 0
|
|
});
|
|
}
|
|
};
|
|
});
|
|
return {
|
|
mergedPosInfo,
|
|
triggerTarget
|
|
};
|
|
};
|
|
var tourKey = Symbol("ElTour");
|
|
function isInViewPort(element) {
|
|
const viewWidth = window.innerWidth || document.documentElement.clientWidth;
|
|
const viewHeight = window.innerHeight || document.documentElement.clientHeight;
|
|
const { top, right, bottom, left } = element.getBoundingClientRect();
|
|
return top >= 0 && left >= 0 && right <= viewWidth && bottom <= viewHeight;
|
|
}
|
|
var useFloating2 = (referenceRef, contentRef, arrowRef, placement, strategy, offset$1, zIndex2, showArrow) => {
|
|
const x2 = ref();
|
|
const y = ref();
|
|
const middlewareData = ref({});
|
|
const states = {
|
|
x: x2,
|
|
y,
|
|
placement,
|
|
strategy,
|
|
middlewareData
|
|
};
|
|
const middleware = computed(() => {
|
|
const _middleware = [
|
|
offset2(unref(offset$1)),
|
|
flip3(),
|
|
shift2(),
|
|
overflowMiddleware()
|
|
];
|
|
if (unref(showArrow) && unref(arrowRef)) {
|
|
_middleware.push(arrow2({
|
|
element: unref(arrowRef)
|
|
}));
|
|
}
|
|
return _middleware;
|
|
});
|
|
const update2 = async () => {
|
|
if (!isClient)
|
|
return;
|
|
const referenceEl = unref(referenceRef);
|
|
const contentEl = unref(contentRef);
|
|
if (!referenceEl || !contentEl)
|
|
return;
|
|
const data = await computePosition2(referenceEl, contentEl, {
|
|
placement: unref(placement),
|
|
strategy: unref(strategy),
|
|
middleware: unref(middleware)
|
|
});
|
|
keysOf(states).forEach((key) => {
|
|
states[key].value = data[key];
|
|
});
|
|
};
|
|
const contentStyle = computed(() => {
|
|
if (!unref(referenceRef)) {
|
|
return {
|
|
position: "fixed",
|
|
top: "50%",
|
|
left: "50%",
|
|
transform: "translate3d(-50%, -50%, 0)",
|
|
maxWidth: "100vw",
|
|
zIndex: unref(zIndex2)
|
|
};
|
|
}
|
|
const { overflow } = unref(middlewareData);
|
|
return {
|
|
position: unref(strategy),
|
|
zIndex: unref(zIndex2),
|
|
top: unref(y) != null ? `${unref(y)}px` : "",
|
|
left: unref(x2) != null ? `${unref(x2)}px` : "",
|
|
maxWidth: (overflow == null ? void 0 : overflow.maxWidth) ? `${overflow == null ? void 0 : overflow.maxWidth}px` : ""
|
|
};
|
|
});
|
|
const arrowStyle = computed(() => {
|
|
if (!unref(showArrow))
|
|
return {};
|
|
const { arrow: arrow22 } = unref(middlewareData);
|
|
return {
|
|
left: (arrow22 == null ? void 0 : arrow22.x) != null ? `${arrow22 == null ? void 0 : arrow22.x}px` : "",
|
|
top: (arrow22 == null ? void 0 : arrow22.y) != null ? `${arrow22 == null ? void 0 : arrow22.y}px` : ""
|
|
};
|
|
});
|
|
let cleanup;
|
|
onMounted(() => {
|
|
const referenceEl = unref(referenceRef);
|
|
const contentEl = unref(contentRef);
|
|
if (referenceEl && contentEl) {
|
|
cleanup = autoUpdate(referenceEl, contentEl, update2);
|
|
}
|
|
watchEffect(() => {
|
|
update2();
|
|
});
|
|
});
|
|
onBeforeUnmount(() => {
|
|
cleanup && cleanup();
|
|
});
|
|
return {
|
|
update: update2,
|
|
contentStyle,
|
|
arrowStyle
|
|
};
|
|
};
|
|
var overflowMiddleware = () => {
|
|
return {
|
|
name: "overflow",
|
|
async fn(state) {
|
|
const overflow = await detectOverflow2(state);
|
|
let overWidth = 0;
|
|
if (overflow.left > 0)
|
|
overWidth = overflow.left;
|
|
if (overflow.right > 0)
|
|
overWidth = overflow.right;
|
|
const floatingWidth = state.rects.floating.width;
|
|
return {
|
|
data: {
|
|
maxWidth: floatingWidth - overWidth
|
|
}
|
|
};
|
|
}
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/tour/src/mask2.mjs
|
|
var __default__105 = defineComponent({
|
|
name: "ElTourMask",
|
|
inheritAttrs: false
|
|
});
|
|
var _sfc_main145 = defineComponent({
|
|
...__default__105,
|
|
props: maskProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const { ns } = inject(tourKey);
|
|
const radius = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = props2.pos) == null ? void 0 : _a2.radius) != null ? _b : 2;
|
|
});
|
|
const roundInfo = computed(() => {
|
|
const v2 = radius.value;
|
|
const baseInfo = `a${v2},${v2} 0 0 1`;
|
|
return {
|
|
topRight: `${baseInfo} ${v2},${v2}`,
|
|
bottomRight: `${baseInfo} ${-v2},${v2}`,
|
|
bottomLeft: `${baseInfo} ${-v2},${-v2}`,
|
|
topLeft: `${baseInfo} ${v2},${-v2}`
|
|
};
|
|
});
|
|
const path = computed(() => {
|
|
const width = window.innerWidth;
|
|
const height = window.innerHeight;
|
|
const info = roundInfo.value;
|
|
const _path = `M${width},0 L0,0 L0,${height} L${width},${height} L${width},0 Z`;
|
|
const _radius = radius.value;
|
|
return props2.pos ? `${_path} M${props2.pos.left + _radius},${props2.pos.top} h${props2.pos.width - _radius * 2} ${info.topRight} v${props2.pos.height - _radius * 2} ${info.bottomRight} h${-props2.pos.width + _radius * 2} ${info.bottomLeft} v${-props2.pos.height + _radius * 2} ${info.topLeft} z` : _path;
|
|
});
|
|
const pathStyle = computed(() => {
|
|
return {
|
|
fill: props2.fill,
|
|
pointerEvents: "auto",
|
|
cursor: "auto"
|
|
};
|
|
});
|
|
useLockscreen(toRef(props2, "visible"), {
|
|
ns
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return _ctx.visible ? (openBlock(), createElementBlock("div", mergeProps({
|
|
key: 0,
|
|
class: unref(ns).e("mask"),
|
|
style: {
|
|
position: "fixed",
|
|
left: 0,
|
|
right: 0,
|
|
top: 0,
|
|
bottom: 0,
|
|
zIndex: _ctx.zIndex,
|
|
pointerEvents: _ctx.pos && _ctx.targetAreaClickable ? "none" : "auto"
|
|
}
|
|
}, _ctx.$attrs), [
|
|
(openBlock(), createElementBlock("svg", { style: {
|
|
width: "100%",
|
|
height: "100%"
|
|
} }, [
|
|
createBaseVNode("path", {
|
|
class: normalizeClass(unref(ns).e("hollow")),
|
|
style: normalizeStyle(unref(pathStyle)),
|
|
d: unref(path)
|
|
}, null, 14, ["d"])
|
|
]))
|
|
], 16)) : createCommentVNode("v-if", true);
|
|
};
|
|
}
|
|
});
|
|
var ElTourMask = _export_sfc(_sfc_main145, [["__file", "mask.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tour/src/content2.mjs
|
|
var __default__106 = defineComponent({
|
|
name: "ElTourContent"
|
|
});
|
|
var _sfc_main146 = defineComponent({
|
|
...__default__106,
|
|
props: tourContentProps,
|
|
emits: tourContentEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const placement = ref(props2.placement);
|
|
const strategy = ref(props2.strategy);
|
|
const contentRef = ref(null);
|
|
const arrowRef = ref(null);
|
|
watch(() => props2.placement, () => {
|
|
placement.value = props2.placement;
|
|
});
|
|
const { contentStyle, arrowStyle } = useFloating2(toRef(props2, "reference"), contentRef, arrowRef, placement, strategy, toRef(props2, "offset"), toRef(props2, "zIndex"), toRef(props2, "showArrow"));
|
|
const side = computed(() => {
|
|
return placement.value.split("-")[0];
|
|
});
|
|
const { ns } = inject(tourKey);
|
|
const onCloseRequested = () => {
|
|
emit("close");
|
|
};
|
|
const onFocusoutPrevented = (event) => {
|
|
if (event.detail.focusReason === "pointer") {
|
|
event.preventDefault();
|
|
}
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "contentRef",
|
|
ref: contentRef,
|
|
style: normalizeStyle(unref(contentStyle)),
|
|
class: normalizeClass(unref(ns).e("content")),
|
|
"data-side": unref(side),
|
|
tabindex: "-1"
|
|
}, [
|
|
createVNode(unref(ElFocusTrap), {
|
|
loop: "",
|
|
trapped: "",
|
|
"focus-start-el": "container",
|
|
"focus-trap-el": contentRef.value || void 0,
|
|
onReleaseRequested: onCloseRequested,
|
|
onFocusoutPrevented
|
|
}, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 8, ["focus-trap-el"]),
|
|
_ctx.showArrow ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
ref_key: "arrowRef",
|
|
ref: arrowRef,
|
|
style: normalizeStyle(unref(arrowStyle)),
|
|
class: normalizeClass(unref(ns).e("arrow"))
|
|
}, null, 6)) : createCommentVNode("v-if", true)
|
|
], 14, ["data-side"]);
|
|
};
|
|
}
|
|
});
|
|
var ElTourContent = _export_sfc(_sfc_main146, [["__file", "content.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tour/src/steps.mjs
|
|
var ElTourSteps = defineComponent({
|
|
name: "ElTourSteps",
|
|
props: {
|
|
current: {
|
|
type: Number,
|
|
default: 0
|
|
}
|
|
},
|
|
emits: ["update-total"],
|
|
setup(props2, { slots, emit }) {
|
|
let cacheTotal = 0;
|
|
return () => {
|
|
var _a2, _b;
|
|
const children = (_a2 = slots.default) == null ? void 0 : _a2.call(slots);
|
|
const result2 = [];
|
|
let total2 = 0;
|
|
function filterSteps(children2) {
|
|
if (!isArray(children2))
|
|
return;
|
|
children2.forEach((item) => {
|
|
var _a22;
|
|
const name = (_a22 = (item == null ? void 0 : item.type) || {}) == null ? void 0 : _a22.name;
|
|
if (name === "ElTourStep") {
|
|
result2.push(item);
|
|
total2 += 1;
|
|
}
|
|
});
|
|
}
|
|
if (children.length) {
|
|
filterSteps(flattedChildren((_b = children[0]) == null ? void 0 : _b.children));
|
|
}
|
|
if (cacheTotal !== total2) {
|
|
cacheTotal = total2;
|
|
emit("update-total", total2);
|
|
}
|
|
if (result2.length) {
|
|
return result2[props2.current];
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tour/src/tour2.mjs
|
|
var __default__107 = defineComponent({
|
|
name: "ElTour"
|
|
});
|
|
var _sfc_main147 = defineComponent({
|
|
...__default__107,
|
|
props: tourProps,
|
|
emits: tourEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("tour");
|
|
const total2 = ref(0);
|
|
const currentStep = ref();
|
|
const current = useVModel(props2, "current", emit, {
|
|
passive: true
|
|
});
|
|
const currentTarget = computed(() => {
|
|
var _a2;
|
|
return (_a2 = currentStep.value) == null ? void 0 : _a2.target;
|
|
});
|
|
const kls = computed(() => [
|
|
ns.b(),
|
|
mergedType.value === "primary" ? ns.m("primary") : ""
|
|
]);
|
|
const mergedPlacement = computed(() => {
|
|
var _a2;
|
|
return ((_a2 = currentStep.value) == null ? void 0 : _a2.placement) || props2.placement;
|
|
});
|
|
const mergedContentStyle = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = currentStep.value) == null ? void 0 : _a2.contentStyle) != null ? _b : props2.contentStyle;
|
|
});
|
|
const mergedMask = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = currentStep.value) == null ? void 0 : _a2.mask) != null ? _b : props2.mask;
|
|
});
|
|
const mergedShowMask = computed(() => !!mergedMask.value && props2.modelValue);
|
|
const mergedMaskStyle = computed(() => isBoolean2(mergedMask.value) ? void 0 : mergedMask.value);
|
|
const mergedShowArrow = computed(() => {
|
|
var _a2, _b;
|
|
return !!currentTarget.value && ((_b = (_a2 = currentStep.value) == null ? void 0 : _a2.showArrow) != null ? _b : props2.showArrow);
|
|
});
|
|
const mergedScrollIntoViewOptions = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = currentStep.value) == null ? void 0 : _a2.scrollIntoViewOptions) != null ? _b : props2.scrollIntoViewOptions;
|
|
});
|
|
const mergedType = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = currentStep.value) == null ? void 0 : _a2.type) != null ? _b : props2.type;
|
|
});
|
|
const { nextZIndex } = useZIndex();
|
|
const nowZIndex = nextZIndex();
|
|
const mergedZIndex = computed(() => {
|
|
var _a2;
|
|
return (_a2 = props2.zIndex) != null ? _a2 : nowZIndex;
|
|
});
|
|
const { mergedPosInfo: pos, triggerTarget } = useTarget(currentTarget, toRef(props2, "modelValue"), toRef(props2, "gap"), mergedMask, mergedScrollIntoViewOptions);
|
|
watch(() => props2.modelValue, (val) => {
|
|
if (!val) {
|
|
current.value = 0;
|
|
}
|
|
});
|
|
const onEscClose = () => {
|
|
if (props2.closeOnPressEscape) {
|
|
emit(UPDATE_MODEL_EVENT, false);
|
|
emit("close", current.value);
|
|
}
|
|
};
|
|
const onUpdateTotal = (val) => {
|
|
total2.value = val;
|
|
};
|
|
const slots = useSlots();
|
|
provide(tourKey, {
|
|
currentStep,
|
|
current,
|
|
total: total2,
|
|
showClose: toRef(props2, "showClose"),
|
|
closeIcon: toRef(props2, "closeIcon"),
|
|
mergedType,
|
|
ns,
|
|
slots,
|
|
updateModelValue(modelValue) {
|
|
emit(UPDATE_MODEL_EVENT, modelValue);
|
|
},
|
|
onClose() {
|
|
emit("close", current.value);
|
|
},
|
|
onFinish() {
|
|
emit("finish");
|
|
},
|
|
onChange() {
|
|
emit(CHANGE_EVENT, current.value);
|
|
}
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock(Fragment, null, [
|
|
createVNode(unref(ElTeleport), { to: _ctx.appendTo }, {
|
|
default: withCtx(() => {
|
|
var _a2, _b;
|
|
return [
|
|
createBaseVNode("div", mergeProps({ class: unref(kls) }, _ctx.$attrs), [
|
|
createVNode(ElTourMask, {
|
|
visible: unref(mergedShowMask),
|
|
fill: (_a2 = unref(mergedMaskStyle)) == null ? void 0 : _a2.color,
|
|
style: normalizeStyle((_b = unref(mergedMaskStyle)) == null ? void 0 : _b.style),
|
|
pos: unref(pos),
|
|
"z-index": unref(mergedZIndex),
|
|
"target-area-clickable": _ctx.targetAreaClickable
|
|
}, null, 8, ["visible", "fill", "style", "pos", "z-index", "target-area-clickable"]),
|
|
_ctx.modelValue ? (openBlock(), createBlock(ElTourContent, {
|
|
key: unref(current),
|
|
reference: unref(triggerTarget),
|
|
placement: unref(mergedPlacement),
|
|
"show-arrow": unref(mergedShowArrow),
|
|
"z-index": unref(mergedZIndex),
|
|
style: normalizeStyle(unref(mergedContentStyle)),
|
|
onClose: onEscClose
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(ElTourSteps), {
|
|
current: unref(current),
|
|
onUpdateTotal
|
|
}, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 8, ["current"])
|
|
]),
|
|
_: 3
|
|
}, 8, ["reference", "placement", "show-arrow", "z-index", "style"])) : createCommentVNode("v-if", true)
|
|
], 16)
|
|
];
|
|
}),
|
|
_: 3
|
|
}, 8, ["to"]),
|
|
createCommentVNode(" just for IDE "),
|
|
createCommentVNode("v-if", true)
|
|
], 64);
|
|
};
|
|
}
|
|
});
|
|
var Tour = _export_sfc(_sfc_main147, [["__file", "tour.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tour/src/step.mjs
|
|
var __default__108 = defineComponent({
|
|
name: "ElTourStep"
|
|
});
|
|
var _sfc_main148 = defineComponent({
|
|
...__default__108,
|
|
props: tourStepProps,
|
|
emits: tourStepEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const { Close } = CloseComponents;
|
|
const { t } = useLocale();
|
|
const {
|
|
currentStep,
|
|
current,
|
|
total: total2,
|
|
showClose,
|
|
closeIcon,
|
|
mergedType,
|
|
ns,
|
|
slots: tourSlots,
|
|
updateModelValue,
|
|
onClose: tourOnClose,
|
|
onFinish: tourOnFinish,
|
|
onChange
|
|
} = inject(tourKey);
|
|
watch(props2, (val) => {
|
|
currentStep.value = val;
|
|
}, {
|
|
immediate: true
|
|
});
|
|
const mergedShowClose = computed(() => {
|
|
var _a2;
|
|
return (_a2 = props2.showClose) != null ? _a2 : showClose.value;
|
|
});
|
|
const mergedCloseIcon = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = props2.closeIcon) != null ? _a2 : closeIcon.value) != null ? _b : Close;
|
|
});
|
|
const filterButtonProps = (btnProps) => {
|
|
if (!btnProps)
|
|
return;
|
|
return omit_default(btnProps, ["children", "onClick"]);
|
|
};
|
|
const onPrev = () => {
|
|
var _a2, _b;
|
|
current.value -= 1;
|
|
if ((_a2 = props2.prevButtonProps) == null ? void 0 : _a2.onClick) {
|
|
(_b = props2.prevButtonProps) == null ? void 0 : _b.onClick();
|
|
}
|
|
onChange();
|
|
};
|
|
const onNext = () => {
|
|
var _a2;
|
|
if (current.value >= total2.value - 1) {
|
|
onFinish();
|
|
} else {
|
|
current.value += 1;
|
|
}
|
|
if ((_a2 = props2.nextButtonProps) == null ? void 0 : _a2.onClick) {
|
|
props2.nextButtonProps.onClick();
|
|
}
|
|
onChange();
|
|
};
|
|
const onFinish = () => {
|
|
onClose();
|
|
tourOnFinish();
|
|
};
|
|
const onClose = () => {
|
|
updateModelValue(false);
|
|
tourOnClose();
|
|
emit("close");
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock(Fragment, null, [
|
|
unref(mergedShowClose) ? (openBlock(), createElementBlock("button", {
|
|
key: 0,
|
|
"aria-label": "Close",
|
|
class: normalizeClass(unref(ns).e("closebtn")),
|
|
type: "button",
|
|
onClick: onClose
|
|
}, [
|
|
createVNode(unref(ElIcon), {
|
|
class: normalizeClass(unref(ns).e("close"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(unref(mergedCloseIcon))))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("header", {
|
|
class: normalizeClass([unref(ns).e("header"), { "show-close": unref(showClose) }])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "header", {}, () => [
|
|
createBaseVNode("span", {
|
|
role: "heading",
|
|
class: normalizeClass(unref(ns).e("title"))
|
|
}, toDisplayString(_ctx.title), 3)
|
|
])
|
|
], 2),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("body"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default", {}, () => [
|
|
createBaseVNode("span", null, toDisplayString(_ctx.description), 1)
|
|
])
|
|
], 2),
|
|
createBaseVNode("footer", {
|
|
class: normalizeClass(unref(ns).e("footer"))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).b("indicators"))
|
|
}, [
|
|
unref(tourSlots).indicators ? (openBlock(), createBlock(resolveDynamicComponent(unref(tourSlots).indicators), {
|
|
key: 0,
|
|
current: unref(current),
|
|
total: unref(total2)
|
|
}, null, 8, ["current", "total"])) : (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(unref(total2), (item, index) => {
|
|
return openBlock(), createElementBlock("span", {
|
|
key: item,
|
|
class: normalizeClass([unref(ns).b("indicator"), index === unref(current) ? "is-active" : ""])
|
|
}, null, 2);
|
|
}), 128))
|
|
], 2),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).b("buttons"))
|
|
}, [
|
|
unref(current) > 0 ? (openBlock(), createBlock(unref(ElButton), mergeProps({
|
|
key: 0,
|
|
size: "small",
|
|
type: unref(mergedType)
|
|
}, filterButtonProps(_ctx.prevButtonProps), { onClick: onPrev }), {
|
|
default: withCtx(() => {
|
|
var _a2, _b;
|
|
return [
|
|
createTextVNode(toDisplayString((_b = (_a2 = _ctx.prevButtonProps) == null ? void 0 : _a2.children) != null ? _b : unref(t)("el.tour.previous")), 1)
|
|
];
|
|
}),
|
|
_: 1
|
|
}, 16, ["type"])) : createCommentVNode("v-if", true),
|
|
unref(current) <= unref(total2) - 1 ? (openBlock(), createBlock(unref(ElButton), mergeProps({
|
|
key: 1,
|
|
size: "small",
|
|
type: unref(mergedType) === "primary" ? "default" : "primary"
|
|
}, filterButtonProps(_ctx.nextButtonProps), { onClick: onNext }), {
|
|
default: withCtx(() => {
|
|
var _a2, _b;
|
|
return [
|
|
createTextVNode(toDisplayString((_b = (_a2 = _ctx.nextButtonProps) == null ? void 0 : _a2.children) != null ? _b : unref(current) === unref(total2) - 1 ? unref(t)("el.tour.finish") : unref(t)("el.tour.next")), 1)
|
|
];
|
|
}),
|
|
_: 1
|
|
}, 16, ["type"])) : createCommentVNode("v-if", true)
|
|
], 2)
|
|
], 2)
|
|
], 64);
|
|
};
|
|
}
|
|
});
|
|
var TourStep = _export_sfc(_sfc_main148, [["__file", "step.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tour/index.mjs
|
|
var ElTour = withInstall(Tour, {
|
|
TourStep
|
|
});
|
|
var ElTourStep = withNoopInstall(TourStep);
|
|
|
|
// node_modules/element-plus/es/components/anchor/src/anchor.mjs
|
|
var anchorProps = buildProps({
|
|
container: {
|
|
type: definePropType([
|
|
String,
|
|
Object
|
|
])
|
|
},
|
|
offset: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
bound: {
|
|
type: Number,
|
|
default: 15
|
|
},
|
|
duration: {
|
|
type: Number,
|
|
default: 300
|
|
},
|
|
marker: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
type: {
|
|
type: definePropType(String),
|
|
default: "default"
|
|
},
|
|
direction: {
|
|
type: definePropType(String),
|
|
default: "vertical"
|
|
},
|
|
selectScrollTop: {
|
|
type: Boolean,
|
|
default: false
|
|
}
|
|
});
|
|
var anchorEmits = {
|
|
change: (href) => isString(href),
|
|
click: (e, href) => e instanceof MouseEvent && (isString(href) || isUndefined2(href))
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/anchor/src/constants.mjs
|
|
var anchorKey = Symbol("anchor");
|
|
|
|
// node_modules/element-plus/es/utils/dom/element.mjs
|
|
var getElement = (target2) => {
|
|
if (!isClient || target2 === "")
|
|
return null;
|
|
if (isString(target2)) {
|
|
try {
|
|
return document.querySelector(target2);
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
}
|
|
return target2;
|
|
};
|
|
|
|
// node_modules/element-plus/es/utils/throttleByRaf.mjs
|
|
function throttleByRaf(cb) {
|
|
let timer = 0;
|
|
const throttle2 = (...args) => {
|
|
if (timer) {
|
|
cAF(timer);
|
|
}
|
|
timer = rAF(() => {
|
|
cb(...args);
|
|
timer = 0;
|
|
});
|
|
};
|
|
throttle2.cancel = () => {
|
|
cAF(timer);
|
|
timer = 0;
|
|
};
|
|
return throttle2;
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/anchor/src/anchor2.mjs
|
|
var __default__109 = defineComponent({
|
|
name: "ElAnchor"
|
|
});
|
|
var _sfc_main149 = defineComponent({
|
|
...__default__109,
|
|
props: anchorProps,
|
|
emits: anchorEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const currentAnchor = ref("");
|
|
const anchorRef = ref(null);
|
|
const markerRef = ref(null);
|
|
const containerEl = ref();
|
|
const links = {};
|
|
let isScrolling = false;
|
|
let currentScrollTop = 0;
|
|
const ns = useNamespace("anchor");
|
|
const cls = computed(() => [
|
|
ns.b(),
|
|
props2.type === "underline" ? ns.m("underline") : "",
|
|
ns.m(props2.direction)
|
|
]);
|
|
const addLink = (state) => {
|
|
links[state.href] = state.el;
|
|
};
|
|
const removeLink = (href) => {
|
|
delete links[href];
|
|
};
|
|
const setCurrentAnchor = (href) => {
|
|
const activeHref = currentAnchor.value;
|
|
if (activeHref !== href) {
|
|
currentAnchor.value = href;
|
|
emit(CHANGE_EVENT, href);
|
|
}
|
|
};
|
|
let clearAnimate = null;
|
|
const scrollToAnchor = (href) => {
|
|
if (!containerEl.value)
|
|
return;
|
|
const target2 = getElement(href);
|
|
if (!target2)
|
|
return;
|
|
if (clearAnimate)
|
|
clearAnimate();
|
|
isScrolling = true;
|
|
const scrollEle = getScrollElement(target2, containerEl.value);
|
|
const distance = getOffsetTopDistance(target2, scrollEle);
|
|
const max4 = scrollEle.scrollHeight - scrollEle.clientHeight;
|
|
const to = Math.min(distance - props2.offset, max4);
|
|
clearAnimate = animateScrollTo(containerEl.value, currentScrollTop, to, props2.duration, () => {
|
|
setTimeout(() => {
|
|
isScrolling = false;
|
|
}, 20);
|
|
});
|
|
};
|
|
const scrollTo = (href) => {
|
|
if (href) {
|
|
setCurrentAnchor(href);
|
|
scrollToAnchor(href);
|
|
}
|
|
};
|
|
const handleClick = (e, href) => {
|
|
emit("click", e, href);
|
|
scrollTo(href);
|
|
};
|
|
const handleScroll2 = throttleByRaf(() => {
|
|
if (containerEl.value) {
|
|
currentScrollTop = getScrollTop(containerEl.value);
|
|
}
|
|
const currentHref = getCurrentHref();
|
|
if (isScrolling || isUndefined2(currentHref))
|
|
return;
|
|
setCurrentAnchor(currentHref);
|
|
});
|
|
const getCurrentHref = () => {
|
|
if (!containerEl.value)
|
|
return;
|
|
const scrollTop = getScrollTop(containerEl.value);
|
|
const anchorTopList = [];
|
|
for (const href of Object.keys(links)) {
|
|
const target2 = getElement(href);
|
|
if (!target2)
|
|
continue;
|
|
const scrollEle = getScrollElement(target2, containerEl.value);
|
|
const distance = getOffsetTopDistance(target2, scrollEle);
|
|
anchorTopList.push({
|
|
top: distance - props2.offset - props2.bound,
|
|
href
|
|
});
|
|
}
|
|
anchorTopList.sort((prev, next) => prev.top - next.top);
|
|
for (let i = 0; i < anchorTopList.length; i++) {
|
|
const item = anchorTopList[i];
|
|
const next = anchorTopList[i + 1];
|
|
if (i === 0 && scrollTop === 0) {
|
|
return props2.selectScrollTop ? item.href : "";
|
|
}
|
|
if (item.top <= scrollTop && (!next || next.top > scrollTop)) {
|
|
return item.href;
|
|
}
|
|
}
|
|
};
|
|
const getContainer = () => {
|
|
const el = getElement(props2.container);
|
|
if (!el || isWindow(el)) {
|
|
containerEl.value = window;
|
|
} else {
|
|
containerEl.value = el;
|
|
}
|
|
};
|
|
useEventListener(containerEl, "scroll", handleScroll2);
|
|
const markerStyle = computed(() => {
|
|
if (!anchorRef.value || !markerRef.value || !currentAnchor.value)
|
|
return {};
|
|
const currentLinkEl = links[currentAnchor.value];
|
|
if (!currentLinkEl)
|
|
return {};
|
|
const anchorRect = anchorRef.value.getBoundingClientRect();
|
|
const markerRect = markerRef.value.getBoundingClientRect();
|
|
const linkRect = currentLinkEl.getBoundingClientRect();
|
|
if (props2.direction === "horizontal") {
|
|
const left = linkRect.left - anchorRect.left;
|
|
return {
|
|
left: `${left}px`,
|
|
width: `${linkRect.width}px`,
|
|
opacity: 1
|
|
};
|
|
} else {
|
|
const top = linkRect.top - anchorRect.top + (linkRect.height - markerRect.height) / 2;
|
|
return {
|
|
top: `${top}px`,
|
|
opacity: 1
|
|
};
|
|
}
|
|
});
|
|
onMounted(() => {
|
|
getContainer();
|
|
const hash = decodeURIComponent(window.location.hash);
|
|
const target2 = getElement(hash);
|
|
if (target2) {
|
|
scrollTo(hash);
|
|
} else {
|
|
handleScroll2();
|
|
}
|
|
});
|
|
watch(() => props2.container, () => {
|
|
getContainer();
|
|
});
|
|
provide(anchorKey, {
|
|
ns,
|
|
direction: props2.direction,
|
|
currentAnchor,
|
|
addLink,
|
|
removeLink,
|
|
handleClick
|
|
});
|
|
expose({
|
|
scrollTo
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "anchorRef",
|
|
ref: anchorRef,
|
|
class: normalizeClass(unref(cls))
|
|
}, [
|
|
_ctx.marker ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
ref_key: "markerRef",
|
|
ref: markerRef,
|
|
class: normalizeClass(unref(ns).e("marker")),
|
|
style: normalizeStyle(unref(markerStyle))
|
|
}, null, 6)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("list"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 2)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Anchor = _export_sfc(_sfc_main149, [["__file", "anchor.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/anchor/src/anchor-link.mjs
|
|
var anchorLinkProps = buildProps({
|
|
title: String,
|
|
href: String
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/anchor/src/anchor-link2.mjs
|
|
var __default__110 = defineComponent({
|
|
name: "ElAnchorLink"
|
|
});
|
|
var _sfc_main150 = defineComponent({
|
|
...__default__110,
|
|
props: anchorLinkProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const linkRef = ref(null);
|
|
const {
|
|
ns,
|
|
direction: direction2,
|
|
currentAnchor,
|
|
addLink,
|
|
removeLink,
|
|
handleClick: contextHandleClick
|
|
} = inject(anchorKey);
|
|
const cls = computed(() => [
|
|
ns.e("link"),
|
|
ns.is("active", currentAnchor.value === props2.href)
|
|
]);
|
|
const handleClick = (e) => {
|
|
contextHandleClick(e, props2.href);
|
|
};
|
|
watch(() => props2.href, (val, oldVal) => {
|
|
nextTick(() => {
|
|
if (oldVal)
|
|
removeLink(oldVal);
|
|
if (val) {
|
|
addLink({
|
|
href: val,
|
|
el: linkRef.value
|
|
});
|
|
}
|
|
});
|
|
});
|
|
onMounted(() => {
|
|
const { href } = props2;
|
|
if (href) {
|
|
addLink({
|
|
href,
|
|
el: linkRef.value
|
|
});
|
|
}
|
|
});
|
|
onBeforeUnmount(() => {
|
|
const { href } = props2;
|
|
if (href) {
|
|
removeLink(href);
|
|
}
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(unref(ns).e("item"))
|
|
}, [
|
|
createBaseVNode("a", {
|
|
ref_key: "linkRef",
|
|
ref: linkRef,
|
|
class: normalizeClass(unref(cls)),
|
|
href: _ctx.href,
|
|
onClick: handleClick
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default", {}, () => [
|
|
createTextVNode(toDisplayString(_ctx.title), 1)
|
|
])
|
|
], 10, ["href"]),
|
|
_ctx.$slots["sub-link"] && unref(direction2) === "vertical" ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("list"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "sub-link")
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var AnchorLink = _export_sfc(_sfc_main150, [["__file", "anchor-link.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/anchor/index.mjs
|
|
var ElAnchor = withInstall(Anchor, {
|
|
AnchorLink
|
|
});
|
|
var ElAnchorLink = withNoopInstall(AnchorLink);
|
|
|
|
// node_modules/element-plus/es/components/segmented/src/segmented.mjs
|
|
var defaultProps5 = {
|
|
label: "label",
|
|
value: "value",
|
|
disabled: "disabled"
|
|
};
|
|
var segmentedProps = buildProps({
|
|
direction: {
|
|
type: definePropType(String),
|
|
default: "horizontal"
|
|
},
|
|
options: {
|
|
type: definePropType(Array),
|
|
default: () => []
|
|
},
|
|
modelValue: {
|
|
type: [String, Number, Boolean],
|
|
default: void 0
|
|
},
|
|
props: {
|
|
type: definePropType(Object),
|
|
default: () => defaultProps5
|
|
},
|
|
block: Boolean,
|
|
size: useSizeProp,
|
|
disabled: Boolean,
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
id: String,
|
|
name: String,
|
|
...useAriaProps(["ariaLabel"])
|
|
});
|
|
var segmentedEmits = {
|
|
[UPDATE_MODEL_EVENT]: (val) => isString(val) || isNumber2(val) || isBoolean2(val),
|
|
[CHANGE_EVENT]: (val) => isString(val) || isNumber2(val) || isBoolean2(val)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/segmented/src/segmented2.mjs
|
|
var __default__111 = defineComponent({
|
|
name: "ElSegmented"
|
|
});
|
|
var _sfc_main151 = defineComponent({
|
|
...__default__111,
|
|
props: segmentedProps,
|
|
emits: segmentedEmits,
|
|
setup(__props, { emit }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("segmented");
|
|
const segmentedId = useId();
|
|
const segmentedSize = useFormSize();
|
|
const _disabled = useFormDisabled();
|
|
const { formItem } = useFormItem();
|
|
const { inputId, isLabeledByFormItem } = useFormItemInputId(props2, {
|
|
formItemContext: formItem
|
|
});
|
|
const segmentedRef = ref(null);
|
|
const activeElement = useActiveElement();
|
|
const state = reactive({
|
|
isInit: false,
|
|
width: 0,
|
|
height: 0,
|
|
translateX: 0,
|
|
translateY: 0,
|
|
focusVisible: false
|
|
});
|
|
const handleChange = (item) => {
|
|
const value = getValue3(item);
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emit(CHANGE_EVENT, value);
|
|
};
|
|
const aliasProps = computed(() => ({ ...defaultProps5, ...props2.props }));
|
|
const getValue3 = (item) => {
|
|
return isObject(item) ? item[aliasProps.value.value] : item;
|
|
};
|
|
const getLabel = (item) => {
|
|
return isObject(item) ? item[aliasProps.value.label] : item;
|
|
};
|
|
const getDisabled = (item) => {
|
|
return !!(_disabled.value || (isObject(item) ? item[aliasProps.value.disabled] : false));
|
|
};
|
|
const getSelected = (item) => {
|
|
return props2.modelValue === getValue3(item);
|
|
};
|
|
const getOption = (value) => {
|
|
return props2.options.find((item) => getValue3(item) === value);
|
|
};
|
|
const getItemCls = (item) => {
|
|
return [
|
|
ns.e("item"),
|
|
ns.is("selected", getSelected(item)),
|
|
ns.is("disabled", getDisabled(item))
|
|
];
|
|
};
|
|
const updateSelect = () => {
|
|
if (!segmentedRef.value)
|
|
return;
|
|
const selectedItem = segmentedRef.value.querySelector(".is-selected");
|
|
const selectedItemInput = segmentedRef.value.querySelector(".is-selected input");
|
|
if (!selectedItem || !selectedItemInput) {
|
|
state.width = 0;
|
|
state.height = 0;
|
|
state.translateX = 0;
|
|
state.translateY = 0;
|
|
state.focusVisible = false;
|
|
return;
|
|
}
|
|
const rect = selectedItem.getBoundingClientRect();
|
|
state.isInit = true;
|
|
if (props2.direction === "vertical") {
|
|
state.height = rect.height;
|
|
state.translateY = selectedItem.offsetTop;
|
|
} else {
|
|
state.width = rect.width;
|
|
state.translateX = selectedItem.offsetLeft;
|
|
}
|
|
try {
|
|
state.focusVisible = selectedItemInput.matches(":focus-visible");
|
|
} catch (e) {
|
|
}
|
|
};
|
|
const segmentedCls = computed(() => [
|
|
ns.b(),
|
|
ns.m(segmentedSize.value),
|
|
ns.is("block", props2.block)
|
|
]);
|
|
const selectedStyle = computed(() => ({
|
|
width: props2.direction === "vertical" ? "100%" : `${state.width}px`,
|
|
height: props2.direction === "vertical" ? `${state.height}px` : "100%",
|
|
transform: props2.direction === "vertical" ? `translateY(${state.translateY}px)` : `translateX(${state.translateX}px)`,
|
|
display: state.isInit ? "block" : "none"
|
|
}));
|
|
const selectedCls = computed(() => [
|
|
ns.e("item-selected"),
|
|
ns.is("disabled", getDisabled(getOption(props2.modelValue))),
|
|
ns.is("focus-visible", state.focusVisible)
|
|
]);
|
|
const name = computed(() => {
|
|
return props2.name || segmentedId.value;
|
|
});
|
|
useResizeObserver(segmentedRef, updateSelect);
|
|
watch(activeElement, updateSelect);
|
|
watch(() => props2.modelValue, () => {
|
|
var _a2;
|
|
updateSelect();
|
|
if (props2.validateEvent) {
|
|
(_a2 = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a2.call(formItem, "change").catch((err) => debugWarn(err));
|
|
}
|
|
}, {
|
|
flush: "post"
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return _ctx.options.length ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
id: unref(inputId),
|
|
ref_key: "segmentedRef",
|
|
ref: segmentedRef,
|
|
class: normalizeClass(unref(segmentedCls)),
|
|
role: "radiogroup",
|
|
"aria-label": !unref(isLabeledByFormItem) ? _ctx.ariaLabel || "segmented" : void 0,
|
|
"aria-labelledby": unref(isLabeledByFormItem) ? unref(formItem).labelId : void 0
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([unref(ns).e("group"), unref(ns).m(props2.direction)])
|
|
}, [
|
|
createBaseVNode("div", {
|
|
style: normalizeStyle(unref(selectedStyle)),
|
|
class: normalizeClass(unref(selectedCls))
|
|
}, null, 6),
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.options, (item, index) => {
|
|
return openBlock(), createElementBlock("label", {
|
|
key: index,
|
|
class: normalizeClass(getItemCls(item))
|
|
}, [
|
|
createBaseVNode("input", {
|
|
class: normalizeClass(unref(ns).e("item-input")),
|
|
type: "radio",
|
|
name: unref(name),
|
|
disabled: getDisabled(item),
|
|
checked: getSelected(item),
|
|
onChange: ($event) => handleChange(item)
|
|
}, null, 42, ["name", "disabled", "checked", "onChange"]),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("item-label"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default", { item }, () => [
|
|
createTextVNode(toDisplayString(getLabel(item)), 1)
|
|
])
|
|
], 2)
|
|
], 2);
|
|
}), 128))
|
|
], 2)
|
|
], 10, ["id", "aria-label", "aria-labelledby"])) : createCommentVNode("v-if", true);
|
|
};
|
|
}
|
|
});
|
|
var Segmented = _export_sfc(_sfc_main151, [["__file", "segmented.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/segmented/index.mjs
|
|
var ElSegmented = withInstall(Segmented);
|
|
|
|
// node_modules/element-plus/es/components/mention/src/helper.mjs
|
|
var filterOption = (pattern4, option) => {
|
|
const lowerCase2 = pattern4.toLowerCase();
|
|
const label = option.label || option.value;
|
|
return label.toLowerCase().includes(lowerCase2);
|
|
};
|
|
var getMentionCtx = (inputEl, prefix, split2) => {
|
|
const { selectionEnd } = inputEl;
|
|
if (selectionEnd === null)
|
|
return;
|
|
const inputValue = inputEl.value;
|
|
const prefixArray = castArray_default(prefix);
|
|
let splitIndex = -1;
|
|
let mentionCtx;
|
|
for (let i = selectionEnd - 1; i >= 0; --i) {
|
|
const char = inputValue[i];
|
|
if (char === split2 || char === "\n" || char === "\r") {
|
|
splitIndex = i;
|
|
continue;
|
|
}
|
|
if (prefixArray.includes(char)) {
|
|
const end = splitIndex === -1 ? selectionEnd : splitIndex;
|
|
const pattern4 = inputValue.slice(i + 1, end);
|
|
mentionCtx = {
|
|
pattern: pattern4,
|
|
start: i + 1,
|
|
end,
|
|
prefix: char,
|
|
prefixIndex: i,
|
|
splitIndex,
|
|
selectionEnd
|
|
};
|
|
break;
|
|
}
|
|
}
|
|
return mentionCtx;
|
|
};
|
|
var getCursorPosition = (element, options = {
|
|
debug: false,
|
|
useSelectionEnd: false
|
|
}) => {
|
|
const selectionStart = element.selectionStart !== null ? element.selectionStart : 0;
|
|
const selectionEnd = element.selectionEnd !== null ? element.selectionEnd : 0;
|
|
const position = options.useSelectionEnd ? selectionEnd : selectionStart;
|
|
const properties = [
|
|
"direction",
|
|
"boxSizing",
|
|
"width",
|
|
"height",
|
|
"overflowX",
|
|
"overflowY",
|
|
"borderTopWidth",
|
|
"borderRightWidth",
|
|
"borderBottomWidth",
|
|
"borderLeftWidth",
|
|
"borderStyle",
|
|
"paddingTop",
|
|
"paddingRight",
|
|
"paddingBottom",
|
|
"paddingLeft",
|
|
"fontStyle",
|
|
"fontVariant",
|
|
"fontWeight",
|
|
"fontStretch",
|
|
"fontSize",
|
|
"fontSizeAdjust",
|
|
"lineHeight",
|
|
"fontFamily",
|
|
"textAlign",
|
|
"textTransform",
|
|
"textIndent",
|
|
"textDecoration",
|
|
"letterSpacing",
|
|
"wordSpacing",
|
|
"tabSize",
|
|
"MozTabSize"
|
|
];
|
|
if (options.debug) {
|
|
const el = document.querySelector("#input-textarea-caret-position-mirror-div");
|
|
if (el == null ? void 0 : el.parentNode)
|
|
el.parentNode.removeChild(el);
|
|
}
|
|
const div = document.createElement("div");
|
|
div.id = "input-textarea-caret-position-mirror-div";
|
|
document.body.appendChild(div);
|
|
const style = div.style;
|
|
const computed2 = window.getComputedStyle(element);
|
|
const isInput = element.nodeName === "INPUT";
|
|
style.whiteSpace = isInput ? "nowrap" : "pre-wrap";
|
|
if (!isInput)
|
|
style.wordWrap = "break-word";
|
|
style.position = "absolute";
|
|
if (!options.debug)
|
|
style.visibility = "hidden";
|
|
properties.forEach((prop) => {
|
|
if (isInput && prop === "lineHeight") {
|
|
if (computed2.boxSizing === "border-box") {
|
|
const height = Number.parseInt(computed2.height);
|
|
const outerHeight = Number.parseInt(computed2.paddingTop) + Number.parseInt(computed2.paddingBottom) + Number.parseInt(computed2.borderTopWidth) + Number.parseInt(computed2.borderBottomWidth);
|
|
const targetHeight = outerHeight + Number.parseInt(computed2.lineHeight);
|
|
if (height > targetHeight) {
|
|
style.lineHeight = `${height - outerHeight}px`;
|
|
} else if (height === targetHeight) {
|
|
style.lineHeight = computed2.lineHeight;
|
|
} else {
|
|
style.lineHeight = "0";
|
|
}
|
|
} else {
|
|
style.lineHeight = computed2.height;
|
|
}
|
|
} else {
|
|
style[prop] = computed2[prop];
|
|
}
|
|
});
|
|
if (isFirefox()) {
|
|
if (element.scrollHeight > Number.parseInt(computed2.height)) {
|
|
style.overflowY = "scroll";
|
|
}
|
|
} else {
|
|
style.overflow = "hidden";
|
|
}
|
|
div.textContent = element.value.slice(0, Math.max(0, position));
|
|
if (isInput && div.textContent) {
|
|
div.textContent = div.textContent.replace(/\s/g, "\xA0");
|
|
}
|
|
const span = document.createElement("span");
|
|
span.textContent = element.value.slice(Math.max(0, position)) || ".";
|
|
span.style.position = "relative";
|
|
span.style.left = `${-element.scrollLeft}px`;
|
|
span.style.top = `${-element.scrollTop}px`;
|
|
div.appendChild(span);
|
|
const relativePosition = {
|
|
top: span.offsetTop + Number.parseInt(computed2.borderTopWidth),
|
|
left: span.offsetLeft + Number.parseInt(computed2.borderLeftWidth),
|
|
height: Number.parseInt(computed2.fontSize) * 1.5
|
|
};
|
|
if (options.debug) {
|
|
span.style.backgroundColor = "#aaa";
|
|
} else {
|
|
document.body.removeChild(div);
|
|
}
|
|
if (relativePosition.left >= element.clientWidth) {
|
|
relativePosition.left = element.clientWidth;
|
|
}
|
|
return relativePosition;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/mention/src/mention.mjs
|
|
var mentionProps = buildProps({
|
|
...inputProps,
|
|
options: {
|
|
type: definePropType(Array),
|
|
default: () => []
|
|
},
|
|
prefix: {
|
|
type: definePropType([String, Array]),
|
|
default: "@",
|
|
validator: (val) => {
|
|
if (isString(val))
|
|
return val.length === 1;
|
|
return val.every((v2) => isString(v2) && v2.length === 1);
|
|
}
|
|
},
|
|
split: {
|
|
type: String,
|
|
default: " ",
|
|
validator: (val) => val.length === 1
|
|
},
|
|
filterOption: {
|
|
type: definePropType([Boolean, Function]),
|
|
default: () => filterOption,
|
|
validator: (val) => {
|
|
if (val === false)
|
|
return true;
|
|
return isFunction(val);
|
|
}
|
|
},
|
|
placement: {
|
|
type: definePropType(String),
|
|
default: "bottom"
|
|
},
|
|
showArrow: Boolean,
|
|
offset: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
whole: Boolean,
|
|
checkIsWhole: {
|
|
type: definePropType(Function)
|
|
},
|
|
modelValue: String,
|
|
loading: Boolean,
|
|
popperClass: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
popperOptions: {
|
|
type: definePropType(Object),
|
|
default: () => ({})
|
|
}
|
|
});
|
|
var mentionEmits = {
|
|
[UPDATE_MODEL_EVENT]: (value) => isString(value),
|
|
input: (value) => isString(value),
|
|
search: (pattern4, prefix) => isString(pattern4) && isString(prefix),
|
|
select: (option, prefix) => isString(option.value) && isString(prefix),
|
|
focus: (evt) => evt instanceof FocusEvent,
|
|
blur: (evt) => evt instanceof FocusEvent
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/mention/src/mention-dropdown.mjs
|
|
var mentionDropdownProps = buildProps({
|
|
options: {
|
|
type: definePropType(Array),
|
|
default: () => []
|
|
},
|
|
loading: Boolean,
|
|
disabled: Boolean,
|
|
contentId: String,
|
|
ariaLabel: String
|
|
});
|
|
var mentionDropdownEmits = {
|
|
select: (option) => isString(option.value)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/mention/src/mention-dropdown2.mjs
|
|
var __default__112 = defineComponent({
|
|
name: "ElMentionDropdown"
|
|
});
|
|
var _sfc_main152 = defineComponent({
|
|
...__default__112,
|
|
props: mentionDropdownProps,
|
|
emits: mentionDropdownEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("mention");
|
|
const { t } = useLocale();
|
|
const hoveringIndex = ref(-1);
|
|
const scrollbarRef = ref();
|
|
const optionRefs = ref();
|
|
const dropdownRef = ref();
|
|
const optionkls = (item, index) => [
|
|
ns.be("dropdown", "item"),
|
|
ns.is("hovering", hoveringIndex.value === index),
|
|
ns.is("disabled", item.disabled || props2.disabled)
|
|
];
|
|
const handleSelect = (item) => {
|
|
if (item.disabled || props2.disabled)
|
|
return;
|
|
emit("select", item);
|
|
};
|
|
const handleMouseEnter = (index) => {
|
|
hoveringIndex.value = index;
|
|
};
|
|
const filteredAllDisabled = computed(() => props2.disabled || props2.options.every((item) => item.disabled));
|
|
const hoverOption = computed(() => props2.options[hoveringIndex.value]);
|
|
const selectHoverOption = () => {
|
|
if (!hoverOption.value)
|
|
return;
|
|
emit("select", hoverOption.value);
|
|
};
|
|
const navigateOptions = (direction2) => {
|
|
const { options } = props2;
|
|
if (options.length === 0 || filteredAllDisabled.value)
|
|
return;
|
|
if (direction2 === "next") {
|
|
hoveringIndex.value++;
|
|
if (hoveringIndex.value === options.length) {
|
|
hoveringIndex.value = 0;
|
|
}
|
|
} else if (direction2 === "prev") {
|
|
hoveringIndex.value--;
|
|
if (hoveringIndex.value < 0) {
|
|
hoveringIndex.value = options.length - 1;
|
|
}
|
|
}
|
|
const option = options[hoveringIndex.value];
|
|
if (option.disabled) {
|
|
navigateOptions(direction2);
|
|
return;
|
|
}
|
|
nextTick(() => scrollToOption(option));
|
|
};
|
|
const scrollToOption = (option) => {
|
|
var _a2, _b, _c, _d;
|
|
const { options } = props2;
|
|
const index = options.findIndex((item) => item.value === option.value);
|
|
const target2 = (_a2 = optionRefs.value) == null ? void 0 : _a2[index];
|
|
if (target2) {
|
|
const menu = (_c = (_b = dropdownRef.value) == null ? void 0 : _b.querySelector) == null ? void 0 : _c.call(_b, `.${ns.be("dropdown", "wrap")}`);
|
|
if (menu) {
|
|
scrollIntoView(menu, target2);
|
|
}
|
|
}
|
|
(_d = scrollbarRef.value) == null ? void 0 : _d.handleScroll();
|
|
};
|
|
const resetHoveringIndex = () => {
|
|
if (filteredAllDisabled.value || props2.options.length === 0) {
|
|
hoveringIndex.value = -1;
|
|
} else {
|
|
hoveringIndex.value = 0;
|
|
}
|
|
};
|
|
watch(() => props2.options, resetHoveringIndex, {
|
|
immediate: true
|
|
});
|
|
expose({
|
|
hoveringIndex,
|
|
navigateOptions,
|
|
selectHoverOption,
|
|
hoverOption
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "dropdownRef",
|
|
ref: dropdownRef,
|
|
class: normalizeClass(unref(ns).b("dropdown"))
|
|
}, [
|
|
_ctx.$slots.header ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).be("dropdown", "header"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "header")
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
withDirectives(createVNode(unref(ElScrollbar), {
|
|
id: _ctx.contentId,
|
|
ref_key: "scrollbarRef",
|
|
ref: scrollbarRef,
|
|
tag: "ul",
|
|
"wrap-class": unref(ns).be("dropdown", "wrap"),
|
|
"view-class": unref(ns).be("dropdown", "list"),
|
|
role: "listbox",
|
|
"aria-label": _ctx.ariaLabel,
|
|
"aria-orientation": "vertical"
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.options, (item, index) => {
|
|
return openBlock(), createElementBlock("li", {
|
|
id: `${_ctx.contentId}-${index}`,
|
|
ref_for: true,
|
|
ref_key: "optionRefs",
|
|
ref: optionRefs,
|
|
key: index,
|
|
class: normalizeClass(optionkls(item, index)),
|
|
role: "option",
|
|
"aria-disabled": item.disabled || _ctx.disabled || void 0,
|
|
"aria-selected": hoveringIndex.value === index,
|
|
onMousemove: ($event) => handleMouseEnter(index),
|
|
onClick: withModifiers(($event) => handleSelect(item), ["stop"])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "label", {
|
|
item,
|
|
index
|
|
}, () => {
|
|
var _a2;
|
|
return [
|
|
createBaseVNode("span", null, toDisplayString((_a2 = item.label) != null ? _a2 : item.value), 1)
|
|
];
|
|
})
|
|
], 42, ["id", "aria-disabled", "aria-selected", "onMousemove", "onClick"]);
|
|
}), 128))
|
|
]),
|
|
_: 3
|
|
}, 8, ["id", "wrap-class", "view-class", "aria-label"]), [
|
|
[vShow, _ctx.options.length > 0 && !_ctx.loading]
|
|
]),
|
|
_ctx.loading ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).be("dropdown", "loading"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "loading", {}, () => [
|
|
createTextVNode(toDisplayString(unref(t)("el.mention.loading")), 1)
|
|
])
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
_ctx.$slots.footer ? (openBlock(), createElementBlock("div", {
|
|
key: 2,
|
|
class: normalizeClass(unref(ns).be("dropdown", "footer"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "footer")
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var ElMentionDropdown = _export_sfc(_sfc_main152, [["__file", "mention-dropdown.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/mention/src/mention2.mjs
|
|
var __default__113 = defineComponent({
|
|
name: "ElMention",
|
|
inheritAttrs: false
|
|
});
|
|
var _sfc_main153 = defineComponent({
|
|
...__default__113,
|
|
props: mentionProps,
|
|
emits: mentionEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const passInputProps = computed(() => pick_default(props2, Object.keys(inputProps)));
|
|
const ns = useNamespace("mention");
|
|
const disabled = useFormDisabled();
|
|
const contentId = useId();
|
|
const elInputRef = ref();
|
|
const tooltipRef = ref();
|
|
const dropdownRef = ref();
|
|
const visible = ref(false);
|
|
const cursorStyle = ref();
|
|
const mentionCtx = ref();
|
|
const computedPlacement = computed(() => props2.showArrow ? props2.placement : `${props2.placement}-start`);
|
|
const computedFallbackPlacements = computed(() => props2.showArrow ? ["bottom", "top"] : ["bottom-start", "top-start"]);
|
|
const filteredOptions = computed(() => {
|
|
const { filterOption: filterOption2, options } = props2;
|
|
if (!mentionCtx.value || !filterOption2)
|
|
return options;
|
|
return options.filter((option) => filterOption2(mentionCtx.value.pattern, option));
|
|
});
|
|
const dropdownVisible = computed(() => {
|
|
return visible.value && (!!filteredOptions.value.length || props2.loading);
|
|
});
|
|
const hoveringId = computed(() => {
|
|
var _a2;
|
|
return `${contentId.value}-${(_a2 = dropdownRef.value) == null ? void 0 : _a2.hoveringIndex}`;
|
|
});
|
|
const handleInputChange = (value) => {
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emit(INPUT_EVENT, value);
|
|
syncAfterCursorMove();
|
|
};
|
|
const handleInputKeyDown = (event) => {
|
|
var _a2, _b, _c, _d;
|
|
if (!("code" in event) || ((_a2 = elInputRef.value) == null ? void 0 : _a2.isComposing))
|
|
return;
|
|
switch (event.code) {
|
|
case EVENT_CODE.left:
|
|
case EVENT_CODE.right:
|
|
syncAfterCursorMove();
|
|
break;
|
|
case EVENT_CODE.up:
|
|
case EVENT_CODE.down:
|
|
if (!visible.value)
|
|
return;
|
|
event.preventDefault();
|
|
(_b = dropdownRef.value) == null ? void 0 : _b.navigateOptions(event.code === EVENT_CODE.up ? "prev" : "next");
|
|
break;
|
|
case EVENT_CODE.enter:
|
|
case EVENT_CODE.numpadEnter:
|
|
if (!visible.value)
|
|
return;
|
|
event.preventDefault();
|
|
if ((_c = dropdownRef.value) == null ? void 0 : _c.hoverOption) {
|
|
(_d = dropdownRef.value) == null ? void 0 : _d.selectHoverOption();
|
|
} else {
|
|
visible.value = false;
|
|
}
|
|
break;
|
|
case EVENT_CODE.esc:
|
|
if (!visible.value)
|
|
return;
|
|
event.preventDefault();
|
|
visible.value = false;
|
|
break;
|
|
case EVENT_CODE.backspace:
|
|
if (props2.whole && mentionCtx.value) {
|
|
const { splitIndex, selectionEnd, pattern: pattern4, prefixIndex, prefix } = mentionCtx.value;
|
|
const inputEl = getInputEl();
|
|
if (!inputEl)
|
|
return;
|
|
const inputValue = inputEl.value;
|
|
const matchOption = props2.options.find((item) => item.value === pattern4);
|
|
const isWhole = isFunction(props2.checkIsWhole) ? props2.checkIsWhole(pattern4, prefix) : matchOption;
|
|
if (isWhole && splitIndex !== -1 && splitIndex + 1 === selectionEnd) {
|
|
event.preventDefault();
|
|
const newValue = inputValue.slice(0, prefixIndex) + inputValue.slice(splitIndex + 1);
|
|
emit(UPDATE_MODEL_EVENT, newValue);
|
|
emit(INPUT_EVENT, newValue);
|
|
const newSelectionEnd = prefixIndex;
|
|
nextTick(() => {
|
|
inputEl.selectionStart = newSelectionEnd;
|
|
inputEl.selectionEnd = newSelectionEnd;
|
|
syncDropdownVisible();
|
|
});
|
|
}
|
|
}
|
|
}
|
|
};
|
|
const { wrapperRef } = useFocusController(elInputRef, {
|
|
beforeFocus() {
|
|
return disabled.value;
|
|
},
|
|
afterFocus() {
|
|
syncAfterCursorMove();
|
|
},
|
|
beforeBlur(event) {
|
|
var _a2;
|
|
return (_a2 = tooltipRef.value) == null ? void 0 : _a2.isFocusInsideContent(event);
|
|
},
|
|
afterBlur() {
|
|
visible.value = false;
|
|
}
|
|
});
|
|
const handleInputMouseDown = () => {
|
|
syncAfterCursorMove();
|
|
};
|
|
const handleSelect = (item) => {
|
|
if (!mentionCtx.value)
|
|
return;
|
|
const inputEl = getInputEl();
|
|
if (!inputEl)
|
|
return;
|
|
const inputValue = inputEl.value;
|
|
const { split: split2 } = props2;
|
|
const newEndPart = inputValue.slice(mentionCtx.value.end);
|
|
const alreadySeparated = newEndPart.startsWith(split2);
|
|
const newMiddlePart = `${item.value}${alreadySeparated ? "" : split2}`;
|
|
const newValue = inputValue.slice(0, mentionCtx.value.start) + newMiddlePart + newEndPart;
|
|
emit(UPDATE_MODEL_EVENT, newValue);
|
|
emit(INPUT_EVENT, newValue);
|
|
emit("select", item, mentionCtx.value.prefix);
|
|
const newSelectionEnd = mentionCtx.value.start + newMiddlePart.length + (alreadySeparated ? 1 : 0);
|
|
nextTick(() => {
|
|
inputEl.selectionStart = newSelectionEnd;
|
|
inputEl.selectionEnd = newSelectionEnd;
|
|
inputEl.focus();
|
|
syncDropdownVisible();
|
|
});
|
|
};
|
|
const getInputEl = () => {
|
|
var _a2, _b;
|
|
return props2.type === "textarea" ? (_a2 = elInputRef.value) == null ? void 0 : _a2.textarea : (_b = elInputRef.value) == null ? void 0 : _b.input;
|
|
};
|
|
const syncAfterCursorMove = () => {
|
|
setTimeout(() => {
|
|
syncCursor();
|
|
syncDropdownVisible();
|
|
nextTick(() => {
|
|
var _a2;
|
|
return (_a2 = tooltipRef.value) == null ? void 0 : _a2.updatePopper();
|
|
});
|
|
}, 0);
|
|
};
|
|
const syncCursor = () => {
|
|
const inputEl = getInputEl();
|
|
if (!inputEl)
|
|
return;
|
|
const caretPosition = getCursorPosition(inputEl);
|
|
const inputRect = inputEl.getBoundingClientRect();
|
|
const elInputRect = elInputRef.value.$el.getBoundingClientRect();
|
|
cursorStyle.value = {
|
|
position: "absolute",
|
|
width: 0,
|
|
height: `${caretPosition.height}px`,
|
|
left: `${caretPosition.left + inputRect.left - elInputRect.left}px`,
|
|
top: `${caretPosition.top + inputRect.top - elInputRect.top}px`
|
|
};
|
|
};
|
|
const syncDropdownVisible = () => {
|
|
const inputEl = getInputEl();
|
|
if (document.activeElement !== inputEl) {
|
|
visible.value = false;
|
|
return;
|
|
}
|
|
const { prefix, split: split2 } = props2;
|
|
mentionCtx.value = getMentionCtx(inputEl, prefix, split2);
|
|
if (mentionCtx.value && mentionCtx.value.splitIndex === -1) {
|
|
visible.value = true;
|
|
emit("search", mentionCtx.value.pattern, mentionCtx.value.prefix);
|
|
return;
|
|
}
|
|
visible.value = false;
|
|
};
|
|
expose({
|
|
input: elInputRef,
|
|
tooltip: tooltipRef,
|
|
dropdownVisible
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "wrapperRef",
|
|
ref: wrapperRef,
|
|
class: normalizeClass(unref(ns).b())
|
|
}, [
|
|
createVNode(unref(ElInput), mergeProps(mergeProps(unref(passInputProps), _ctx.$attrs), {
|
|
ref_key: "elInputRef",
|
|
ref: elInputRef,
|
|
"model-value": _ctx.modelValue,
|
|
disabled: unref(disabled),
|
|
role: unref(dropdownVisible) ? "combobox" : void 0,
|
|
"aria-activedescendant": unref(dropdownVisible) ? unref(hoveringId) || "" : void 0,
|
|
"aria-controls": unref(dropdownVisible) ? unref(contentId) : void 0,
|
|
"aria-expanded": unref(dropdownVisible) || void 0,
|
|
"aria-label": _ctx.ariaLabel,
|
|
"aria-autocomplete": unref(dropdownVisible) ? "none" : void 0,
|
|
"aria-haspopup": unref(dropdownVisible) ? "listbox" : void 0,
|
|
onInput: handleInputChange,
|
|
onKeydown: handleInputKeyDown,
|
|
onMousedown: handleInputMouseDown
|
|
}), createSlots({
|
|
_: 2
|
|
}, [
|
|
renderList(_ctx.$slots, (_2, name) => {
|
|
return {
|
|
name,
|
|
fn: withCtx((slotProps) => [
|
|
renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps)))
|
|
])
|
|
};
|
|
})
|
|
]), 1040, ["model-value", "disabled", "role", "aria-activedescendant", "aria-controls", "aria-expanded", "aria-label", "aria-autocomplete", "aria-haspopup"]),
|
|
createVNode(unref(ElTooltip), {
|
|
ref_key: "tooltipRef",
|
|
ref: tooltipRef,
|
|
visible: unref(dropdownVisible),
|
|
"popper-class": [unref(ns).e("popper"), _ctx.popperClass],
|
|
"popper-options": _ctx.popperOptions,
|
|
placement: unref(computedPlacement),
|
|
"fallback-placements": unref(computedFallbackPlacements),
|
|
effect: "light",
|
|
pure: "",
|
|
offset: _ctx.offset,
|
|
"show-arrow": _ctx.showArrow
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
style: normalizeStyle(cursorStyle.value)
|
|
}, null, 4)
|
|
]),
|
|
content: withCtx(() => {
|
|
var _a2;
|
|
return [
|
|
createVNode(ElMentionDropdown, {
|
|
ref_key: "dropdownRef",
|
|
ref: dropdownRef,
|
|
options: unref(filteredOptions),
|
|
disabled: unref(disabled),
|
|
loading: _ctx.loading,
|
|
"content-id": unref(contentId),
|
|
"aria-label": _ctx.ariaLabel,
|
|
onSelect: handleSelect,
|
|
onClick: withModifiers((_a2 = elInputRef.value) == null ? void 0 : _a2.focus, ["stop"])
|
|
}, createSlots({
|
|
_: 2
|
|
}, [
|
|
renderList(_ctx.$slots, (_2, name) => {
|
|
return {
|
|
name,
|
|
fn: withCtx((slotProps) => [
|
|
renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps)))
|
|
])
|
|
};
|
|
})
|
|
]), 1032, ["options", "disabled", "loading", "content-id", "aria-label", "onClick"])
|
|
];
|
|
}),
|
|
_: 3
|
|
}, 8, ["visible", "popper-class", "popper-options", "placement", "fallback-placements", "offset", "show-arrow"])
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
var Mention = _export_sfc(_sfc_main153, [["__file", "mention.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/mention/index.mjs
|
|
var ElMention = withInstall(Mention);
|
|
|
|
// node_modules/element-plus/es/components/infinite-scroll/src/index.mjs
|
|
var SCOPE11 = "ElInfiniteScroll";
|
|
var CHECK_INTERVAL = 50;
|
|
var DEFAULT_DELAY = 200;
|
|
var DEFAULT_DISTANCE = 0;
|
|
var attributes = {
|
|
delay: {
|
|
type: Number,
|
|
default: DEFAULT_DELAY
|
|
},
|
|
distance: {
|
|
type: Number,
|
|
default: DEFAULT_DISTANCE
|
|
},
|
|
disabled: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
immediate: {
|
|
type: Boolean,
|
|
default: true
|
|
}
|
|
};
|
|
var getScrollOptions = (el, instance) => {
|
|
return Object.entries(attributes).reduce((acm, [name, option]) => {
|
|
var _a2, _b;
|
|
const { type: type4, default: defaultValue } = option;
|
|
const attrVal = el.getAttribute(`infinite-scroll-${name}`);
|
|
let value = (_b = (_a2 = instance[attrVal]) != null ? _a2 : attrVal) != null ? _b : defaultValue;
|
|
value = value === "false" ? false : value;
|
|
value = type4(value);
|
|
acm[name] = Number.isNaN(value) ? defaultValue : value;
|
|
return acm;
|
|
}, {});
|
|
};
|
|
var destroyObserver = (el) => {
|
|
const { observer } = el[SCOPE11];
|
|
if (observer) {
|
|
observer.disconnect();
|
|
delete el[SCOPE11].observer;
|
|
}
|
|
};
|
|
var handleScroll = (el, cb) => {
|
|
const { container, containerEl, instance, observer, lastScrollTop } = el[SCOPE11];
|
|
const { disabled, distance } = getScrollOptions(el, instance);
|
|
const { clientHeight, scrollHeight, scrollTop } = containerEl;
|
|
const delta = scrollTop - lastScrollTop;
|
|
el[SCOPE11].lastScrollTop = scrollTop;
|
|
if (observer || disabled || delta < 0)
|
|
return;
|
|
let shouldTrigger = false;
|
|
if (container === el) {
|
|
shouldTrigger = scrollHeight - (clientHeight + scrollTop) <= distance;
|
|
} else {
|
|
const { clientTop, scrollHeight: height } = el;
|
|
const offsetTop = getOffsetTopDistance(el, containerEl);
|
|
shouldTrigger = scrollTop + clientHeight >= offsetTop + clientTop + height - distance;
|
|
}
|
|
if (shouldTrigger) {
|
|
cb.call(instance);
|
|
}
|
|
};
|
|
function checkFull(el, cb) {
|
|
const { containerEl, instance } = el[SCOPE11];
|
|
const { disabled } = getScrollOptions(el, instance);
|
|
if (disabled || containerEl.clientHeight === 0)
|
|
return;
|
|
if (containerEl.scrollHeight <= containerEl.clientHeight) {
|
|
cb.call(instance);
|
|
} else {
|
|
destroyObserver(el);
|
|
}
|
|
}
|
|
var InfiniteScroll = {
|
|
async mounted(el, binding) {
|
|
const { instance, value: cb } = binding;
|
|
if (!isFunction(cb)) {
|
|
throwError(SCOPE11, "'v-infinite-scroll' binding value must be a function");
|
|
}
|
|
await nextTick();
|
|
const { delay: delay2, immediate } = getScrollOptions(el, instance);
|
|
const container = getScrollContainer(el, true);
|
|
const containerEl = container === window ? document.documentElement : container;
|
|
const onScroll = throttle_default(handleScroll.bind(null, el, cb), delay2);
|
|
if (!container)
|
|
return;
|
|
el[SCOPE11] = {
|
|
instance,
|
|
container,
|
|
containerEl,
|
|
delay: delay2,
|
|
cb,
|
|
onScroll,
|
|
lastScrollTop: containerEl.scrollTop
|
|
};
|
|
if (immediate) {
|
|
const observer = new MutationObserver(throttle_default(checkFull.bind(null, el, cb), CHECK_INTERVAL));
|
|
el[SCOPE11].observer = observer;
|
|
observer.observe(el, { childList: true, subtree: true });
|
|
checkFull(el, cb);
|
|
}
|
|
container.addEventListener("scroll", onScroll);
|
|
},
|
|
unmounted(el) {
|
|
if (!el[SCOPE11])
|
|
return;
|
|
const { container, onScroll } = el[SCOPE11];
|
|
container == null ? void 0 : container.removeEventListener("scroll", onScroll);
|
|
destroyObserver(el);
|
|
},
|
|
async updated(el) {
|
|
if (!el[SCOPE11]) {
|
|
await nextTick();
|
|
} else {
|
|
const { containerEl, cb, observer } = el[SCOPE11];
|
|
if (containerEl.clientHeight && observer) {
|
|
checkFull(el, cb);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/infinite-scroll/index.mjs
|
|
var _InfiniteScroll = InfiniteScroll;
|
|
_InfiniteScroll.install = (app) => {
|
|
app.directive("InfiniteScroll", _InfiniteScroll);
|
|
};
|
|
var ElInfiniteScroll = _InfiniteScroll;
|
|
|
|
// node_modules/element-plus/es/components/loading/src/loading.mjs
|
|
function createLoadingComponent(options, appContext) {
|
|
let afterLeaveTimer;
|
|
const afterLeaveFlag = ref(false);
|
|
const data = reactive({
|
|
...options,
|
|
originalPosition: "",
|
|
originalOverflow: "",
|
|
visible: false
|
|
});
|
|
function setText(text) {
|
|
data.text = text;
|
|
}
|
|
function destroySelf() {
|
|
const target2 = data.parent;
|
|
const ns = vm.ns;
|
|
if (!target2.vLoadingAddClassList) {
|
|
let loadingNumber = target2.getAttribute("loading-number");
|
|
loadingNumber = Number.parseInt(loadingNumber) - 1;
|
|
if (!loadingNumber) {
|
|
removeClass(target2, ns.bm("parent", "relative"));
|
|
target2.removeAttribute("loading-number");
|
|
} else {
|
|
target2.setAttribute("loading-number", loadingNumber.toString());
|
|
}
|
|
removeClass(target2, ns.bm("parent", "hidden"));
|
|
}
|
|
removeElLoadingChild();
|
|
loadingInstance.unmount();
|
|
}
|
|
function removeElLoadingChild() {
|
|
var _a2, _b;
|
|
(_b = (_a2 = vm.$el) == null ? void 0 : _a2.parentNode) == null ? void 0 : _b.removeChild(vm.$el);
|
|
}
|
|
function close2() {
|
|
var _a2;
|
|
if (options.beforeClose && !options.beforeClose())
|
|
return;
|
|
afterLeaveFlag.value = true;
|
|
clearTimeout(afterLeaveTimer);
|
|
afterLeaveTimer = setTimeout(handleAfterLeave, 400);
|
|
data.visible = false;
|
|
(_a2 = options.closed) == null ? void 0 : _a2.call(options);
|
|
}
|
|
function handleAfterLeave() {
|
|
if (!afterLeaveFlag.value)
|
|
return;
|
|
const target2 = data.parent;
|
|
afterLeaveFlag.value = false;
|
|
target2.vLoadingAddClassList = void 0;
|
|
destroySelf();
|
|
}
|
|
const elLoadingComponent = defineComponent({
|
|
name: "ElLoading",
|
|
setup(_2, { expose }) {
|
|
const { ns, zIndex: zIndex2 } = useGlobalComponentSettings("loading");
|
|
expose({
|
|
ns,
|
|
zIndex: zIndex2
|
|
});
|
|
return () => {
|
|
const svg = data.spinner || data.svg;
|
|
const spinner = h("svg", {
|
|
class: "circular",
|
|
viewBox: data.svgViewBox ? data.svgViewBox : "0 0 50 50",
|
|
...svg ? { innerHTML: svg } : {}
|
|
}, [
|
|
h("circle", {
|
|
class: "path",
|
|
cx: "25",
|
|
cy: "25",
|
|
r: "20",
|
|
fill: "none"
|
|
})
|
|
]);
|
|
const spinnerText = data.text ? h("p", { class: ns.b("text") }, [data.text]) : void 0;
|
|
return h(Transition, {
|
|
name: ns.b("fade"),
|
|
onAfterLeave: handleAfterLeave
|
|
}, {
|
|
default: withCtx(() => [
|
|
withDirectives(createVNode("div", {
|
|
style: {
|
|
backgroundColor: data.background || ""
|
|
},
|
|
class: [
|
|
ns.b("mask"),
|
|
data.customClass,
|
|
data.fullscreen ? "is-fullscreen" : ""
|
|
]
|
|
}, [
|
|
h("div", {
|
|
class: ns.b("spinner")
|
|
}, [spinner, spinnerText])
|
|
]), [[vShow, data.visible]])
|
|
])
|
|
});
|
|
};
|
|
}
|
|
});
|
|
const loadingInstance = createApp(elLoadingComponent);
|
|
Object.assign(loadingInstance._context, appContext != null ? appContext : {});
|
|
const vm = loadingInstance.mount(document.createElement("div"));
|
|
return {
|
|
...toRefs(data),
|
|
setText,
|
|
removeElLoadingChild,
|
|
close: close2,
|
|
handleAfterLeave,
|
|
vm,
|
|
get $el() {
|
|
return vm.$el;
|
|
}
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/loading/src/service.mjs
|
|
var fullscreenInstance = void 0;
|
|
var Loading = function(options = {}) {
|
|
if (!isClient)
|
|
return void 0;
|
|
const resolved = resolveOptions(options);
|
|
if (resolved.fullscreen && fullscreenInstance) {
|
|
return fullscreenInstance;
|
|
}
|
|
const instance = createLoadingComponent({
|
|
...resolved,
|
|
closed: () => {
|
|
var _a2;
|
|
(_a2 = resolved.closed) == null ? void 0 : _a2.call(resolved);
|
|
if (resolved.fullscreen)
|
|
fullscreenInstance = void 0;
|
|
}
|
|
}, Loading._context);
|
|
addStyle(resolved, resolved.parent, instance);
|
|
addClassList(resolved, resolved.parent, instance);
|
|
resolved.parent.vLoadingAddClassList = () => addClassList(resolved, resolved.parent, instance);
|
|
let loadingNumber = resolved.parent.getAttribute("loading-number");
|
|
if (!loadingNumber) {
|
|
loadingNumber = "1";
|
|
} else {
|
|
loadingNumber = `${Number.parseInt(loadingNumber) + 1}`;
|
|
}
|
|
resolved.parent.setAttribute("loading-number", loadingNumber);
|
|
resolved.parent.appendChild(instance.$el);
|
|
nextTick(() => instance.visible.value = resolved.visible);
|
|
if (resolved.fullscreen) {
|
|
fullscreenInstance = instance;
|
|
}
|
|
return instance;
|
|
};
|
|
var resolveOptions = (options) => {
|
|
var _a2, _b, _c, _d;
|
|
let target2;
|
|
if (isString(options.target)) {
|
|
target2 = (_a2 = document.querySelector(options.target)) != null ? _a2 : document.body;
|
|
} else {
|
|
target2 = options.target || document.body;
|
|
}
|
|
return {
|
|
parent: target2 === document.body || options.body ? document.body : target2,
|
|
background: options.background || "",
|
|
svg: options.svg || "",
|
|
svgViewBox: options.svgViewBox || "",
|
|
spinner: options.spinner || false,
|
|
text: options.text || "",
|
|
fullscreen: target2 === document.body && ((_b = options.fullscreen) != null ? _b : true),
|
|
lock: (_c = options.lock) != null ? _c : false,
|
|
customClass: options.customClass || "",
|
|
visible: (_d = options.visible) != null ? _d : true,
|
|
beforeClose: options.beforeClose,
|
|
closed: options.closed,
|
|
target: target2
|
|
};
|
|
};
|
|
var addStyle = async (options, parent2, instance) => {
|
|
const { nextZIndex } = instance.vm.zIndex || instance.vm._.exposed.zIndex;
|
|
const maskStyle = {};
|
|
if (options.fullscreen) {
|
|
instance.originalPosition.value = getStyle(document.body, "position");
|
|
instance.originalOverflow.value = getStyle(document.body, "overflow");
|
|
maskStyle.zIndex = nextZIndex();
|
|
} else if (options.parent === document.body) {
|
|
instance.originalPosition.value = getStyle(document.body, "position");
|
|
await nextTick();
|
|
for (const property2 of ["top", "left"]) {
|
|
const scroll = property2 === "top" ? "scrollTop" : "scrollLeft";
|
|
maskStyle[property2] = `${options.target.getBoundingClientRect()[property2] + document.body[scroll] + document.documentElement[scroll] - Number.parseInt(getStyle(document.body, `margin-${property2}`), 10)}px`;
|
|
}
|
|
for (const property2 of ["height", "width"]) {
|
|
maskStyle[property2] = `${options.target.getBoundingClientRect()[property2]}px`;
|
|
}
|
|
} else {
|
|
instance.originalPosition.value = getStyle(parent2, "position");
|
|
}
|
|
for (const [key, value] of Object.entries(maskStyle)) {
|
|
instance.$el.style[key] = value;
|
|
}
|
|
};
|
|
var addClassList = (options, parent2, instance) => {
|
|
const ns = instance.vm.ns || instance.vm._.exposed.ns;
|
|
if (!["absolute", "fixed", "sticky"].includes(instance.originalPosition.value)) {
|
|
addClass(parent2, ns.bm("parent", "relative"));
|
|
} else {
|
|
removeClass(parent2, ns.bm("parent", "relative"));
|
|
}
|
|
if (options.fullscreen && options.lock) {
|
|
addClass(parent2, ns.bm("parent", "hidden"));
|
|
} else {
|
|
removeClass(parent2, ns.bm("parent", "hidden"));
|
|
}
|
|
};
|
|
Loading._context = null;
|
|
|
|
// node_modules/element-plus/es/components/loading/src/directive.mjs
|
|
var INSTANCE_KEY = Symbol("ElLoading");
|
|
var createInstance = (el, binding) => {
|
|
var _a2, _b, _c, _d;
|
|
const vm = binding.instance;
|
|
const getBindingProp = (key) => isObject(binding.value) ? binding.value[key] : void 0;
|
|
const resolveExpression = (key) => {
|
|
const data = isString(key) && (vm == null ? void 0 : vm[key]) || key;
|
|
if (data)
|
|
return ref(data);
|
|
else
|
|
return data;
|
|
};
|
|
const getProp2 = (name) => resolveExpression(getBindingProp(name) || el.getAttribute(`element-loading-${hyphenate(name)}`));
|
|
const fullscreen = (_a2 = getBindingProp("fullscreen")) != null ? _a2 : binding.modifiers.fullscreen;
|
|
const options = {
|
|
text: getProp2("text"),
|
|
svg: getProp2("svg"),
|
|
svgViewBox: getProp2("svgViewBox"),
|
|
spinner: getProp2("spinner"),
|
|
background: getProp2("background"),
|
|
customClass: getProp2("customClass"),
|
|
fullscreen,
|
|
target: (_b = getBindingProp("target")) != null ? _b : fullscreen ? void 0 : el,
|
|
body: (_c = getBindingProp("body")) != null ? _c : binding.modifiers.body,
|
|
lock: (_d = getBindingProp("lock")) != null ? _d : binding.modifiers.lock
|
|
};
|
|
const instance = Loading(options);
|
|
instance._context = vLoading._context;
|
|
el[INSTANCE_KEY] = {
|
|
options,
|
|
instance
|
|
};
|
|
};
|
|
var updateOptions = (newOptions, originalOptions) => {
|
|
for (const key of Object.keys(originalOptions)) {
|
|
if (isRef(originalOptions[key]))
|
|
originalOptions[key].value = newOptions[key];
|
|
}
|
|
};
|
|
var vLoading = {
|
|
mounted(el, binding) {
|
|
if (binding.value) {
|
|
createInstance(el, binding);
|
|
}
|
|
},
|
|
updated(el, binding) {
|
|
const instance = el[INSTANCE_KEY];
|
|
if (binding.oldValue !== binding.value) {
|
|
if (binding.value && !binding.oldValue) {
|
|
createInstance(el, binding);
|
|
} else if (binding.value && binding.oldValue) {
|
|
if (isObject(binding.value))
|
|
updateOptions(binding.value, instance.options);
|
|
} else {
|
|
instance == null ? void 0 : instance.instance.close();
|
|
}
|
|
}
|
|
},
|
|
unmounted(el) {
|
|
var _a2;
|
|
(_a2 = el[INSTANCE_KEY]) == null ? void 0 : _a2.instance.close();
|
|
el[INSTANCE_KEY] = null;
|
|
}
|
|
};
|
|
vLoading._context = null;
|
|
|
|
// node_modules/element-plus/es/components/loading/index.mjs
|
|
var ElLoading = {
|
|
install(app) {
|
|
Loading._context = app._context;
|
|
vLoading._context = app._context;
|
|
app.directive("loading", vLoading);
|
|
app.config.globalProperties.$loading = Loading;
|
|
},
|
|
directive: vLoading,
|
|
service: Loading
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/message/src/message.mjs
|
|
var messageTypes = [
|
|
"primary",
|
|
"success",
|
|
"info",
|
|
"warning",
|
|
"error"
|
|
];
|
|
var messageDefaults = mutable({
|
|
customClass: "",
|
|
dangerouslyUseHTMLString: false,
|
|
duration: 3e3,
|
|
icon: void 0,
|
|
id: "",
|
|
message: "",
|
|
onClose: void 0,
|
|
showClose: false,
|
|
type: "info",
|
|
plain: false,
|
|
offset: 16,
|
|
zIndex: 0,
|
|
grouping: false,
|
|
repeatNum: 1,
|
|
appendTo: isClient ? document.body : void 0
|
|
});
|
|
var messageProps = buildProps({
|
|
customClass: {
|
|
type: String,
|
|
default: messageDefaults.customClass
|
|
},
|
|
dangerouslyUseHTMLString: {
|
|
type: Boolean,
|
|
default: messageDefaults.dangerouslyUseHTMLString
|
|
},
|
|
duration: {
|
|
type: Number,
|
|
default: messageDefaults.duration
|
|
},
|
|
icon: {
|
|
type: iconPropType,
|
|
default: messageDefaults.icon
|
|
},
|
|
id: {
|
|
type: String,
|
|
default: messageDefaults.id
|
|
},
|
|
message: {
|
|
type: definePropType([
|
|
String,
|
|
Object,
|
|
Function
|
|
]),
|
|
default: messageDefaults.message
|
|
},
|
|
onClose: {
|
|
type: definePropType(Function),
|
|
default: messageDefaults.onClose
|
|
},
|
|
showClose: {
|
|
type: Boolean,
|
|
default: messageDefaults.showClose
|
|
},
|
|
type: {
|
|
type: String,
|
|
values: messageTypes,
|
|
default: messageDefaults.type
|
|
},
|
|
plain: {
|
|
type: Boolean,
|
|
default: messageDefaults.plain
|
|
},
|
|
offset: {
|
|
type: Number,
|
|
default: messageDefaults.offset
|
|
},
|
|
zIndex: {
|
|
type: Number,
|
|
default: messageDefaults.zIndex
|
|
},
|
|
grouping: {
|
|
type: Boolean,
|
|
default: messageDefaults.grouping
|
|
},
|
|
repeatNum: {
|
|
type: Number,
|
|
default: messageDefaults.repeatNum
|
|
}
|
|
});
|
|
var messageEmits = {
|
|
destroy: () => true
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/message/src/instance.mjs
|
|
var instances = shallowReactive([]);
|
|
var getInstance = (id) => {
|
|
const idx = instances.findIndex((instance) => instance.id === id);
|
|
const current = instances[idx];
|
|
let prev;
|
|
if (idx > 0) {
|
|
prev = instances[idx - 1];
|
|
}
|
|
return { current, prev };
|
|
};
|
|
var getLastOffset = (id) => {
|
|
const { prev } = getInstance(id);
|
|
if (!prev)
|
|
return 0;
|
|
return prev.vm.exposed.bottom.value;
|
|
};
|
|
var getOffsetOrSpace = (id, offset3) => {
|
|
const idx = instances.findIndex((instance) => instance.id === id);
|
|
return idx > 0 ? 16 : offset3;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/message/src/message2.mjs
|
|
var __default__114 = defineComponent({
|
|
name: "ElMessage"
|
|
});
|
|
var _sfc_main154 = defineComponent({
|
|
...__default__114,
|
|
props: messageProps,
|
|
emits: messageEmits,
|
|
setup(__props, { expose, emit }) {
|
|
const props2 = __props;
|
|
const { Close } = TypeComponents;
|
|
const isStartTransition = ref(false);
|
|
const { ns, zIndex: zIndex2 } = useGlobalComponentSettings("message");
|
|
const { currentZIndex, nextZIndex } = zIndex2;
|
|
const messageRef = ref();
|
|
const visible = ref(false);
|
|
const height = ref(0);
|
|
let stopTimer = void 0;
|
|
const badgeType = computed(() => props2.type ? props2.type === "error" ? "danger" : props2.type : "info");
|
|
const typeClass = computed(() => {
|
|
const type4 = props2.type;
|
|
return { [ns.bm("icon", type4)]: type4 && TypeComponentsMap[type4] };
|
|
});
|
|
const iconComponent = computed(() => props2.icon || TypeComponentsMap[props2.type] || "");
|
|
const lastOffset = computed(() => getLastOffset(props2.id));
|
|
const offset3 = computed(() => getOffsetOrSpace(props2.id, props2.offset) + lastOffset.value);
|
|
const bottom = computed(() => height.value + offset3.value);
|
|
const customStyle = computed(() => ({
|
|
top: `${offset3.value}px`,
|
|
zIndex: currentZIndex.value
|
|
}));
|
|
function startTimer() {
|
|
if (props2.duration === 0)
|
|
return;
|
|
({ stop: stopTimer } = useTimeoutFn(() => {
|
|
close2();
|
|
}, props2.duration));
|
|
}
|
|
function clearTimer() {
|
|
stopTimer == null ? void 0 : stopTimer();
|
|
}
|
|
function close2() {
|
|
visible.value = false;
|
|
nextTick(() => {
|
|
var _a2;
|
|
if (!isStartTransition.value) {
|
|
(_a2 = props2.onClose) == null ? void 0 : _a2.call(props2);
|
|
emit("destroy");
|
|
}
|
|
});
|
|
}
|
|
function keydown({ code }) {
|
|
if (code === EVENT_CODE.esc) {
|
|
close2();
|
|
}
|
|
}
|
|
onMounted(() => {
|
|
startTimer();
|
|
nextZIndex();
|
|
visible.value = true;
|
|
});
|
|
watch(() => props2.repeatNum, () => {
|
|
clearTimer();
|
|
startTimer();
|
|
});
|
|
useEventListener(document, "keydown", keydown);
|
|
useResizeObserver(messageRef, () => {
|
|
height.value = messageRef.value.getBoundingClientRect().height;
|
|
});
|
|
expose({
|
|
visible,
|
|
bottom,
|
|
close: close2
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(Transition, {
|
|
name: unref(ns).b("fade"),
|
|
onBeforeEnter: ($event) => isStartTransition.value = true,
|
|
onBeforeLeave: _ctx.onClose,
|
|
onAfterLeave: ($event) => _ctx.$emit("destroy"),
|
|
persisted: ""
|
|
}, {
|
|
default: withCtx(() => [
|
|
withDirectives(createBaseVNode("div", {
|
|
id: _ctx.id,
|
|
ref_key: "messageRef",
|
|
ref: messageRef,
|
|
class: normalizeClass([
|
|
unref(ns).b(),
|
|
{ [unref(ns).m(_ctx.type)]: _ctx.type },
|
|
unref(ns).is("closable", _ctx.showClose),
|
|
unref(ns).is("plain", _ctx.plain),
|
|
_ctx.customClass
|
|
]),
|
|
style: normalizeStyle(unref(customStyle)),
|
|
role: "alert",
|
|
onMouseenter: clearTimer,
|
|
onMouseleave: startTimer
|
|
}, [
|
|
_ctx.repeatNum > 1 ? (openBlock(), createBlock(unref(ElBadge), {
|
|
key: 0,
|
|
value: _ctx.repeatNum,
|
|
type: unref(badgeType),
|
|
class: normalizeClass(unref(ns).e("badge"))
|
|
}, null, 8, ["value", "type", "class"])) : createCommentVNode("v-if", true),
|
|
unref(iconComponent) ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 1,
|
|
class: normalizeClass([unref(ns).e("icon"), unref(typeClass)])
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(unref(iconComponent))))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true),
|
|
renderSlot(_ctx.$slots, "default", {}, () => [
|
|
!_ctx.dangerouslyUseHTMLString ? (openBlock(), createElementBlock("p", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("content"))
|
|
}, toDisplayString(_ctx.message), 3)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
|
|
createCommentVNode(" Caution here, message could've been compromised, never use user's input as message "),
|
|
createBaseVNode("p", {
|
|
class: normalizeClass(unref(ns).e("content")),
|
|
innerHTML: _ctx.message
|
|
}, null, 10, ["innerHTML"])
|
|
], 2112))
|
|
]),
|
|
_ctx.showClose ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 2,
|
|
class: normalizeClass(unref(ns).e("closeBtn")),
|
|
onClick: withModifiers(close2, ["stop"])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(Close))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "onClick"])) : createCommentVNode("v-if", true)
|
|
], 46, ["id"]), [
|
|
[vShow, visible.value]
|
|
])
|
|
]),
|
|
_: 3
|
|
}, 8, ["name", "onBeforeEnter", "onBeforeLeave", "onAfterLeave"]);
|
|
};
|
|
}
|
|
});
|
|
var MessageConstructor = _export_sfc(_sfc_main154, [["__file", "message.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/message/src/method.mjs
|
|
var seed = 1;
|
|
var normalizeOptions = (params) => {
|
|
const options = !params || isString(params) || isVNode(params) || isFunction(params) ? { message: params } : params;
|
|
const normalized = {
|
|
...messageDefaults,
|
|
...options
|
|
};
|
|
if (!normalized.appendTo) {
|
|
normalized.appendTo = document.body;
|
|
} else if (isString(normalized.appendTo)) {
|
|
let appendTo = document.querySelector(normalized.appendTo);
|
|
if (!isElement2(appendTo)) {
|
|
debugWarn("ElMessage", "the appendTo option is not an HTMLElement. Falling back to document.body.");
|
|
appendTo = document.body;
|
|
}
|
|
normalized.appendTo = appendTo;
|
|
}
|
|
if (isBoolean2(messageConfig.grouping) && !normalized.grouping) {
|
|
normalized.grouping = messageConfig.grouping;
|
|
}
|
|
if (isNumber2(messageConfig.duration) && normalized.duration === 3e3) {
|
|
normalized.duration = messageConfig.duration;
|
|
}
|
|
if (isNumber2(messageConfig.offset) && normalized.offset === 16) {
|
|
normalized.offset = messageConfig.offset;
|
|
}
|
|
if (isBoolean2(messageConfig.showClose) && !normalized.showClose) {
|
|
normalized.showClose = messageConfig.showClose;
|
|
}
|
|
if (isBoolean2(messageConfig.plain) && !normalized.plain) {
|
|
normalized.plain = messageConfig.plain;
|
|
}
|
|
return normalized;
|
|
};
|
|
var closeMessage = (instance) => {
|
|
const idx = instances.indexOf(instance);
|
|
if (idx === -1)
|
|
return;
|
|
instances.splice(idx, 1);
|
|
const { handler } = instance;
|
|
handler.close();
|
|
};
|
|
var createMessage = ({ appendTo, ...options }, context) => {
|
|
const id = `message_${seed++}`;
|
|
const userOnClose = options.onClose;
|
|
const container = document.createElement("div");
|
|
const props2 = {
|
|
...options,
|
|
id,
|
|
onClose: () => {
|
|
userOnClose == null ? void 0 : userOnClose();
|
|
closeMessage(instance);
|
|
},
|
|
onDestroy: () => {
|
|
render(null, container);
|
|
}
|
|
};
|
|
const vnode = createVNode(MessageConstructor, props2, isFunction(props2.message) || isVNode(props2.message) ? {
|
|
default: isFunction(props2.message) ? props2.message : () => props2.message
|
|
} : null);
|
|
vnode.appContext = context || message._context;
|
|
render(vnode, container);
|
|
appendTo.appendChild(container.firstElementChild);
|
|
const vm = vnode.component;
|
|
const handler = {
|
|
close: () => {
|
|
vm.exposed.close();
|
|
}
|
|
};
|
|
const instance = {
|
|
id,
|
|
vnode,
|
|
vm,
|
|
handler,
|
|
props: vnode.component.props
|
|
};
|
|
return instance;
|
|
};
|
|
var message = (options = {}, context) => {
|
|
if (!isClient)
|
|
return { close: () => void 0 };
|
|
const normalized = normalizeOptions(options);
|
|
if (normalized.grouping && instances.length) {
|
|
const instance2 = instances.find(({ vnode: vm }) => {
|
|
var _a2;
|
|
return ((_a2 = vm.props) == null ? void 0 : _a2.message) === normalized.message;
|
|
});
|
|
if (instance2) {
|
|
instance2.props.repeatNum += 1;
|
|
instance2.props.type = normalized.type;
|
|
return instance2.handler;
|
|
}
|
|
}
|
|
if (isNumber2(messageConfig.max) && instances.length >= messageConfig.max) {
|
|
return { close: () => void 0 };
|
|
}
|
|
const instance = createMessage(normalized, context);
|
|
instances.push(instance);
|
|
return instance.handler;
|
|
};
|
|
messageTypes.forEach((type4) => {
|
|
message[type4] = (options = {}, appContext) => {
|
|
const normalized = normalizeOptions(options);
|
|
return message({ ...normalized, type: type4 }, appContext);
|
|
};
|
|
});
|
|
function closeAll(type4) {
|
|
const instancesToClose = [...instances];
|
|
for (const instance of instancesToClose) {
|
|
if (!type4 || type4 === instance.props.type) {
|
|
instance.handler.close();
|
|
}
|
|
}
|
|
}
|
|
message.closeAll = closeAll;
|
|
message._context = null;
|
|
|
|
// node_modules/element-plus/es/components/message/index.mjs
|
|
var ElMessage = withInstallFunction(message, "$message");
|
|
|
|
// node_modules/element-plus/es/directives/trap-focus/index.mjs
|
|
var FOCUSABLE_CHILDREN = "_trap-focus-children";
|
|
var FOCUS_STACK = [];
|
|
var FOCUS_HANDLER = (e) => {
|
|
var _a2;
|
|
if (FOCUS_STACK.length === 0)
|
|
return;
|
|
const focusableElement = FOCUS_STACK[FOCUS_STACK.length - 1][FOCUSABLE_CHILDREN];
|
|
if (focusableElement.length > 0 && e.code === EVENT_CODE.tab) {
|
|
if (focusableElement.length === 1) {
|
|
e.preventDefault();
|
|
if (document.activeElement !== focusableElement[0]) {
|
|
focusableElement[0].focus();
|
|
}
|
|
return;
|
|
}
|
|
const goingBackward = e.shiftKey;
|
|
const isFirst = e.target === focusableElement[0];
|
|
const isLast = e.target === focusableElement[focusableElement.length - 1];
|
|
if (isFirst && goingBackward) {
|
|
e.preventDefault();
|
|
focusableElement[focusableElement.length - 1].focus();
|
|
}
|
|
if (isLast && !goingBackward) {
|
|
e.preventDefault();
|
|
focusableElement[0].focus();
|
|
}
|
|
if (false) {
|
|
const index = focusableElement.indexOf(e.target);
|
|
if (index !== -1) {
|
|
(_a2 = focusableElement[goingBackward ? index - 1 : index + 1]) == null ? void 0 : _a2.focus();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var TrapFocus = {
|
|
beforeMount(el) {
|
|
el[FOCUSABLE_CHILDREN] = obtainAllFocusableElements(el);
|
|
FOCUS_STACK.push(el);
|
|
if (FOCUS_STACK.length <= 1) {
|
|
document.addEventListener("keydown", FOCUS_HANDLER);
|
|
}
|
|
},
|
|
updated(el) {
|
|
nextTick(() => {
|
|
el[FOCUSABLE_CHILDREN] = obtainAllFocusableElements(el);
|
|
});
|
|
},
|
|
unmounted() {
|
|
FOCUS_STACK.shift();
|
|
if (FOCUS_STACK.length === 0) {
|
|
document.removeEventListener("keydown", FOCUS_HANDLER);
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/message-box/src/index.mjs
|
|
var _sfc_main155 = defineComponent({
|
|
name: "ElMessageBox",
|
|
directives: {
|
|
TrapFocus
|
|
},
|
|
components: {
|
|
ElButton,
|
|
ElFocusTrap,
|
|
ElInput,
|
|
ElOverlay,
|
|
ElIcon,
|
|
...TypeComponents
|
|
},
|
|
inheritAttrs: false,
|
|
props: {
|
|
buttonSize: {
|
|
type: String,
|
|
validator: isValidComponentSize
|
|
},
|
|
modal: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
lockScroll: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
showClose: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
closeOnClickModal: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
closeOnPressEscape: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
closeOnHashChange: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
center: Boolean,
|
|
draggable: Boolean,
|
|
overflow: Boolean,
|
|
roundButton: {
|
|
default: false,
|
|
type: Boolean
|
|
},
|
|
container: {
|
|
type: String,
|
|
default: "body"
|
|
},
|
|
boxType: {
|
|
type: String,
|
|
default: ""
|
|
}
|
|
},
|
|
emits: ["vanish", "action"],
|
|
setup(props2, { emit }) {
|
|
const {
|
|
locale,
|
|
zIndex: zIndex2,
|
|
ns,
|
|
size: btnSize
|
|
} = useGlobalComponentSettings("message-box", computed(() => props2.buttonSize));
|
|
const { t } = locale;
|
|
const { nextZIndex } = zIndex2;
|
|
const visible = ref(false);
|
|
const state = reactive({
|
|
autofocus: true,
|
|
beforeClose: null,
|
|
callback: null,
|
|
cancelButtonText: "",
|
|
cancelButtonClass: "",
|
|
confirmButtonText: "",
|
|
confirmButtonClass: "",
|
|
customClass: "",
|
|
customStyle: {},
|
|
dangerouslyUseHTMLString: false,
|
|
distinguishCancelAndClose: false,
|
|
icon: "",
|
|
closeIcon: "",
|
|
inputPattern: null,
|
|
inputPlaceholder: "",
|
|
inputType: "text",
|
|
inputValue: "",
|
|
inputValidator: void 0,
|
|
inputErrorMessage: "",
|
|
message: "",
|
|
modalFade: true,
|
|
modalClass: "",
|
|
showCancelButton: false,
|
|
showConfirmButton: true,
|
|
type: "",
|
|
title: void 0,
|
|
showInput: false,
|
|
action: "",
|
|
confirmButtonLoading: false,
|
|
cancelButtonLoading: false,
|
|
confirmButtonLoadingIcon: markRaw(loading_default),
|
|
cancelButtonLoadingIcon: markRaw(loading_default),
|
|
confirmButtonDisabled: false,
|
|
editorErrorMessage: "",
|
|
validateError: false,
|
|
zIndex: nextZIndex()
|
|
});
|
|
const typeClass = computed(() => {
|
|
const type4 = state.type;
|
|
return { [ns.bm("icon", type4)]: type4 && TypeComponentsMap[type4] };
|
|
});
|
|
const contentId = useId();
|
|
const inputId = useId();
|
|
const iconComponent = computed(() => {
|
|
const type4 = state.type;
|
|
return state.icon || type4 && TypeComponentsMap[type4] || "";
|
|
});
|
|
const hasMessage = computed(() => !!state.message);
|
|
const rootRef = ref();
|
|
const headerRef = ref();
|
|
const focusStartRef = ref();
|
|
const inputRef = ref();
|
|
const confirmRef = ref();
|
|
const confirmButtonClasses = computed(() => state.confirmButtonClass);
|
|
watch(() => state.inputValue, async (val) => {
|
|
await nextTick();
|
|
if (props2.boxType === "prompt" && val) {
|
|
validate();
|
|
}
|
|
}, { immediate: true });
|
|
watch(() => visible.value, (val) => {
|
|
var _a2, _b;
|
|
if (val) {
|
|
if (props2.boxType !== "prompt") {
|
|
if (state.autofocus) {
|
|
focusStartRef.value = (_b = (_a2 = confirmRef.value) == null ? void 0 : _a2.$el) != null ? _b : rootRef.value;
|
|
} else {
|
|
focusStartRef.value = rootRef.value;
|
|
}
|
|
}
|
|
state.zIndex = nextZIndex();
|
|
}
|
|
if (props2.boxType !== "prompt")
|
|
return;
|
|
if (val) {
|
|
nextTick().then(() => {
|
|
var _a22;
|
|
if (inputRef.value && inputRef.value.$el) {
|
|
if (state.autofocus) {
|
|
focusStartRef.value = (_a22 = getInputElement()) != null ? _a22 : rootRef.value;
|
|
} else {
|
|
focusStartRef.value = rootRef.value;
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
state.editorErrorMessage = "";
|
|
state.validateError = false;
|
|
}
|
|
});
|
|
const draggable2 = computed(() => props2.draggable);
|
|
const overflow = computed(() => props2.overflow);
|
|
useDraggable(rootRef, headerRef, draggable2, overflow);
|
|
onMounted(async () => {
|
|
await nextTick();
|
|
if (props2.closeOnHashChange) {
|
|
window.addEventListener("hashchange", doClose);
|
|
}
|
|
});
|
|
onBeforeUnmount(() => {
|
|
if (props2.closeOnHashChange) {
|
|
window.removeEventListener("hashchange", doClose);
|
|
}
|
|
});
|
|
function doClose() {
|
|
if (!visible.value)
|
|
return;
|
|
visible.value = false;
|
|
nextTick(() => {
|
|
if (state.action)
|
|
emit("action", state.action);
|
|
});
|
|
}
|
|
const handleWrapperClick = () => {
|
|
if (props2.closeOnClickModal) {
|
|
handleAction(state.distinguishCancelAndClose ? "close" : "cancel");
|
|
}
|
|
};
|
|
const overlayEvent = useSameTarget(handleWrapperClick);
|
|
const handleInputEnter = (e) => {
|
|
if (state.inputType !== "textarea") {
|
|
e.preventDefault();
|
|
return handleAction("confirm");
|
|
}
|
|
};
|
|
const handleAction = (action) => {
|
|
var _a2;
|
|
if (props2.boxType === "prompt" && action === "confirm" && !validate()) {
|
|
return;
|
|
}
|
|
state.action = action;
|
|
if (state.beforeClose) {
|
|
(_a2 = state.beforeClose) == null ? void 0 : _a2.call(state, action, state, doClose);
|
|
} else {
|
|
doClose();
|
|
}
|
|
};
|
|
const validate = () => {
|
|
if (props2.boxType === "prompt") {
|
|
const inputPattern = state.inputPattern;
|
|
if (inputPattern && !inputPattern.test(state.inputValue || "")) {
|
|
state.editorErrorMessage = state.inputErrorMessage || t("el.messagebox.error");
|
|
state.validateError = true;
|
|
return false;
|
|
}
|
|
const inputValidator = state.inputValidator;
|
|
if (isFunction(inputValidator)) {
|
|
const validateResult = inputValidator(state.inputValue);
|
|
if (validateResult === false) {
|
|
state.editorErrorMessage = state.inputErrorMessage || t("el.messagebox.error");
|
|
state.validateError = true;
|
|
return false;
|
|
}
|
|
if (isString(validateResult)) {
|
|
state.editorErrorMessage = validateResult;
|
|
state.validateError = true;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
state.editorErrorMessage = "";
|
|
state.validateError = false;
|
|
return true;
|
|
};
|
|
const getInputElement = () => {
|
|
var _a2, _b;
|
|
const inputRefs = (_a2 = inputRef.value) == null ? void 0 : _a2.$refs;
|
|
return (_b = inputRefs == null ? void 0 : inputRefs.input) != null ? _b : inputRefs == null ? void 0 : inputRefs.textarea;
|
|
};
|
|
const handleClose = () => {
|
|
handleAction("close");
|
|
};
|
|
const onCloseRequested = () => {
|
|
if (props2.closeOnPressEscape) {
|
|
handleClose();
|
|
}
|
|
};
|
|
if (props2.lockScroll) {
|
|
useLockscreen(visible);
|
|
}
|
|
return {
|
|
...toRefs(state),
|
|
ns,
|
|
overlayEvent,
|
|
visible,
|
|
hasMessage,
|
|
typeClass,
|
|
contentId,
|
|
inputId,
|
|
btnSize,
|
|
iconComponent,
|
|
confirmButtonClasses,
|
|
rootRef,
|
|
focusStartRef,
|
|
headerRef,
|
|
inputRef,
|
|
confirmRef,
|
|
doClose,
|
|
handleClose,
|
|
onCloseRequested,
|
|
handleWrapperClick,
|
|
handleInputEnter,
|
|
handleAction,
|
|
t
|
|
};
|
|
}
|
|
});
|
|
function _sfc_render28(_ctx, _cache, $props, $setup, $data, $options) {
|
|
const _component_el_icon = resolveComponent("el-icon");
|
|
const _component_el_input = resolveComponent("el-input");
|
|
const _component_el_button = resolveComponent("el-button");
|
|
const _component_el_focus_trap = resolveComponent("el-focus-trap");
|
|
const _component_el_overlay = resolveComponent("el-overlay");
|
|
return openBlock(), createBlock(Transition, {
|
|
name: "fade-in-linear",
|
|
onAfterLeave: ($event) => _ctx.$emit("vanish"),
|
|
persisted: ""
|
|
}, {
|
|
default: withCtx(() => [
|
|
withDirectives(createVNode(_component_el_overlay, {
|
|
"z-index": _ctx.zIndex,
|
|
"overlay-class": [_ctx.ns.is("message-box"), _ctx.modalClass],
|
|
mask: _ctx.modal
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
role: "dialog",
|
|
"aria-label": _ctx.title,
|
|
"aria-modal": "true",
|
|
"aria-describedby": !_ctx.showInput ? _ctx.contentId : void 0,
|
|
class: normalizeClass(`${_ctx.ns.namespace.value}-overlay-message-box`),
|
|
onClick: _ctx.overlayEvent.onClick,
|
|
onMousedown: _ctx.overlayEvent.onMousedown,
|
|
onMouseup: _ctx.overlayEvent.onMouseup
|
|
}, [
|
|
createVNode(_component_el_focus_trap, {
|
|
loop: "",
|
|
trapped: _ctx.visible,
|
|
"focus-trap-el": _ctx.rootRef,
|
|
"focus-start-el": _ctx.focusStartRef,
|
|
onReleaseRequested: _ctx.onCloseRequested
|
|
}, {
|
|
default: withCtx(() => [
|
|
createBaseVNode("div", {
|
|
ref: "rootRef",
|
|
class: normalizeClass([
|
|
_ctx.ns.b(),
|
|
_ctx.customClass,
|
|
_ctx.ns.is("draggable", _ctx.draggable),
|
|
{ [_ctx.ns.m("center")]: _ctx.center }
|
|
]),
|
|
style: normalizeStyle(_ctx.customStyle),
|
|
tabindex: "-1",
|
|
onClick: withModifiers(() => {
|
|
}, ["stop"])
|
|
}, [
|
|
_ctx.title !== null && _ctx.title !== void 0 ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
ref: "headerRef",
|
|
class: normalizeClass([_ctx.ns.e("header"), { "show-close": _ctx.showClose }])
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.ns.e("title"))
|
|
}, [
|
|
_ctx.iconComponent && _ctx.center ? (openBlock(), createBlock(_component_el_icon, {
|
|
key: 0,
|
|
class: normalizeClass([_ctx.ns.e("status"), _ctx.typeClass])
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.iconComponent)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true),
|
|
createBaseVNode("span", null, toDisplayString(_ctx.title), 1)
|
|
], 2),
|
|
_ctx.showClose ? (openBlock(), createElementBlock("button", {
|
|
key: 0,
|
|
type: "button",
|
|
class: normalizeClass(_ctx.ns.e("headerbtn")),
|
|
"aria-label": _ctx.t("el.messagebox.close"),
|
|
onClick: ($event) => _ctx.handleAction(_ctx.distinguishCancelAndClose ? "close" : "cancel"),
|
|
onKeydown: withKeys(withModifiers(($event) => _ctx.handleAction(_ctx.distinguishCancelAndClose ? "close" : "cancel"), ["prevent"]), ["enter"])
|
|
}, [
|
|
createVNode(_component_el_icon, {
|
|
class: normalizeClass(_ctx.ns.e("close"))
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.closeIcon || "close")))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])
|
|
], 42, ["aria-label", "onClick", "onKeydown"])) : createCommentVNode("v-if", true)
|
|
], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
id: _ctx.contentId,
|
|
class: normalizeClass(_ctx.ns.e("content"))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.ns.e("container"))
|
|
}, [
|
|
_ctx.iconComponent && !_ctx.center && _ctx.hasMessage ? (openBlock(), createBlock(_component_el_icon, {
|
|
key: 0,
|
|
class: normalizeClass([_ctx.ns.e("status"), _ctx.typeClass])
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.iconComponent)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true),
|
|
_ctx.hasMessage ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(_ctx.ns.e("message"))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default", {}, () => [
|
|
!_ctx.dangerouslyUseHTMLString ? (openBlock(), createBlock(resolveDynamicComponent(_ctx.showInput ? "label" : "p"), {
|
|
key: 0,
|
|
for: _ctx.showInput ? _ctx.inputId : void 0
|
|
}, {
|
|
default: withCtx(() => [
|
|
createTextVNode(toDisplayString(!_ctx.dangerouslyUseHTMLString ? _ctx.message : ""), 1)
|
|
]),
|
|
_: 1
|
|
}, 8, ["for"])) : (openBlock(), createBlock(resolveDynamicComponent(_ctx.showInput ? "label" : "p"), {
|
|
key: 1,
|
|
for: _ctx.showInput ? _ctx.inputId : void 0,
|
|
innerHTML: _ctx.message
|
|
}, null, 8, ["for", "innerHTML"]))
|
|
])
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 2),
|
|
withDirectives(createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.ns.e("input"))
|
|
}, [
|
|
createVNode(_component_el_input, {
|
|
id: _ctx.inputId,
|
|
ref: "inputRef",
|
|
modelValue: _ctx.inputValue,
|
|
"onUpdate:modelValue": ($event) => _ctx.inputValue = $event,
|
|
type: _ctx.inputType,
|
|
placeholder: _ctx.inputPlaceholder,
|
|
"aria-invalid": _ctx.validateError,
|
|
class: normalizeClass({ invalid: _ctx.validateError }),
|
|
onKeydown: withKeys(_ctx.handleInputEnter, ["enter"])
|
|
}, null, 8, ["id", "modelValue", "onUpdate:modelValue", "type", "placeholder", "aria-invalid", "class", "onKeydown"]),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.ns.e("errormsg")),
|
|
style: normalizeStyle({
|
|
visibility: !!_ctx.editorErrorMessage ? "visible" : "hidden"
|
|
})
|
|
}, toDisplayString(_ctx.editorErrorMessage), 7)
|
|
], 2), [
|
|
[vShow, _ctx.showInput]
|
|
])
|
|
], 10, ["id"]),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.ns.e("btns"))
|
|
}, [
|
|
_ctx.showCancelButton ? (openBlock(), createBlock(_component_el_button, {
|
|
key: 0,
|
|
loading: _ctx.cancelButtonLoading,
|
|
"loading-icon": _ctx.cancelButtonLoadingIcon,
|
|
class: normalizeClass([_ctx.cancelButtonClass]),
|
|
round: _ctx.roundButton,
|
|
size: _ctx.btnSize,
|
|
onClick: ($event) => _ctx.handleAction("cancel"),
|
|
onKeydown: withKeys(withModifiers(($event) => _ctx.handleAction("cancel"), ["prevent"]), ["enter"])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createTextVNode(toDisplayString(_ctx.cancelButtonText || _ctx.t("el.messagebox.cancel")), 1)
|
|
]),
|
|
_: 1
|
|
}, 8, ["loading", "loading-icon", "class", "round", "size", "onClick", "onKeydown"])) : createCommentVNode("v-if", true),
|
|
withDirectives(createVNode(_component_el_button, {
|
|
ref: "confirmRef",
|
|
type: "primary",
|
|
loading: _ctx.confirmButtonLoading,
|
|
"loading-icon": _ctx.confirmButtonLoadingIcon,
|
|
class: normalizeClass([_ctx.confirmButtonClasses]),
|
|
round: _ctx.roundButton,
|
|
disabled: _ctx.confirmButtonDisabled,
|
|
size: _ctx.btnSize,
|
|
onClick: ($event) => _ctx.handleAction("confirm"),
|
|
onKeydown: withKeys(withModifiers(($event) => _ctx.handleAction("confirm"), ["prevent"]), ["enter"])
|
|
}, {
|
|
default: withCtx(() => [
|
|
createTextVNode(toDisplayString(_ctx.confirmButtonText || _ctx.t("el.messagebox.confirm")), 1)
|
|
]),
|
|
_: 1
|
|
}, 8, ["loading", "loading-icon", "class", "round", "disabled", "size", "onClick", "onKeydown"]), [
|
|
[vShow, _ctx.showConfirmButton]
|
|
])
|
|
], 2)
|
|
], 14, ["onClick"])
|
|
]),
|
|
_: 3
|
|
}, 8, ["trapped", "focus-trap-el", "focus-start-el", "onReleaseRequested"])
|
|
], 42, ["aria-label", "aria-describedby", "onClick", "onMousedown", "onMouseup"])
|
|
]),
|
|
_: 3
|
|
}, 8, ["z-index", "overlay-class", "mask"]), [
|
|
[vShow, _ctx.visible]
|
|
])
|
|
]),
|
|
_: 3
|
|
}, 8, ["onAfterLeave"]);
|
|
}
|
|
var MessageBoxConstructor = _export_sfc(_sfc_main155, [["render", _sfc_render28], ["__file", "index.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/message-box/src/messageBox.mjs
|
|
var messageInstance = new Map();
|
|
var getAppendToElement = (props2) => {
|
|
let appendTo = document.body;
|
|
if (props2.appendTo) {
|
|
if (isString(props2.appendTo)) {
|
|
appendTo = document.querySelector(props2.appendTo);
|
|
}
|
|
if (isElement2(props2.appendTo)) {
|
|
appendTo = props2.appendTo;
|
|
}
|
|
if (!isElement2(appendTo)) {
|
|
debugWarn("ElMessageBox", "the appendTo option is not an HTMLElement. Falling back to document.body.");
|
|
appendTo = document.body;
|
|
}
|
|
}
|
|
return appendTo;
|
|
};
|
|
var initInstance = (props2, container, appContext = null) => {
|
|
const vnode = createVNode(MessageBoxConstructor, props2, isFunction(props2.message) || isVNode(props2.message) ? {
|
|
default: isFunction(props2.message) ? props2.message : () => props2.message
|
|
} : null);
|
|
vnode.appContext = appContext;
|
|
render(vnode, container);
|
|
getAppendToElement(props2).appendChild(container.firstElementChild);
|
|
return vnode.component;
|
|
};
|
|
var genContainer = () => {
|
|
return document.createElement("div");
|
|
};
|
|
var showMessage = (options, appContext) => {
|
|
const container = genContainer();
|
|
options.onVanish = () => {
|
|
render(null, container);
|
|
messageInstance.delete(vm);
|
|
};
|
|
options.onAction = (action) => {
|
|
const currentMsg = messageInstance.get(vm);
|
|
let resolve;
|
|
if (options.showInput) {
|
|
resolve = { value: vm.inputValue, action };
|
|
} else {
|
|
resolve = action;
|
|
}
|
|
if (options.callback) {
|
|
options.callback(resolve, instance.proxy);
|
|
} else {
|
|
if (action === "cancel" || action === "close") {
|
|
if (options.distinguishCancelAndClose && action !== "cancel") {
|
|
currentMsg.reject("close");
|
|
} else {
|
|
currentMsg.reject("cancel");
|
|
}
|
|
} else {
|
|
currentMsg.resolve(resolve);
|
|
}
|
|
}
|
|
};
|
|
const instance = initInstance(options, container, appContext);
|
|
const vm = instance.proxy;
|
|
for (const prop in options) {
|
|
if (hasOwn(options, prop) && !hasOwn(vm.$props, prop)) {
|
|
if (prop === "closeIcon" && isObject(options[prop])) {
|
|
vm[prop] = markRaw(options[prop]);
|
|
} else {
|
|
vm[prop] = options[prop];
|
|
}
|
|
}
|
|
}
|
|
vm.visible = true;
|
|
return vm;
|
|
};
|
|
function MessageBox(options, appContext = null) {
|
|
if (!isClient)
|
|
return Promise.reject();
|
|
let callback;
|
|
if (isString(options) || isVNode(options)) {
|
|
options = {
|
|
message: options
|
|
};
|
|
} else {
|
|
callback = options.callback;
|
|
}
|
|
return new Promise((resolve, reject2) => {
|
|
const vm = showMessage(options, appContext != null ? appContext : MessageBox._context);
|
|
messageInstance.set(vm, {
|
|
options,
|
|
callback,
|
|
resolve,
|
|
reject: reject2
|
|
});
|
|
});
|
|
}
|
|
var MESSAGE_BOX_VARIANTS = ["alert", "confirm", "prompt"];
|
|
var MESSAGE_BOX_DEFAULT_OPTS = {
|
|
alert: { closeOnPressEscape: false, closeOnClickModal: false },
|
|
confirm: { showCancelButton: true },
|
|
prompt: { showCancelButton: true, showInput: true }
|
|
};
|
|
MESSAGE_BOX_VARIANTS.forEach((boxType) => {
|
|
MessageBox[boxType] = messageBoxFactory(boxType);
|
|
});
|
|
function messageBoxFactory(boxType) {
|
|
return (message2, title, options, appContext) => {
|
|
let titleOrOpts = "";
|
|
if (isObject(title)) {
|
|
options = title;
|
|
titleOrOpts = "";
|
|
} else if (isUndefined2(title)) {
|
|
titleOrOpts = "";
|
|
} else {
|
|
titleOrOpts = title;
|
|
}
|
|
return MessageBox(Object.assign({
|
|
title: titleOrOpts,
|
|
message: message2,
|
|
type: "",
|
|
...MESSAGE_BOX_DEFAULT_OPTS[boxType]
|
|
}, options, {
|
|
boxType
|
|
}), appContext);
|
|
};
|
|
}
|
|
MessageBox.close = () => {
|
|
messageInstance.forEach((_2, vm) => {
|
|
vm.doClose();
|
|
});
|
|
messageInstance.clear();
|
|
};
|
|
MessageBox._context = null;
|
|
|
|
// node_modules/element-plus/es/components/message-box/index.mjs
|
|
var _MessageBox = MessageBox;
|
|
_MessageBox.install = (app) => {
|
|
_MessageBox._context = app._context;
|
|
app.config.globalProperties.$msgbox = _MessageBox;
|
|
app.config.globalProperties.$messageBox = _MessageBox;
|
|
app.config.globalProperties.$alert = _MessageBox.alert;
|
|
app.config.globalProperties.$confirm = _MessageBox.confirm;
|
|
app.config.globalProperties.$prompt = _MessageBox.prompt;
|
|
};
|
|
var ElMessageBox = _MessageBox;
|
|
|
|
// node_modules/element-plus/es/components/notification/src/notification.mjs
|
|
var notificationTypes = [
|
|
"primary",
|
|
"success",
|
|
"info",
|
|
"warning",
|
|
"error"
|
|
];
|
|
var notificationProps = buildProps({
|
|
customClass: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
dangerouslyUseHTMLString: Boolean,
|
|
duration: {
|
|
type: Number,
|
|
default: 4500
|
|
},
|
|
icon: {
|
|
type: iconPropType
|
|
},
|
|
id: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
message: {
|
|
type: definePropType([
|
|
String,
|
|
Object,
|
|
Function
|
|
]),
|
|
default: ""
|
|
},
|
|
offset: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
onClick: {
|
|
type: definePropType(Function),
|
|
default: () => void 0
|
|
},
|
|
onClose: {
|
|
type: definePropType(Function),
|
|
required: true
|
|
},
|
|
position: {
|
|
type: String,
|
|
values: ["top-right", "top-left", "bottom-right", "bottom-left"],
|
|
default: "top-right"
|
|
},
|
|
showClose: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
title: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
type: {
|
|
type: String,
|
|
values: [...notificationTypes, ""],
|
|
default: ""
|
|
},
|
|
zIndex: Number,
|
|
closeIcon: {
|
|
type: iconPropType,
|
|
default: close_default
|
|
}
|
|
});
|
|
var notificationEmits = {
|
|
destroy: () => true
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/notification/src/notification2.mjs
|
|
var __default__115 = defineComponent({
|
|
name: "ElNotification"
|
|
});
|
|
var _sfc_main156 = defineComponent({
|
|
...__default__115,
|
|
props: notificationProps,
|
|
emits: notificationEmits,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const { ns, zIndex: zIndex2 } = useGlobalComponentSettings("notification");
|
|
const { nextZIndex, currentZIndex } = zIndex2;
|
|
const visible = ref(false);
|
|
let timer = void 0;
|
|
const typeClass = computed(() => {
|
|
const type4 = props2.type;
|
|
return type4 && TypeComponentsMap[props2.type] ? ns.m(type4) : "";
|
|
});
|
|
const iconComponent = computed(() => {
|
|
if (!props2.type)
|
|
return props2.icon;
|
|
return TypeComponentsMap[props2.type] || props2.icon;
|
|
});
|
|
const horizontalClass = computed(() => props2.position.endsWith("right") ? "right" : "left");
|
|
const verticalProperty = computed(() => props2.position.startsWith("top") ? "top" : "bottom");
|
|
const positionStyle = computed(() => {
|
|
var _a2;
|
|
return {
|
|
[verticalProperty.value]: `${props2.offset}px`,
|
|
zIndex: (_a2 = props2.zIndex) != null ? _a2 : currentZIndex.value
|
|
};
|
|
});
|
|
function startTimer() {
|
|
if (props2.duration > 0) {
|
|
({ stop: timer } = useTimeoutFn(() => {
|
|
if (visible.value)
|
|
close2();
|
|
}, props2.duration));
|
|
}
|
|
}
|
|
function clearTimer() {
|
|
timer == null ? void 0 : timer();
|
|
}
|
|
function close2() {
|
|
visible.value = false;
|
|
}
|
|
function onKeydown({ code }) {
|
|
if (code === EVENT_CODE.delete || code === EVENT_CODE.backspace) {
|
|
clearTimer();
|
|
} else if (code === EVENT_CODE.esc) {
|
|
if (visible.value) {
|
|
close2();
|
|
}
|
|
} else {
|
|
startTimer();
|
|
}
|
|
}
|
|
onMounted(() => {
|
|
startTimer();
|
|
nextZIndex();
|
|
visible.value = true;
|
|
});
|
|
useEventListener(document, "keydown", onKeydown);
|
|
expose({
|
|
visible,
|
|
close: close2
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(Transition, {
|
|
name: unref(ns).b("fade"),
|
|
onBeforeLeave: _ctx.onClose,
|
|
onAfterLeave: ($event) => _ctx.$emit("destroy"),
|
|
persisted: ""
|
|
}, {
|
|
default: withCtx(() => [
|
|
withDirectives(createBaseVNode("div", {
|
|
id: _ctx.id,
|
|
class: normalizeClass([unref(ns).b(), _ctx.customClass, unref(horizontalClass)]),
|
|
style: normalizeStyle(unref(positionStyle)),
|
|
role: "alert",
|
|
onMouseenter: clearTimer,
|
|
onMouseleave: startTimer,
|
|
onClick: _ctx.onClick
|
|
}, [
|
|
unref(iconComponent) ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("icon"), unref(typeClass)])
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(unref(iconComponent))))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("group"))
|
|
}, [
|
|
createBaseVNode("h2", {
|
|
class: normalizeClass(unref(ns).e("title")),
|
|
textContent: toDisplayString(_ctx.title)
|
|
}, null, 10, ["textContent"]),
|
|
withDirectives(createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("content")),
|
|
style: normalizeStyle(!!_ctx.title ? void 0 : { margin: 0 })
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default", {}, () => [
|
|
!_ctx.dangerouslyUseHTMLString ? (openBlock(), createElementBlock("p", { key: 0 }, toDisplayString(_ctx.message), 1)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
|
|
createCommentVNode(" Caution here, message could've been compromised, never use user's input as message "),
|
|
createBaseVNode("p", { innerHTML: _ctx.message }, null, 8, ["innerHTML"])
|
|
], 2112))
|
|
])
|
|
], 6), [
|
|
[vShow, _ctx.message]
|
|
]),
|
|
_ctx.showClose ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("closeBtn")),
|
|
onClick: withModifiers(close2, ["stop"])
|
|
}, {
|
|
default: withCtx(() => [
|
|
(openBlock(), createBlock(resolveDynamicComponent(_ctx.closeIcon)))
|
|
]),
|
|
_: 1
|
|
}, 8, ["class", "onClick"])) : createCommentVNode("v-if", true)
|
|
], 2)
|
|
], 46, ["id", "onClick"]), [
|
|
[vShow, visible.value]
|
|
])
|
|
]),
|
|
_: 3
|
|
}, 8, ["name", "onBeforeLeave", "onAfterLeave"]);
|
|
};
|
|
}
|
|
});
|
|
var NotificationConstructor = _export_sfc(_sfc_main156, [["__file", "notification.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/notification/src/notify.mjs
|
|
var notifications = {
|
|
"top-left": [],
|
|
"top-right": [],
|
|
"bottom-left": [],
|
|
"bottom-right": []
|
|
};
|
|
var GAP_SIZE = 16;
|
|
var seed2 = 1;
|
|
var notify = function(options = {}, context) {
|
|
if (!isClient)
|
|
return { close: () => void 0 };
|
|
if (isString(options) || isVNode(options)) {
|
|
options = { message: options };
|
|
}
|
|
const position = options.position || "top-right";
|
|
let verticalOffset = options.offset || 0;
|
|
notifications[position].forEach(({ vm: vm2 }) => {
|
|
var _a2;
|
|
verticalOffset += (((_a2 = vm2.el) == null ? void 0 : _a2.offsetHeight) || 0) + GAP_SIZE;
|
|
});
|
|
verticalOffset += GAP_SIZE;
|
|
const id = `notification_${seed2++}`;
|
|
const userOnClose = options.onClose;
|
|
const props2 = {
|
|
...options,
|
|
offset: verticalOffset,
|
|
id,
|
|
onClose: () => {
|
|
close(id, position, userOnClose);
|
|
}
|
|
};
|
|
let appendTo = document.body;
|
|
if (isElement2(options.appendTo)) {
|
|
appendTo = options.appendTo;
|
|
} else if (isString(options.appendTo)) {
|
|
appendTo = document.querySelector(options.appendTo);
|
|
}
|
|
if (!isElement2(appendTo)) {
|
|
debugWarn("ElNotification", "the appendTo option is not an HTMLElement. Falling back to document.body.");
|
|
appendTo = document.body;
|
|
}
|
|
const container = document.createElement("div");
|
|
const vm = createVNode(NotificationConstructor, props2, isFunction(props2.message) ? props2.message : isVNode(props2.message) ? () => props2.message : null);
|
|
vm.appContext = isUndefined2(context) ? notify._context : context;
|
|
vm.props.onDestroy = () => {
|
|
render(null, container);
|
|
};
|
|
render(vm, container);
|
|
notifications[position].push({ vm });
|
|
appendTo.appendChild(container.firstElementChild);
|
|
return {
|
|
close: () => {
|
|
vm.component.exposed.visible.value = false;
|
|
}
|
|
};
|
|
};
|
|
notificationTypes.forEach((type4) => {
|
|
notify[type4] = (options = {}, appContext) => {
|
|
if (isString(options) || isVNode(options)) {
|
|
options = {
|
|
message: options
|
|
};
|
|
}
|
|
return notify({ ...options, type: type4 }, appContext);
|
|
};
|
|
});
|
|
function close(id, position, userOnClose) {
|
|
const orientedNotifications = notifications[position];
|
|
const idx = orientedNotifications.findIndex(({ vm: vm2 }) => {
|
|
var _a2;
|
|
return ((_a2 = vm2.component) == null ? void 0 : _a2.props.id) === id;
|
|
});
|
|
if (idx === -1)
|
|
return;
|
|
const { vm } = orientedNotifications[idx];
|
|
if (!vm)
|
|
return;
|
|
userOnClose == null ? void 0 : userOnClose(vm);
|
|
const removedHeight = vm.el.offsetHeight;
|
|
const verticalPos = position.split("-")[0];
|
|
orientedNotifications.splice(idx, 1);
|
|
const len = orientedNotifications.length;
|
|
if (len < 1)
|
|
return;
|
|
for (let i = idx; i < len; i++) {
|
|
const { el, component: component2 } = orientedNotifications[i].vm;
|
|
const pos = Number.parseInt(el.style[verticalPos], 10) - removedHeight - GAP_SIZE;
|
|
component2.props.offset = pos;
|
|
}
|
|
}
|
|
function closeAll2() {
|
|
for (const orientedNotifications of Object.values(notifications)) {
|
|
orientedNotifications.forEach(({ vm }) => {
|
|
vm.component.exposed.visible.value = false;
|
|
});
|
|
}
|
|
}
|
|
notify.closeAll = closeAll2;
|
|
notify._context = null;
|
|
|
|
// node_modules/element-plus/es/components/notification/index.mjs
|
|
var ElNotification = withInstallFunction(notify, "$notify");
|
|
|
|
// node_modules/element-plus/es/components/tooltip-v2/src/common.mjs
|
|
var tooltipV2CommonProps = buildProps({
|
|
nowrap: Boolean
|
|
});
|
|
var TooltipV2Sides = ((TooltipV2Sides2) => {
|
|
TooltipV2Sides2["top"] = "top";
|
|
TooltipV2Sides2["bottom"] = "bottom";
|
|
TooltipV2Sides2["left"] = "left";
|
|
TooltipV2Sides2["right"] = "right";
|
|
return TooltipV2Sides2;
|
|
})(TooltipV2Sides || {});
|
|
var tooltipV2Sides = Object.values(TooltipV2Sides);
|
|
var tooltipV2OppositeSide = {
|
|
["top"]: "bottom",
|
|
["bottom"]: "top",
|
|
["left"]: "right",
|
|
["right"]: "left"
|
|
};
|
|
var tooltipV2ArrowBorders = {
|
|
["top"]: ["left", "top"],
|
|
["bottom"]: ["bottom", "right"],
|
|
["left"]: ["bottom", "left"],
|
|
["right"]: ["top", "right"]
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/tooltip-v2/src/arrow.mjs
|
|
var tooltipV2ArrowProps = buildProps({
|
|
width: {
|
|
type: Number,
|
|
default: 10
|
|
},
|
|
height: {
|
|
type: Number,
|
|
default: 10
|
|
},
|
|
style: {
|
|
type: definePropType(Object),
|
|
default: null
|
|
}
|
|
});
|
|
var tooltipV2ArrowSpecialProps = buildProps({
|
|
side: {
|
|
type: definePropType(String),
|
|
values: tooltipV2Sides,
|
|
required: true
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tooltip-v2/src/content.mjs
|
|
var tooltipV2Strategies = ["absolute", "fixed"];
|
|
var tooltipV2Placements = [
|
|
"top-start",
|
|
"top-end",
|
|
"top",
|
|
"bottom-start",
|
|
"bottom-end",
|
|
"bottom",
|
|
"left-start",
|
|
"left-end",
|
|
"left",
|
|
"right-start",
|
|
"right-end",
|
|
"right"
|
|
];
|
|
var tooltipV2ContentProps = buildProps({
|
|
arrowPadding: {
|
|
type: definePropType(Number),
|
|
default: 5
|
|
},
|
|
effect: {
|
|
type: definePropType(String),
|
|
default: "light"
|
|
},
|
|
contentClass: String,
|
|
placement: {
|
|
type: definePropType(String),
|
|
values: tooltipV2Placements,
|
|
default: "bottom"
|
|
},
|
|
reference: {
|
|
type: definePropType(Object),
|
|
default: null
|
|
},
|
|
offset: {
|
|
type: Number,
|
|
default: 8
|
|
},
|
|
strategy: {
|
|
type: definePropType(String),
|
|
values: tooltipV2Strategies,
|
|
default: "absolute"
|
|
},
|
|
showArrow: Boolean,
|
|
...useAriaProps(["ariaLabel"])
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tooltip-v2/src/root.mjs
|
|
var tooltipV2RootProps = buildProps({
|
|
delayDuration: {
|
|
type: Number,
|
|
default: 300
|
|
},
|
|
defaultOpen: Boolean,
|
|
open: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
onOpenChange: {
|
|
type: definePropType(Function)
|
|
},
|
|
"onUpdate:open": {
|
|
type: definePropType(Function)
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tooltip-v2/src/trigger2.mjs
|
|
var EventHandler = {
|
|
type: definePropType(Function)
|
|
};
|
|
var tooltipV2TriggerProps = buildProps({
|
|
onBlur: EventHandler,
|
|
onClick: EventHandler,
|
|
onFocus: EventHandler,
|
|
onMouseDown: EventHandler,
|
|
onMouseEnter: EventHandler,
|
|
onMouseLeave: EventHandler
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tooltip-v2/src/tooltip2.mjs
|
|
var tooltipV2Props = buildProps({
|
|
...tooltipV2RootProps,
|
|
...tooltipV2ArrowProps,
|
|
...tooltipV2TriggerProps,
|
|
...tooltipV2ContentProps,
|
|
alwaysOn: Boolean,
|
|
fullTransition: Boolean,
|
|
transitionProps: {
|
|
type: definePropType(Object),
|
|
default: null
|
|
},
|
|
teleported: Boolean,
|
|
to: {
|
|
type: definePropType(String),
|
|
default: "body"
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tooltip-v2/src/constants.mjs
|
|
var tooltipV2RootKey = Symbol("tooltipV2");
|
|
var tooltipV2ContentKey = Symbol("tooltipV2Content");
|
|
var TOOLTIP_V2_OPEN = "tooltip_v2.open";
|
|
|
|
// node_modules/element-plus/es/components/tooltip-v2/src/root2.mjs
|
|
var __default__116 = defineComponent({
|
|
name: "ElTooltipV2Root"
|
|
});
|
|
var _sfc_main157 = defineComponent({
|
|
...__default__116,
|
|
props: tooltipV2RootProps,
|
|
setup(__props, { expose }) {
|
|
const props2 = __props;
|
|
const _open = ref(props2.defaultOpen);
|
|
const triggerRef = ref(null);
|
|
const open = computed({
|
|
get: () => isPropAbsent(props2.open) ? _open.value : props2.open,
|
|
set: (open2) => {
|
|
var _a2;
|
|
_open.value = open2;
|
|
(_a2 = props2["onUpdate:open"]) == null ? void 0 : _a2.call(props2, open2);
|
|
}
|
|
});
|
|
const isOpenDelayed = computed(() => isNumber2(props2.delayDuration) && props2.delayDuration > 0);
|
|
const { start: onDelayedOpen, stop: clearTimer } = useTimeoutFn(() => {
|
|
open.value = true;
|
|
}, computed(() => props2.delayDuration), {
|
|
immediate: false
|
|
});
|
|
const ns = useNamespace("tooltip-v2");
|
|
const contentId = useId();
|
|
const onNormalOpen = () => {
|
|
clearTimer();
|
|
open.value = true;
|
|
};
|
|
const onDelayOpen = () => {
|
|
unref(isOpenDelayed) ? onDelayedOpen() : onNormalOpen();
|
|
};
|
|
const onOpen = onNormalOpen;
|
|
const onClose = () => {
|
|
clearTimer();
|
|
open.value = false;
|
|
};
|
|
const onChange = (open2) => {
|
|
var _a2;
|
|
if (open2) {
|
|
document.dispatchEvent(new CustomEvent(TOOLTIP_V2_OPEN));
|
|
onOpen();
|
|
}
|
|
(_a2 = props2.onOpenChange) == null ? void 0 : _a2.call(props2, open2);
|
|
};
|
|
watch(open, onChange);
|
|
onMounted(() => {
|
|
document.addEventListener(TOOLTIP_V2_OPEN, onClose);
|
|
});
|
|
onBeforeUnmount(() => {
|
|
clearTimer();
|
|
document.removeEventListener(TOOLTIP_V2_OPEN, onClose);
|
|
});
|
|
provide(tooltipV2RootKey, {
|
|
contentId,
|
|
triggerRef,
|
|
ns,
|
|
onClose,
|
|
onDelayOpen,
|
|
onOpen
|
|
});
|
|
expose({
|
|
onOpen,
|
|
onClose
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return renderSlot(_ctx.$slots, "default", { open: unref(open) });
|
|
};
|
|
}
|
|
});
|
|
var TooltipV2Root = _export_sfc(_sfc_main157, [["__file", "root.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tooltip-v2/src/arrow2.mjs
|
|
var __default__117 = defineComponent({
|
|
name: "ElTooltipV2Arrow"
|
|
});
|
|
var _sfc_main158 = defineComponent({
|
|
...__default__117,
|
|
props: {
|
|
...tooltipV2ArrowProps,
|
|
...tooltipV2ArrowSpecialProps
|
|
},
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const { ns } = inject(tooltipV2RootKey);
|
|
const { arrowRef } = inject(tooltipV2ContentKey);
|
|
const arrowStyle = computed(() => {
|
|
const { style, width, height } = props2;
|
|
const namespace = ns.namespace.value;
|
|
return {
|
|
[`--${namespace}-tooltip-v2-arrow-width`]: `${width}px`,
|
|
[`--${namespace}-tooltip-v2-arrow-height`]: `${height}px`,
|
|
[`--${namespace}-tooltip-v2-arrow-border-width`]: `${width / 2}px`,
|
|
[`--${namespace}-tooltip-v2-arrow-cover-width`]: width / 2 - 1,
|
|
...style || {}
|
|
};
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("span", {
|
|
ref_key: "arrowRef",
|
|
ref: arrowRef,
|
|
style: normalizeStyle(unref(arrowStyle)),
|
|
class: normalizeClass(unref(ns).e("arrow"))
|
|
}, null, 6);
|
|
};
|
|
}
|
|
});
|
|
var TooltipV2Arrow = _export_sfc(_sfc_main158, [["__file", "arrow.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/visual-hidden/src/visual-hidden.mjs
|
|
var visualHiddenProps = buildProps({
|
|
style: {
|
|
type: definePropType([String, Object, Array]),
|
|
default: () => ({})
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/visual-hidden/src/visual-hidden2.mjs
|
|
var __default__118 = defineComponent({
|
|
name: "ElVisuallyHidden"
|
|
});
|
|
var _sfc_main159 = defineComponent({
|
|
...__default__118,
|
|
props: visualHiddenProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const computedStyle = computed(() => {
|
|
return [
|
|
props2.style,
|
|
{
|
|
position: "absolute",
|
|
border: 0,
|
|
width: 1,
|
|
height: 1,
|
|
padding: 0,
|
|
margin: -1,
|
|
overflow: "hidden",
|
|
clip: "rect(0, 0, 0, 0)",
|
|
whiteSpace: "nowrap",
|
|
wordWrap: "normal"
|
|
}
|
|
];
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("span", mergeProps(_ctx.$attrs, { style: unref(computedStyle) }), [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 16);
|
|
};
|
|
}
|
|
});
|
|
var ElVisuallyHidden = _export_sfc(_sfc_main159, [["__file", "visual-hidden.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tooltip-v2/src/content2.mjs
|
|
var __default__119 = defineComponent({
|
|
name: "ElTooltipV2Content"
|
|
});
|
|
var _sfc_main160 = defineComponent({
|
|
...__default__119,
|
|
props: { ...tooltipV2ContentProps, ...tooltipV2CommonProps },
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const { triggerRef, contentId } = inject(tooltipV2RootKey);
|
|
const placement = ref(props2.placement);
|
|
const strategy = ref(props2.strategy);
|
|
const arrowRef = ref(null);
|
|
const { referenceRef, contentRef, middlewareData, x: x2, y, update: update2 } = useFloating({
|
|
placement,
|
|
strategy,
|
|
middleware: computed(() => {
|
|
const middleware = [offset2(props2.offset)];
|
|
if (props2.showArrow) {
|
|
middleware.push(arrowMiddleware({
|
|
arrowRef
|
|
}));
|
|
}
|
|
return middleware;
|
|
})
|
|
});
|
|
const zIndex2 = useZIndex().nextZIndex();
|
|
const ns = useNamespace("tooltip-v2");
|
|
const side = computed(() => {
|
|
return placement.value.split("-")[0];
|
|
});
|
|
const contentStyle = computed(() => {
|
|
return {
|
|
position: unref(strategy),
|
|
top: `${unref(y) || 0}px`,
|
|
left: `${unref(x2) || 0}px`,
|
|
zIndex: zIndex2
|
|
};
|
|
});
|
|
const arrowStyle = computed(() => {
|
|
if (!props2.showArrow)
|
|
return {};
|
|
const { arrow: arrow3 } = unref(middlewareData);
|
|
return {
|
|
[`--${ns.namespace.value}-tooltip-v2-arrow-x`]: `${arrow3 == null ? void 0 : arrow3.x}px` || "",
|
|
[`--${ns.namespace.value}-tooltip-v2-arrow-y`]: `${arrow3 == null ? void 0 : arrow3.y}px` || ""
|
|
};
|
|
});
|
|
const contentClass = computed(() => [
|
|
ns.e("content"),
|
|
ns.is("dark", props2.effect === "dark"),
|
|
ns.is(unref(strategy)),
|
|
props2.contentClass
|
|
]);
|
|
watch(arrowRef, () => update2());
|
|
watch(() => props2.placement, (val) => placement.value = val);
|
|
onMounted(() => {
|
|
watch(() => props2.reference || triggerRef.value, (el) => {
|
|
referenceRef.value = el || void 0;
|
|
}, {
|
|
immediate: true
|
|
});
|
|
});
|
|
provide(tooltipV2ContentKey, { arrowRef });
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "contentRef",
|
|
ref: contentRef,
|
|
style: normalizeStyle(unref(contentStyle)),
|
|
"data-tooltip-v2-root": ""
|
|
}, [
|
|
!_ctx.nowrap ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
"data-side": unref(side),
|
|
class: normalizeClass(unref(contentClass))
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default", {
|
|
contentStyle: unref(contentStyle),
|
|
contentClass: unref(contentClass)
|
|
}),
|
|
createVNode(unref(ElVisuallyHidden), {
|
|
id: unref(contentId),
|
|
role: "tooltip"
|
|
}, {
|
|
default: withCtx(() => [
|
|
_ctx.ariaLabel ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
|
|
createTextVNode(toDisplayString(_ctx.ariaLabel), 1)
|
|
], 64)) : renderSlot(_ctx.$slots, "default", { key: 1 })
|
|
]),
|
|
_: 3
|
|
}, 8, ["id"]),
|
|
renderSlot(_ctx.$slots, "arrow", {
|
|
style: normalizeStyle(unref(arrowStyle)),
|
|
side: unref(side)
|
|
})
|
|
], 10, ["data-side"])) : createCommentVNode("v-if", true)
|
|
], 4);
|
|
};
|
|
}
|
|
});
|
|
var TooltipV2Content = _export_sfc(_sfc_main160, [["__file", "content.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tooltip-v2/src/forward-ref.mjs
|
|
var forwardRefProps = buildProps({
|
|
setRef: {
|
|
type: definePropType(Function),
|
|
required: true
|
|
},
|
|
onlyChild: Boolean
|
|
});
|
|
var ForwardRef = defineComponent({
|
|
props: forwardRefProps,
|
|
setup(props2, {
|
|
slots
|
|
}) {
|
|
const fragmentRef = ref();
|
|
const setRef = composeRefs(fragmentRef, (el) => {
|
|
if (el) {
|
|
props2.setRef(el.nextElementSibling);
|
|
} else {
|
|
props2.setRef(null);
|
|
}
|
|
});
|
|
return () => {
|
|
var _a2;
|
|
const [firstChild] = ((_a2 = slots.default) == null ? void 0 : _a2.call(slots)) || [];
|
|
const child = props2.onlyChild ? ensureOnlyChild(firstChild.children) : firstChild.children;
|
|
return createVNode(Fragment, {
|
|
"ref": setRef
|
|
}, [child]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tooltip-v2/src/trigger.mjs
|
|
var __default__120 = defineComponent({
|
|
name: "ElTooltipV2Trigger"
|
|
});
|
|
var _sfc_main161 = defineComponent({
|
|
...__default__120,
|
|
props: {
|
|
...tooltipV2CommonProps,
|
|
...tooltipV2TriggerProps
|
|
},
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const { onClose, onOpen, onDelayOpen, triggerRef, contentId } = inject(tooltipV2RootKey);
|
|
let isMousedown = false;
|
|
const setTriggerRef = (el) => {
|
|
triggerRef.value = el;
|
|
};
|
|
const onMouseup = () => {
|
|
isMousedown = false;
|
|
};
|
|
const onMouseenter = composeEventHandlers(props2.onMouseEnter, onDelayOpen);
|
|
const onMouseleave = composeEventHandlers(props2.onMouseLeave, onClose);
|
|
const onMousedown = composeEventHandlers(props2.onMouseDown, () => {
|
|
onClose();
|
|
isMousedown = true;
|
|
document.addEventListener("mouseup", onMouseup, { once: true });
|
|
});
|
|
const onFocus = composeEventHandlers(props2.onFocus, () => {
|
|
if (!isMousedown)
|
|
onOpen();
|
|
});
|
|
const onBlur = composeEventHandlers(props2.onBlur, onClose);
|
|
const onClick = composeEventHandlers(props2.onClick, (e) => {
|
|
if (e.detail === 0)
|
|
onClose();
|
|
});
|
|
const events2 = {
|
|
blur: onBlur,
|
|
click: onClick,
|
|
focus: onFocus,
|
|
mousedown: onMousedown,
|
|
mouseenter: onMouseenter,
|
|
mouseleave: onMouseleave
|
|
};
|
|
const setEvents = (el, events22, type4) => {
|
|
if (el) {
|
|
Object.entries(events22).forEach(([name, handler]) => {
|
|
el[type4](name, handler);
|
|
});
|
|
}
|
|
};
|
|
watch(triggerRef, (triggerEl, previousTriggerEl) => {
|
|
setEvents(triggerEl, events2, "addEventListener");
|
|
setEvents(previousTriggerEl, events2, "removeEventListener");
|
|
if (triggerEl) {
|
|
triggerEl.setAttribute("aria-describedby", contentId.value);
|
|
}
|
|
});
|
|
onBeforeUnmount(() => {
|
|
setEvents(triggerRef.value, events2, "removeEventListener");
|
|
document.removeEventListener("mouseup", onMouseup);
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return _ctx.nowrap ? (openBlock(), createBlock(unref(ForwardRef), {
|
|
key: 0,
|
|
"set-ref": setTriggerRef,
|
|
"only-child": ""
|
|
}, {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
})) : (openBlock(), createElementBlock("button", mergeProps({
|
|
key: 1,
|
|
ref_key: "triggerRef",
|
|
ref: triggerRef
|
|
}, _ctx.$attrs), [
|
|
renderSlot(_ctx.$slots, "default")
|
|
], 16));
|
|
};
|
|
}
|
|
});
|
|
var TooltipV2Trigger = _export_sfc(_sfc_main161, [["__file", "trigger.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tooltip-v2/src/tooltip.mjs
|
|
var __default__121 = defineComponent({
|
|
name: "ElTooltipV2"
|
|
});
|
|
var _sfc_main162 = defineComponent({
|
|
...__default__121,
|
|
props: tooltipV2Props,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const refedProps = toRefs(props2);
|
|
const arrowProps = reactive(pick_default(refedProps, Object.keys(tooltipV2ArrowProps)));
|
|
const contentProps = reactive(pick_default(refedProps, Object.keys(tooltipV2ContentProps)));
|
|
const rootProps = reactive(pick_default(refedProps, Object.keys(tooltipV2RootProps)));
|
|
const triggerProps = reactive(pick_default(refedProps, Object.keys(tooltipV2TriggerProps)));
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(TooltipV2Root, normalizeProps(guardReactiveProps(rootProps)), {
|
|
default: withCtx(({ open }) => [
|
|
createVNode(TooltipV2Trigger, mergeProps(triggerProps, { nowrap: "" }), {
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "trigger")
|
|
]),
|
|
_: 3
|
|
}, 16),
|
|
createVNode(unref(ElTeleport), {
|
|
to: _ctx.to,
|
|
disabled: !_ctx.teleported
|
|
}, {
|
|
default: withCtx(() => [
|
|
_ctx.fullTransition ? (openBlock(), createBlock(Transition, normalizeProps(mergeProps({ key: 0 }, _ctx.transitionProps)), {
|
|
default: withCtx(() => [
|
|
_ctx.alwaysOn || open ? (openBlock(), createBlock(TooltipV2Content, normalizeProps(mergeProps({ key: 0 }, contentProps)), {
|
|
arrow: withCtx(({ style, side }) => [
|
|
_ctx.showArrow ? (openBlock(), createBlock(TooltipV2Arrow, mergeProps({ key: 0 }, arrowProps, {
|
|
style,
|
|
side
|
|
}), null, 16, ["style", "side"])) : createCommentVNode("v-if", true)
|
|
]),
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 16)) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 2
|
|
}, 1040)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
|
|
_ctx.alwaysOn || open ? (openBlock(), createBlock(TooltipV2Content, normalizeProps(mergeProps({ key: 0 }, contentProps)), {
|
|
arrow: withCtx(({ style, side }) => [
|
|
_ctx.showArrow ? (openBlock(), createBlock(TooltipV2Arrow, mergeProps({ key: 0 }, arrowProps, {
|
|
style,
|
|
side
|
|
}), null, 16, ["style", "side"])) : createCommentVNode("v-if", true)
|
|
]),
|
|
default: withCtx(() => [
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 16)) : createCommentVNode("v-if", true)
|
|
], 64))
|
|
]),
|
|
_: 2
|
|
}, 1032, ["to", "disabled"])
|
|
]),
|
|
_: 3
|
|
}, 16);
|
|
};
|
|
}
|
|
});
|
|
var TooltipV2 = _export_sfc(_sfc_main162, [["__file", "tooltip.vue"]]);
|
|
|
|
// node_modules/element-plus/es/components/tooltip-v2/index.mjs
|
|
var ElTooltipV2 = withInstall(TooltipV2);
|
|
|
|
// node_modules/element-plus/es/component.mjs
|
|
var Components = [
|
|
ElAffix,
|
|
ElAlert,
|
|
ElAutocomplete,
|
|
ElAutoResizer,
|
|
ElAvatar,
|
|
ElBacktop,
|
|
ElBadge,
|
|
ElBreadcrumb,
|
|
ElBreadcrumbItem,
|
|
ElButton,
|
|
ElButtonGroup,
|
|
ElCalendar,
|
|
ElCard,
|
|
ElCarousel,
|
|
ElCarouselItem,
|
|
ElCascader,
|
|
ElCascaderPanel,
|
|
ElCheckTag,
|
|
ElCheckbox,
|
|
ElCheckboxButton,
|
|
ElCheckboxGroup,
|
|
ElCol,
|
|
ElCollapse,
|
|
ElCollapseItem,
|
|
ElCollapseTransition,
|
|
ElColorPicker,
|
|
ElConfigProvider,
|
|
ElContainer,
|
|
ElAside,
|
|
ElFooter,
|
|
ElHeader,
|
|
ElMain,
|
|
ElDatePicker,
|
|
ElDescriptions,
|
|
ElDescriptionsItem,
|
|
ElDialog,
|
|
ElDivider,
|
|
ElDrawer,
|
|
ElDropdown,
|
|
ElDropdownItem,
|
|
ElDropdownMenu,
|
|
ElEmpty,
|
|
ElForm,
|
|
ElFormItem,
|
|
ElIcon,
|
|
ElImage,
|
|
ElImageViewer,
|
|
ElInput,
|
|
ElInputNumber,
|
|
ElInputTag,
|
|
ElLink,
|
|
ElMenu,
|
|
ElMenuItem,
|
|
ElMenuItemGroup,
|
|
ElSubMenu,
|
|
ElPageHeader,
|
|
ElPagination,
|
|
ElPopconfirm,
|
|
ElPopover,
|
|
ElPopper,
|
|
ElProgress,
|
|
ElRadio,
|
|
ElRadioButton,
|
|
ElRadioGroup,
|
|
ElRate,
|
|
ElResult,
|
|
ElRow,
|
|
ElScrollbar,
|
|
ElSelect,
|
|
ElOption,
|
|
ElOptionGroup,
|
|
ElSelectV2,
|
|
ElSkeleton,
|
|
ElSkeletonItem,
|
|
ElSlider,
|
|
ElSpace,
|
|
ElStatistic,
|
|
ElCountdown,
|
|
ElSteps,
|
|
ElStep,
|
|
ElSwitch,
|
|
ElTable,
|
|
ElTableColumn2,
|
|
ElTableV2,
|
|
ElTabs,
|
|
ElTabPane,
|
|
ElTag,
|
|
ElText,
|
|
ElTimePicker,
|
|
ElTimeSelect,
|
|
ElTimeline,
|
|
ElTimelineItem,
|
|
ElTooltip,
|
|
ElTooltipV2,
|
|
ElTransfer,
|
|
ElTree,
|
|
ElTreeSelect,
|
|
ElTreeV2,
|
|
ElUpload,
|
|
ElWatermark,
|
|
ElTour,
|
|
ElTourStep,
|
|
ElAnchor,
|
|
ElAnchorLink,
|
|
ElSegmented,
|
|
ElMention
|
|
];
|
|
|
|
// node_modules/element-plus/es/plugin.mjs
|
|
var Plugins = [
|
|
ElInfiniteScroll,
|
|
ElLoading,
|
|
ElMessage,
|
|
ElMessageBox,
|
|
ElNotification,
|
|
ElPopoverDirective
|
|
];
|
|
|
|
// node_modules/element-plus/es/defaults.mjs
|
|
var installer = makeInstaller([...Components, ...Plugins]);
|
|
|
|
// node_modules/element-plus/es/hooks/use-focus/index.mjs
|
|
var useFocus = (el) => {
|
|
return {
|
|
focus: () => {
|
|
var _a2, _b;
|
|
(_b = (_a2 = el.value) == null ? void 0 : _a2.focus) == null ? void 0 : _b.call(_a2);
|
|
}
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/hooks/use-modal/index.mjs
|
|
var modalStack = [];
|
|
var closeModal = (e) => {
|
|
if (modalStack.length === 0)
|
|
return;
|
|
if (e.code === EVENT_CODE.esc) {
|
|
e.stopPropagation();
|
|
const topModal = modalStack[modalStack.length - 1];
|
|
topModal.handleClose();
|
|
}
|
|
};
|
|
var useModal = (instance, visibleRef) => {
|
|
watch(visibleRef, (val) => {
|
|
if (val) {
|
|
modalStack.push(instance);
|
|
} else {
|
|
modalStack.splice(modalStack.indexOf(instance), 1);
|
|
}
|
|
});
|
|
};
|
|
if (isClient)
|
|
useEventListener(document, "keydown", closeModal);
|
|
|
|
// node_modules/element-plus/es/hooks/use-prevent-global/index.mjs
|
|
var usePreventGlobal = (indicator, evt, cb) => {
|
|
const prevent = (e) => {
|
|
if (cb(e))
|
|
e.stopImmediatePropagation();
|
|
};
|
|
let stop = void 0;
|
|
watch(() => indicator.value, (val) => {
|
|
if (val) {
|
|
stop = useEventListener(document, evt, prevent, true);
|
|
} else {
|
|
stop == null ? void 0 : stop();
|
|
}
|
|
}, { immediate: true });
|
|
};
|
|
|
|
// node_modules/element-plus/es/utils/vue/global-node.mjs
|
|
var globalNodes = [];
|
|
var target = !isClient ? void 0 : document.body;
|
|
function createGlobalNode(id) {
|
|
const el = document.createElement("div");
|
|
if (id !== void 0) {
|
|
el.setAttribute("id", id);
|
|
}
|
|
if (target) {
|
|
target.appendChild(el);
|
|
globalNodes.push(el);
|
|
}
|
|
return el;
|
|
}
|
|
function removeGlobalNode(el) {
|
|
globalNodes.splice(globalNodes.indexOf(el), 1);
|
|
el.remove();
|
|
}
|
|
|
|
// node_modules/element-plus/es/hooks/use-teleport/index.mjs
|
|
var useTeleport = (contentRenderer, appendToBody) => {
|
|
const isTeleportVisible = ref(false);
|
|
if (!isClient) {
|
|
return {
|
|
isTeleportVisible,
|
|
showTeleport: NOOP,
|
|
hideTeleport: NOOP,
|
|
renderTeleport: NOOP
|
|
};
|
|
}
|
|
let $el = null;
|
|
const showTeleport = () => {
|
|
isTeleportVisible.value = true;
|
|
if ($el !== null)
|
|
return;
|
|
$el = createGlobalNode();
|
|
};
|
|
const hideTeleport = () => {
|
|
isTeleportVisible.value = false;
|
|
if ($el !== null) {
|
|
removeGlobalNode($el);
|
|
$el = null;
|
|
}
|
|
};
|
|
const renderTeleport = () => {
|
|
return appendToBody.value !== true ? contentRenderer() : isTeleportVisible.value ? [h(Teleport, { to: $el }, contentRenderer())] : void 0;
|
|
};
|
|
onUnmounted(hideTeleport);
|
|
return {
|
|
isTeleportVisible,
|
|
showTeleport,
|
|
hideTeleport,
|
|
renderTeleport
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/hooks/use-transition-fallthrough/index.mjs
|
|
var AFTER_APPEAR = "after-appear";
|
|
var AFTER_ENTER = "after-enter";
|
|
var AFTER_LEAVE = "after-leave";
|
|
var APPEAR = "appear";
|
|
var APPEAR_CANCELLED = "appear-cancelled";
|
|
var BEFORE_ENTER = "before-enter";
|
|
var BEFORE_LEAVE = "before-leave";
|
|
var ENTER = "enter";
|
|
var ENTER_CANCELLED = "enter-cancelled";
|
|
var LEAVE = "leave";
|
|
var LEAVE_CANCELLED = "leave-cancelled";
|
|
var useTransitionFallthroughEmits = [
|
|
AFTER_APPEAR,
|
|
AFTER_ENTER,
|
|
AFTER_LEAVE,
|
|
APPEAR,
|
|
APPEAR_CANCELLED,
|
|
BEFORE_ENTER,
|
|
BEFORE_LEAVE,
|
|
ENTER,
|
|
ENTER_CANCELLED,
|
|
LEAVE,
|
|
LEAVE_CANCELLED
|
|
];
|
|
var useTransitionFallthrough = () => {
|
|
const { emit } = getCurrentInstance();
|
|
return {
|
|
onAfterAppear: () => {
|
|
emit(AFTER_APPEAR);
|
|
},
|
|
onAfterEnter: () => {
|
|
emit(AFTER_ENTER);
|
|
},
|
|
onAfterLeave: () => {
|
|
emit(AFTER_LEAVE);
|
|
},
|
|
onAppearCancelled: () => {
|
|
emit(APPEAR_CANCELLED);
|
|
},
|
|
onBeforeEnter: () => {
|
|
emit(BEFORE_ENTER);
|
|
},
|
|
onBeforeLeave: () => {
|
|
emit(BEFORE_LEAVE);
|
|
},
|
|
onEnter: () => {
|
|
emit(ENTER);
|
|
},
|
|
onEnterCancelled: () => {
|
|
emit(ENTER_CANCELLED);
|
|
},
|
|
onLeave: () => {
|
|
emit(LEAVE);
|
|
},
|
|
onLeaveCancelled: () => {
|
|
emit(LEAVE_CANCELLED);
|
|
}
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/hooks/use-intermediate-render/index.mjs
|
|
var useDelayedRender = ({
|
|
indicator,
|
|
intermediateIndicator,
|
|
shouldSetIntermediate = () => true,
|
|
beforeShow,
|
|
afterShow,
|
|
afterHide,
|
|
beforeHide
|
|
}) => {
|
|
watch(() => unref(indicator), (val) => {
|
|
if (val) {
|
|
beforeShow == null ? void 0 : beforeShow();
|
|
nextTick(() => {
|
|
if (!unref(indicator))
|
|
return;
|
|
if (shouldSetIntermediate("show")) {
|
|
intermediateIndicator.value = true;
|
|
}
|
|
});
|
|
} else {
|
|
beforeHide == null ? void 0 : beforeHide();
|
|
nextTick(() => {
|
|
if (unref(indicator))
|
|
return;
|
|
if (shouldSetIntermediate("hide")) {
|
|
intermediateIndicator.value = false;
|
|
}
|
|
});
|
|
}
|
|
});
|
|
watch(() => intermediateIndicator.value, (val) => {
|
|
if (val) {
|
|
afterShow == null ? void 0 : afterShow();
|
|
} else {
|
|
afterHide == null ? void 0 : afterHide();
|
|
}
|
|
});
|
|
};
|
|
|
|
// node_modules/element-plus/es/index.mjs
|
|
var import_dayjs19 = __toModule(require_dayjs_min());
|
|
var install = installer.install;
|
|
var version3 = installer.version;
|
|
|
|
export {
|
|
INSTALLED_KEY,
|
|
configProviderContextKey,
|
|
defaultNamespace,
|
|
namespaceContextKey,
|
|
useGetDerivedNamespace,
|
|
useNamespace,
|
|
defaultInitialZIndex,
|
|
ZINDEX_INJECTION_KEY,
|
|
zIndexContextKey,
|
|
useZIndex,
|
|
buildTranslator,
|
|
translate,
|
|
buildLocaleContext,
|
|
localeContextKey,
|
|
useLocale,
|
|
componentSizes,
|
|
componentSizeMap,
|
|
useSizeProp,
|
|
useSizeProps,
|
|
SIZE_INJECTION_KEY,
|
|
useGlobalSize,
|
|
emptyValuesContextKey,
|
|
SCOPE,
|
|
DEFAULT_EMPTY_VALUES,
|
|
DEFAULT_VALUE_ON_CLEAR,
|
|
useEmptyValuesProps,
|
|
useEmptyValues,
|
|
useGlobalConfig,
|
|
useGlobalComponentSettings,
|
|
provideGlobalConfig,
|
|
makeInstaller,
|
|
UPDATE_MODEL_EVENT,
|
|
CHANGE_EVENT,
|
|
INPUT_EVENT,
|
|
affixProps,
|
|
affixEmits,
|
|
ElAffix,
|
|
iconProps,
|
|
ElIcon,
|
|
alertEffects,
|
|
alertProps,
|
|
alertEmits,
|
|
ElAlert,
|
|
ariaProps,
|
|
useAriaProps,
|
|
inputProps,
|
|
inputEmits,
|
|
useAttrs2 as useAttrs,
|
|
formContextKey,
|
|
formItemContextKey,
|
|
ID_INJECTION_KEY,
|
|
useIdInjection,
|
|
useId,
|
|
useFormItem,
|
|
useFormItemInputId,
|
|
useProp,
|
|
useFormSize,
|
|
useFormDisabled,
|
|
useSize,
|
|
useDisabled,
|
|
useFocusController,
|
|
useComposition,
|
|
useCursor,
|
|
ElInput,
|
|
GAP,
|
|
BAR_MAP,
|
|
renderThumbStyle,
|
|
scrollbarContextKey,
|
|
thumbProps,
|
|
scrollbarProps,
|
|
scrollbarEmits,
|
|
ElScrollbar,
|
|
POPPER_INJECTION_KEY,
|
|
POPPER_CONTENT_INJECTION_KEY,
|
|
Effect,
|
|
roleTypes,
|
|
popperProps,
|
|
usePopperProps,
|
|
ElPopperArrow,
|
|
popperTriggerProps,
|
|
usePopperTriggerProps,
|
|
FORWARD_REF_INJECTION_KEY,
|
|
useForwardRef,
|
|
useForwardRefDirective,
|
|
ElPopperTrigger,
|
|
EVENT_CODE,
|
|
useEscapeKeydown,
|
|
popperArrowProps,
|
|
usePopperArrowProps,
|
|
popperCoreConfigProps,
|
|
popperContentProps,
|
|
popperContentEmits,
|
|
usePopperCoreConfigProps,
|
|
usePopperContentProps,
|
|
usePopperContentEmits,
|
|
usePopper,
|
|
ElPopperContent,
|
|
ElPopper,
|
|
TOOLTIP_INJECTION_KEY,
|
|
useTimeout,
|
|
useDelayedToggleProps,
|
|
useDelayedToggle,
|
|
useTooltipContentProps,
|
|
useTooltipTriggerProps,
|
|
createModelToggleComposable,
|
|
useModelToggle,
|
|
useModelToggleProps,
|
|
useModelToggleEmits,
|
|
useTooltipModelToggleProps,
|
|
useTooltipModelToggleEmits,
|
|
useTooltipModelToggle,
|
|
useTooltipProps,
|
|
tooltipEmits,
|
|
usePopperContainerId,
|
|
usePopperContainer,
|
|
ElTooltip,
|
|
autocompleteProps,
|
|
autocompleteEmits,
|
|
ElAutocomplete,
|
|
avatarProps,
|
|
avatarEmits,
|
|
ElAvatar,
|
|
backtopProps,
|
|
backtopEmits,
|
|
ElBacktop,
|
|
badgeProps,
|
|
ElBadge,
|
|
breadcrumbKey,
|
|
breadcrumbProps,
|
|
breadcrumbItemProps,
|
|
ElBreadcrumb,
|
|
ElBreadcrumbItem,
|
|
buttonGroupContextKey,
|
|
useDeprecated,
|
|
buttonTypes,
|
|
buttonNativeTypes,
|
|
buttonProps,
|
|
buttonEmits,
|
|
ElButton,
|
|
ElButtonGroup,
|
|
buildTimeList,
|
|
rangeArr,
|
|
extractDateFormat,
|
|
extractTimeFormat,
|
|
dateEquals,
|
|
valueEquals,
|
|
parseDate,
|
|
formatter,
|
|
makeList,
|
|
dayOrDaysToDate,
|
|
datePickTypes,
|
|
WEEK_DAYS,
|
|
calendarProps,
|
|
calendarEmits,
|
|
ElCalendar,
|
|
cardProps,
|
|
ElCard,
|
|
carouselProps,
|
|
carouselEmits,
|
|
carouselContextKey,
|
|
CAROUSEL_ITEM_NAME,
|
|
useOrderedChildren,
|
|
carouselItemProps,
|
|
ElCarousel,
|
|
ElCarouselItem,
|
|
checkboxProps,
|
|
checkboxEmits,
|
|
checkboxGroupContextKey,
|
|
checkboxGroupProps,
|
|
checkboxGroupEmits,
|
|
ElCheckbox,
|
|
ElCheckboxButton,
|
|
ElCheckboxGroup,
|
|
radioPropsBase,
|
|
radioProps,
|
|
radioEmits,
|
|
radioGroupKey,
|
|
radioButtonProps,
|
|
radioGroupProps,
|
|
radioGroupEmits,
|
|
ElRadio,
|
|
ElRadioGroup,
|
|
ElRadioButton,
|
|
CASCADER_PANEL_INJECTION_KEY,
|
|
CommonProps,
|
|
DefaultProps,
|
|
useCascaderConfig,
|
|
ElCascaderPanel,
|
|
tagProps,
|
|
tagEmits,
|
|
ElTag,
|
|
cascaderProps,
|
|
cascaderEmits,
|
|
ClickOutside,
|
|
ElCascader,
|
|
checkTagProps,
|
|
checkTagEmits,
|
|
ElCheckTag,
|
|
colProps,
|
|
rowContextKey,
|
|
ElCol,
|
|
emitChangeFn,
|
|
collapseProps,
|
|
collapseEmits,
|
|
collapseContextKey,
|
|
ElCollapseTransition,
|
|
collapseItemProps,
|
|
ElCollapse,
|
|
ElCollapseItem,
|
|
colorPickerProps,
|
|
colorPickerEmits,
|
|
colorPickerContextKey,
|
|
ElColorPicker,
|
|
configProviderProps,
|
|
messageConfig,
|
|
ElConfigProvider,
|
|
ElContainer,
|
|
ElAside,
|
|
ElFooter,
|
|
ElHeader,
|
|
ElMain,
|
|
timeUnits,
|
|
DEFAULT_FORMATS_TIME,
|
|
DEFAULT_FORMATS_DATE,
|
|
DEFAULT_FORMATS_DATEPICKER,
|
|
timePickerDefaultProps,
|
|
timePickerRangeTriggerProps,
|
|
timePickerRngeTriggerProps,
|
|
CommonPicker,
|
|
vRepeatClick,
|
|
TimePickPanel,
|
|
ElTimePicker,
|
|
ROOT_PICKER_INJECTION_KEY,
|
|
datePickerProps,
|
|
ElDatePicker,
|
|
descriptionProps,
|
|
columnAlignment,
|
|
descriptionItemProps,
|
|
ElDescriptions,
|
|
ElDescriptionsItem,
|
|
useSameTarget,
|
|
overlayProps,
|
|
overlayEmits,
|
|
ElOverlay,
|
|
dialogInjectionKey,
|
|
useDraggable,
|
|
dialogProps,
|
|
dialogEmits,
|
|
useLockscreen,
|
|
useDialog,
|
|
ElDialog,
|
|
dividerProps,
|
|
ElDivider,
|
|
drawerProps,
|
|
drawerEmits,
|
|
ElDrawer,
|
|
dropdownProps,
|
|
dropdownItemProps,
|
|
dropdownMenuProps,
|
|
FIRST_KEYS,
|
|
LAST_KEYS,
|
|
FIRST_LAST_KEYS,
|
|
ElCollection,
|
|
ElCollectionItem,
|
|
COLLECTION_INJECTION_KEY,
|
|
COLLECTION_ITEM_INJECTION_KEY,
|
|
DROPDOWN_INJECTION_KEY,
|
|
ElDropdown,
|
|
ElDropdownItem,
|
|
ElDropdownMenu,
|
|
emptyProps,
|
|
ElEmpty,
|
|
formMetaProps,
|
|
formProps,
|
|
formEmits,
|
|
formItemValidateStates,
|
|
formItemProps,
|
|
ElForm,
|
|
ElFormItem,
|
|
imageViewerProps,
|
|
imageViewerEmits,
|
|
ElImageViewer,
|
|
imageProps,
|
|
imageEmits,
|
|
ElImage,
|
|
inputNumberProps,
|
|
inputNumberEmits,
|
|
ElInputNumber,
|
|
inputTagProps,
|
|
inputTagEmits,
|
|
useCalcInputWidth,
|
|
ElInputTag,
|
|
linkProps,
|
|
linkEmits,
|
|
ElLink,
|
|
subMenuProps,
|
|
menuProps,
|
|
menuEmits,
|
|
menuItemProps,
|
|
menuItemEmits,
|
|
menuItemGroupProps,
|
|
ElMenu,
|
|
ElMenuItem,
|
|
ElMenuItemGroup,
|
|
ElSubMenu,
|
|
pageHeaderProps,
|
|
pageHeaderEmits,
|
|
ElPageHeader,
|
|
elPaginationKey,
|
|
selectGroupKey,
|
|
selectKey,
|
|
SelectProps,
|
|
selectEmits,
|
|
ElSelect,
|
|
ElOption,
|
|
ElOptionGroup,
|
|
paginationProps,
|
|
paginationEmits,
|
|
ElPagination,
|
|
popconfirmProps,
|
|
popconfirmEmits,
|
|
ElPopconfirm,
|
|
popoverProps,
|
|
popoverEmits,
|
|
ElPopoverDirective,
|
|
ElPopover,
|
|
progressProps,
|
|
ElProgress,
|
|
rateProps,
|
|
rateEmits,
|
|
ElRate,
|
|
IconMap,
|
|
IconComponentMap,
|
|
resultProps,
|
|
ElResult,
|
|
RowJustify,
|
|
RowAlign,
|
|
rowProps,
|
|
ElRow,
|
|
selectV2InjectionKey,
|
|
virtualizedProps,
|
|
virtualizedListProps,
|
|
virtualizedGridProps,
|
|
virtualizedScrollbarProps,
|
|
FixedSizeList,
|
|
DynamicSizeList,
|
|
ElSelectV2,
|
|
skeletonProps,
|
|
skeletonItemProps,
|
|
useThrottleRender,
|
|
ElSkeleton,
|
|
ElSkeletonItem,
|
|
sliderContextKey,
|
|
sliderProps,
|
|
sliderEmits,
|
|
ElSlider,
|
|
spaceItemProps,
|
|
useSpace,
|
|
spaceProps,
|
|
ElSpace,
|
|
statisticProps,
|
|
ElStatistic,
|
|
countdownProps,
|
|
countdownEmits,
|
|
ElCountdown,
|
|
stepsProps,
|
|
stepsEmits,
|
|
stepProps,
|
|
ElSteps,
|
|
ElStep,
|
|
switchProps,
|
|
switchEmits,
|
|
ElSwitch,
|
|
Mousewheel,
|
|
ElTable,
|
|
ElTableColumn2 as ElTableColumn,
|
|
SortOrder,
|
|
Alignment,
|
|
FixedDir,
|
|
placeholderSign,
|
|
tableV2RowProps,
|
|
tableV2Props,
|
|
DynamicSizeGrid,
|
|
FixedSizeGrid,
|
|
TableV2$1,
|
|
autoResizerProps,
|
|
ElTableV2,
|
|
ElAutoResizer,
|
|
tabsRootContextKey,
|
|
tabBarProps,
|
|
tabNavProps,
|
|
tabNavEmits,
|
|
tabsProps,
|
|
tabsEmits,
|
|
tabPaneProps,
|
|
ElTabs,
|
|
ElTabPane,
|
|
textProps,
|
|
ElText,
|
|
timeSelectProps,
|
|
ElTimeSelect,
|
|
timelineItemProps,
|
|
ElTimeline,
|
|
ElTimelineItem,
|
|
useFloatingProps,
|
|
getPositionDataWithUnit,
|
|
useFloating,
|
|
arrowMiddleware,
|
|
LEFT_CHECK_CHANGE_EVENT,
|
|
RIGHT_CHECK_CHANGE_EVENT,
|
|
transferProps,
|
|
transferCheckedChangeFn,
|
|
transferEmits,
|
|
ElTransfer,
|
|
ElTree,
|
|
ElTreeSelect,
|
|
ElTreeV2,
|
|
uploadContextKey,
|
|
uploadListTypes,
|
|
genFileId,
|
|
uploadBaseProps,
|
|
uploadProps,
|
|
uploadListProps,
|
|
uploadListEmits,
|
|
uploadDraggerProps,
|
|
uploadDraggerEmits,
|
|
uploadContentProps,
|
|
ElUpload,
|
|
watermarkProps,
|
|
ElWatermark,
|
|
tourStrategies,
|
|
tourPlacements,
|
|
tourContentProps,
|
|
tourContentEmits,
|
|
tourProps,
|
|
tourEmits,
|
|
tourStepProps,
|
|
tourStepEmits,
|
|
ElTour,
|
|
ElTourStep,
|
|
anchorProps,
|
|
anchorEmits,
|
|
ElAnchor,
|
|
ElAnchorLink,
|
|
defaultProps5 as defaultProps,
|
|
segmentedProps,
|
|
segmentedEmits,
|
|
ElSegmented,
|
|
mentionProps,
|
|
mentionEmits,
|
|
ElMention,
|
|
ElInfiniteScroll,
|
|
Loading,
|
|
vLoading,
|
|
ElLoading,
|
|
messageTypes,
|
|
messageDefaults,
|
|
messageProps,
|
|
messageEmits,
|
|
ElMessage,
|
|
TrapFocus,
|
|
ElMessageBox,
|
|
notificationTypes,
|
|
notificationProps,
|
|
notificationEmits,
|
|
ElNotification,
|
|
installer,
|
|
useFocus,
|
|
useModal,
|
|
usePreventGlobal,
|
|
useTeleport,
|
|
useTransitionFallthroughEmits,
|
|
useTransitionFallthrough,
|
|
useDelayedRender,
|
|
install,
|
|
version3 as version,
|
|
import_dayjs19 as import_dayjs
|
|
};
|
|
/**
|
|
* @license
|
|
* Lodash (Custom Build) <https://lodash.com/>
|
|
* Build: `lodash modularize exports="es" -o ./`
|
|
* Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
|
|
* Released under MIT license <https://lodash.com/license>
|
|
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
|
|
* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
|
|
*/
|
|
/**
|
|
* Checks if an event is supported in the current execution environment.
|
|
*
|
|
* NOTE: This will not work correctly for non-generic events such as `change`,
|
|
* `reset`, `load`, `error`, and `select`.
|
|
*
|
|
* Borrows from Modernizr.
|
|
*
|
|
* @param {string} eventNameSuffix Event name, e.g. "click".
|
|
* @param {?boolean} capture Check if the capture phase is supported.
|
|
* @return {boolean} True if the event is supported.
|
|
* @internal
|
|
* @license Modernizr 3.0.0pre (Custom Build) | MIT
|
|
*/
|
|
//# sourceMappingURL=chunk-DVV3NNBM.js.map
|