64131 lines
2.1 MiB
64131 lines
2.1 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-5GV5GKFP.js";
|
|
import {
|
|
Comment,
|
|
Fragment,
|
|
NOOP,
|
|
Teleport,
|
|
Text,
|
|
Transition,
|
|
TransitionGroup,
|
|
camelize,
|
|
capitalize,
|
|
cloneVNode,
|
|
computed,
|
|
createApp,
|
|
createBaseVNode,
|
|
createBlock,
|
|
createCommentVNode,
|
|
createElementBlock,
|
|
createSlots,
|
|
createTextVNode,
|
|
createVNode,
|
|
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,
|
|
toValue,
|
|
triggerRef,
|
|
unref,
|
|
useAttrs,
|
|
useSlots,
|
|
vModelCheckbox,
|
|
vModelRadio,
|
|
vModelText,
|
|
vShow,
|
|
warn,
|
|
watch,
|
|
watchEffect,
|
|
withCtx,
|
|
withDirectives,
|
|
withKeys,
|
|
withModifiers
|
|
} from "./chunk-YDDUUUNR.js";
|
|
import {
|
|
require_dayjs_min
|
|
} from "./chunk-YIAL6EWQ.js";
|
|
import {
|
|
__commonJS,
|
|
__toESM
|
|
} from "./chunk-S5KM4IGW.js";
|
|
|
|
// node_modules/dayjs/plugin/customParseFormat.js
|
|
var require_customParseFormat = __commonJS({
|
|
"node_modules/dayjs/plugin/customParseFormat.js"(exports2, module2) {
|
|
!function(e, t) {
|
|
"object" == typeof exports2 && "undefined" != typeof module2 ? module2.exports = t() : "function" == typeof define && define.amd ? define(t) : (e = "undefined" != typeof globalThis ? 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 ("Z" === e3)
|
|
return 0;
|
|
var t2 = e3.match(/([+-]|\d\d)/g), n2 = 60 * t2[1] + (+t2[2] || 0);
|
|
return 0 === n2 ? 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 ("string" == typeof i3)
|
|
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 (void 0 !== t3) {
|
|
var n4 = e3.hours;
|
|
t3 ? n4 < 12 && (e3.hours += 12) : 12 === n4 && (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 ("string" == typeof a3) {
|
|
var f3 = true === o3[2], h4 = true === o3[3], 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(("X" === t4 ? 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(), Y3 = 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, L2 = d4 || 0;
|
|
return c4 ? new Date(Date.UTC(p2, v2, Y3, w2, g, y, L2 + 60 * c4.offset * 1e3)) : n3 ? new Date(Date.UTC(p2, v2, Y3, w2, g, y, L2)) : (D2 = new Date(p2, v2, Y3, w2, g, y, L2), m3 && (D2 = r4(D2).week(m3).toDate()), D2);
|
|
} catch (e5) {
|
|
return new Date("");
|
|
}
|
|
}(t3, a3, r3, n2), this.init(), d3 && true !== d3 && (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/localeData.js
|
|
var require_localeData = __commonJS({
|
|
"node_modules/dayjs/plugin/localeData.js"(exports2, module2) {
|
|
!function(n, e) {
|
|
"object" == typeof exports2 && "undefined" != typeof module2 ? module2.exports = e() : "function" == typeof define && define.amd ? define(e) : (n = "undefined" != typeof globalThis ? 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/advancedFormat.js
|
|
var require_advancedFormat = __commonJS({
|
|
"node_modules/dayjs/plugin/advancedFormat.js"(exports2, module2) {
|
|
!function(e, t) {
|
|
"object" == typeof exports2 && "undefined" != typeof module2 ? module2.exports = t() : "function" == typeof define && define.amd ? define(t) : (e = "undefined" != typeof globalThis ? 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(), "w" === e3 ? 1 : 2, "0");
|
|
case "W":
|
|
case "WW":
|
|
return s2.s(t2.isoWeek(), "W" === e3 ? 1 : 2, "0");
|
|
case "k":
|
|
case "kk":
|
|
return s2.s(String(0 === t2.$H ? 24 : t2.$H), "k" === e3 ? 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) {
|
|
"object" == typeof exports2 && "undefined" != typeof module2 ? module2.exports = t() : "function" == typeof define && define.amd ? define(t) : (e = "undefined" != typeof globalThis ? 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 (void 0 === i2 && (i2 = null), null !== i2)
|
|
return this.add(7 * (i2 - this.week()), "day");
|
|
var n2 = this.$locale().yearStart || 1;
|
|
if (11 === this.month() && 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 void 0 === e2 && (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) {
|
|
"object" == typeof exports2 && "undefined" != typeof module2 ? module2.exports = t() : "function" == typeof define && define.amd ? define(t) : (e = "undefined" != typeof globalThis ? 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 1 === t2 && 11 === e2 ? n + 1 : 0 === e2 && 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) {
|
|
"object" == typeof exports2 && "undefined" != typeof module2 ? module2.exports = t() : "function" == typeof define && define.amd ? define(t) : (e = "undefined" != typeof globalThis ? 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 null == e2 ? 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) {
|
|
"object" == typeof exports2 && "undefined" != typeof module2 ? module2.exports = t() : "function" == typeof define && define.amd ? define(t) : (e = "undefined" != typeof globalThis ? 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) {
|
|
"object" == typeof exports2 && "undefined" != typeof module2 ? module2.exports = i() : "function" == typeof define && define.amd ? define(i) : (e = "undefined" != typeof globalThis ? 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/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/constants/column-alignment.mjs
|
|
var columnAlignment = [
|
|
"left",
|
|
"center",
|
|
"right"
|
|
];
|
|
|
|
// 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/constants/event.mjs
|
|
var UPDATE_MODEL_EVENT = "update:modelValue";
|
|
var CHANGE_EVENT = "change";
|
|
var INPUT_EVENT = "input";
|
|
|
|
// node_modules/element-plus/es/constants/form.mjs
|
|
var MINIMUM_INPUT_WIDTH = 11;
|
|
var BORDER_HORIZONTAL_WIDTH = 2;
|
|
|
|
// node_modules/element-plus/es/constants/key.mjs
|
|
var INSTALLED_KEY = Symbol("INSTALLED_KEY");
|
|
|
|
// node_modules/element-plus/es/constants/size.mjs
|
|
var componentSizes = [
|
|
"",
|
|
"default",
|
|
"small",
|
|
"large"
|
|
];
|
|
var componentSizeMap = {
|
|
large: 40,
|
|
default: 32,
|
|
small: 24
|
|
};
|
|
|
|
// node_modules/@vueuse/shared/index.mjs
|
|
function computedEager(fn2, options) {
|
|
var _a;
|
|
const result2 = shallowRef();
|
|
watchEffect(() => {
|
|
result2.value = fn2();
|
|
}, {
|
|
...options,
|
|
flush: (_a = options == null ? void 0 : options.flush) != null ? _a : "sync"
|
|
});
|
|
return readonly(result2);
|
|
}
|
|
function tryOnScopeDispose(fn2) {
|
|
if (getCurrentScope()) {
|
|
onScopeDispose(fn2);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function toValue2(r) {
|
|
return typeof r === "function" ? r() : unref(r);
|
|
}
|
|
function toReactive(objectRef) {
|
|
if (!isRef(objectRef))
|
|
return reactive(objectRef);
|
|
const proxy = new Proxy({}, {
|
|
get(_2, p2, receiver) {
|
|
return unref(Reflect.get(objectRef.value, p2, receiver));
|
|
},
|
|
set(_2, p2, value) {
|
|
if (isRef(objectRef.value[p2]) && !isRef(value))
|
|
objectRef.value[p2].value = value;
|
|
else
|
|
objectRef.value[p2] = value;
|
|
return true;
|
|
},
|
|
deleteProperty(_2, p2) {
|
|
return Reflect.deleteProperty(objectRef.value, p2);
|
|
},
|
|
has(_2, p2) {
|
|
return Reflect.has(objectRef.value, p2);
|
|
},
|
|
ownKeys() {
|
|
return Object.keys(objectRef.value);
|
|
},
|
|
getOwnPropertyDescriptor() {
|
|
return {
|
|
enumerable: true,
|
|
configurable: true
|
|
};
|
|
}
|
|
});
|
|
return reactive(proxy);
|
|
}
|
|
function reactiveComputed(fn2) {
|
|
return toReactive(computed(fn2));
|
|
}
|
|
var isClient = typeof window !== "undefined" && typeof document !== "undefined";
|
|
var isWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
|
|
var isDef = (val) => typeof val !== "undefined";
|
|
var notNullish = (val) => val != null;
|
|
var toString = Object.prototype.toString;
|
|
var isObject2 = (val) => toString.call(val) === "[object Object]";
|
|
var clamp = (n, min4, max4) => Math.min(max4, Math.max(min4, n));
|
|
var noop = () => {
|
|
};
|
|
var isIOS = getIsIOS();
|
|
function getIsIOS() {
|
|
var _a, _b;
|
|
return isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((_b = window == null ? void 0 : window.navigator) == null ? void 0 : _b.maxTouchPoints) > 2 && /iPad|Macintosh/.test(window == null ? void 0 : window.navigator.userAgent));
|
|
}
|
|
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 = noop;
|
|
const _clearTimeout = (timer2) => {
|
|
clearTimeout(timer2);
|
|
lastRejector();
|
|
lastRejector = noop;
|
|
};
|
|
const filter2 = (invoke2) => {
|
|
const duration = toValue2(ms);
|
|
const maxDuration = toValue2(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(...args) {
|
|
let lastExec = 0;
|
|
let timer;
|
|
let isLeading = true;
|
|
let lastRejector = noop;
|
|
let lastValue;
|
|
let ms;
|
|
let trailing;
|
|
let leading;
|
|
let rejectOnCancel;
|
|
if (!isRef(args[0]) && typeof args[0] === "object")
|
|
({ delay: ms, trailing = true, leading = true, rejectOnCancel = false } = args[0]);
|
|
else
|
|
[ms, trailing = true, leading = true, rejectOnCancel = false] = args;
|
|
const clear = () => {
|
|
if (timer) {
|
|
clearTimeout(timer);
|
|
timer = void 0;
|
|
lastRejector();
|
|
lastRejector = noop;
|
|
}
|
|
};
|
|
const filter2 = (_invoke) => {
|
|
const duration = toValue2(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 cacheStringFunction(fn2) {
|
|
const cache2 = /* @__PURE__ */ Object.create(null);
|
|
return (str) => {
|
|
const hit = cache2[str];
|
|
return hit || (cache2[str] = fn2(str));
|
|
};
|
|
}
|
|
var hyphenateRE = /\B([A-Z])/g;
|
|
var hyphenate2 = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
|
|
var camelizeRE = /-(\w)/g;
|
|
var camelize2 = cacheStringFunction((str) => {
|
|
return str.replace(camelizeRE, (_2, c2) => c2 ? c2.toUpperCase() : "");
|
|
});
|
|
function identity(arg) {
|
|
return arg;
|
|
}
|
|
function getLifeCycleTarget(target2) {
|
|
return target2 || getCurrentInstance();
|
|
}
|
|
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, target2) {
|
|
const instance = getLifeCycleTarget();
|
|
if (instance)
|
|
onMounted(fn2, target2);
|
|
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);
|
|
}, toValue2(interval));
|
|
}
|
|
if (immediate) {
|
|
isPending.value = true;
|
|
if (isClient)
|
|
start();
|
|
}
|
|
tryOnScopeDispose(stop);
|
|
return {
|
|
isPending: readonly(isPending),
|
|
start,
|
|
stop
|
|
};
|
|
}
|
|
|
|
// node_modules/@vueuse/core/index.mjs
|
|
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 unrefElement(elRef) {
|
|
var _a;
|
|
const plain = toValue2(elRef);
|
|
return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
|
|
}
|
|
function useEventListener(...args) {
|
|
let target2;
|
|
let events;
|
|
let listeners;
|
|
let options;
|
|
if (typeof args[0] === "string" || Array.isArray(args[0])) {
|
|
[events, listeners, options] = args;
|
|
target2 = defaultWindow;
|
|
} else {
|
|
[target2, events, listeners, options] = args;
|
|
}
|
|
if (!target2)
|
|
return noop;
|
|
if (!Array.isArray(events))
|
|
events = [events];
|
|
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), toValue2(options)],
|
|
([el, options2]) => {
|
|
cleanup();
|
|
if (!el)
|
|
return;
|
|
const optionsClone = isObject2(options2) ? { ...options2 } : options2;
|
|
cleanups.push(
|
|
...events.flatMap((event) => {
|
|
return listeners.map((listener) => register2(el, event, listener, optionsClone));
|
|
})
|
|
);
|
|
},
|
|
{ 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 noop;
|
|
if (isIOS && !_iOSWorkaround) {
|
|
_iOSWorkaround = true;
|
|
Array.from(window2.document.body.children).forEach((el) => el.addEventListener("click", noop));
|
|
window2.document.documentElement.addEventListener("click", noop);
|
|
}
|
|
let shouldListen = true;
|
|
const shouldIgnore = (event) => {
|
|
return toValue2(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));
|
|
}
|
|
});
|
|
};
|
|
function hasMultipleRoots(target22) {
|
|
const vm = toValue2(target22);
|
|
return vm && vm.$.subTree.shapeFlag === 16;
|
|
}
|
|
function checkMultipleRoots(target22, event) {
|
|
const vm = toValue2(target22);
|
|
const children = vm.$.subTree && vm.$.subTree.children;
|
|
if (children == null || !Array.isArray(children))
|
|
return false;
|
|
return children.some((child) => child.el === event.target || event.composedPath().includes(child.el));
|
|
}
|
|
const listener = (event) => {
|
|
const el = unrefElement(target2);
|
|
if (event.target == null)
|
|
return;
|
|
if (!(el instanceof Element) && hasMultipleRoots(target2) && checkMultipleRoots(target2, event))
|
|
return;
|
|
if (!el || el === event.target || event.composedPath().includes(el))
|
|
return;
|
|
if (event.detail === 0)
|
|
shouldListen = !shouldIgnore(event);
|
|
if (!shouldListen) {
|
|
shouldListen = true;
|
|
return;
|
|
}
|
|
handler(event);
|
|
};
|
|
let isProcessingClick = false;
|
|
const cleanup = [
|
|
useEventListener(window2, "click", (event) => {
|
|
if (!isProcessingClick) {
|
|
isProcessingClick = true;
|
|
setTimeout(() => {
|
|
isProcessingClick = false;
|
|
}, 0);
|
|
listener(event);
|
|
}
|
|
}, { passive: true, capture }),
|
|
useEventListener(window2, "pointerdown", (e) => {
|
|
const el = unrefElement(target2);
|
|
shouldListen = !shouldIgnore(e) && !!(el && !e.composedPath().includes(el));
|
|
}, { passive: true }),
|
|
detectIframe && useEventListener(window2, "blur", (event) => {
|
|
setTimeout(() => {
|
|
var _a;
|
|
const el = unrefElement(target2);
|
|
if (((_a = window2.document.activeElement) == null ? void 0 : _a.tagName) === "IFRAME" && !(el == null ? void 0 : el.contains(window2.document.activeElement))) {
|
|
handler(event);
|
|
}
|
|
}, 0);
|
|
})
|
|
].filter(Boolean);
|
|
const stop = () => cleanup.forEach((fn2) => fn2());
|
|
return stop;
|
|
}
|
|
function useMounted() {
|
|
const isMounted = ref(false);
|
|
const instance = getCurrentInstance();
|
|
if (instance) {
|
|
onMounted(() => {
|
|
isMounted.value = true;
|
|
}, instance);
|
|
}
|
|
return isMounted;
|
|
}
|
|
function useSupported(callback) {
|
|
const isMounted = useMounted();
|
|
return computed(() => {
|
|
isMounted.value;
|
|
return Boolean(callback());
|
|
});
|
|
}
|
|
function useMutationObserver(target2, callback, options = {}) {
|
|
const { window: window2 = defaultWindow, ...mutationOptions } = options;
|
|
let observer;
|
|
const isSupported = useSupported(() => window2 && "MutationObserver" in window2);
|
|
const cleanup = () => {
|
|
if (observer) {
|
|
observer.disconnect();
|
|
observer = void 0;
|
|
}
|
|
};
|
|
const targets = computed(() => {
|
|
const value = toValue2(target2);
|
|
const items = (Array.isArray(value) ? value : [value]).map(unrefElement).filter(notNullish);
|
|
return new Set(items);
|
|
});
|
|
const stopWatch = watch(
|
|
() => targets.value,
|
|
(targets2) => {
|
|
cleanup();
|
|
if (isSupported.value && targets2.size) {
|
|
observer = new MutationObserver(callback);
|
|
targets2.forEach((el) => observer.observe(el, mutationOptions));
|
|
}
|
|
},
|
|
{ immediate: true, flush: "post" }
|
|
);
|
|
const takeRecords = () => {
|
|
return observer == null ? void 0 : observer.takeRecords();
|
|
};
|
|
const stop = () => {
|
|
stopWatch();
|
|
cleanup();
|
|
};
|
|
tryOnScopeDispose(stop);
|
|
return {
|
|
isSupported,
|
|
stop,
|
|
takeRecords
|
|
};
|
|
}
|
|
function useActiveElement(options = {}) {
|
|
var _a;
|
|
const {
|
|
window: window2 = defaultWindow,
|
|
deep = true,
|
|
triggerOnRemoval = false
|
|
} = options;
|
|
const document2 = (_a = options.document) != null ? _a : window2 == null ? void 0 : window2.document;
|
|
const getDeepActiveElement = () => {
|
|
var _a2;
|
|
let element = document2 == null ? void 0 : document2.activeElement;
|
|
if (deep) {
|
|
while (element == null ? void 0 : element.shadowRoot)
|
|
element = (_a2 = element == null ? void 0 : element.shadowRoot) == null ? void 0 : _a2.activeElement;
|
|
}
|
|
return element;
|
|
};
|
|
const activeElement = ref();
|
|
const trigger = () => {
|
|
activeElement.value = getDeepActiveElement();
|
|
};
|
|
if (window2) {
|
|
useEventListener(window2, "blur", (event) => {
|
|
if (event.relatedTarget !== null)
|
|
return;
|
|
trigger();
|
|
}, true);
|
|
useEventListener(window2, "focus", trigger, true);
|
|
}
|
|
if (triggerOnRemoval) {
|
|
useMutationObserver(document2, (mutations) => {
|
|
mutations.filter((m2) => m2.removedNodes.length).map((n) => Array.from(n.removedNodes)).flat().forEach((node) => {
|
|
if (node === activeElement.value)
|
|
trigger();
|
|
});
|
|
}, {
|
|
childList: true,
|
|
subtree: true
|
|
});
|
|
}
|
|
trigger();
|
|
return activeElement;
|
|
}
|
|
function useMediaQuery(query, options = {}) {
|
|
const { window: window2 = defaultWindow } = options;
|
|
const isSupported = useSupported(() => window2 && "matchMedia" in window2 && typeof window2.matchMedia === "function");
|
|
let mediaQuery;
|
|
const matches2 = ref(false);
|
|
const handler = (event) => {
|
|
matches2.value = event.matches;
|
|
};
|
|
const cleanup = () => {
|
|
if (!mediaQuery)
|
|
return;
|
|
if ("removeEventListener" in mediaQuery)
|
|
mediaQuery.removeEventListener("change", handler);
|
|
else
|
|
mediaQuery.removeListener(handler);
|
|
};
|
|
const stopWatch = watchEffect(() => {
|
|
if (!isSupported.value)
|
|
return;
|
|
cleanup();
|
|
mediaQuery = window2.matchMedia(toValue2(query));
|
|
if ("addEventListener" in mediaQuery)
|
|
mediaQuery.addEventListener("change", handler);
|
|
else
|
|
mediaQuery.addListener(handler);
|
|
matches2.value = mediaQuery.matches;
|
|
});
|
|
tryOnScopeDispose(() => {
|
|
stopWatch();
|
|
cleanup();
|
|
mediaQuery = void 0;
|
|
});
|
|
return matches2;
|
|
}
|
|
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__";
|
|
var handlers = getHandlers();
|
|
function getHandlers() {
|
|
if (!(globalKey in _global))
|
|
_global[globalKey] = _global[globalKey] || {};
|
|
return _global[globalKey];
|
|
}
|
|
function useCssVar(prop, target2, options = {}) {
|
|
const { window: window2 = defaultWindow, initialValue, observe = false } = options;
|
|
const variable = ref(initialValue);
|
|
const elRef = computed(() => {
|
|
var _a;
|
|
return unrefElement(target2) || ((_a = window2 == null ? void 0 : window2.document) == null ? void 0 : _a.documentElement);
|
|
});
|
|
function updateCssVar() {
|
|
var _a;
|
|
const key = toValue2(prop);
|
|
const el = toValue2(elRef);
|
|
if (el && window2 && key) {
|
|
const value = (_a = window2.getComputedStyle(el).getPropertyValue(key)) == null ? void 0 : _a.trim();
|
|
variable.value = value || initialValue;
|
|
}
|
|
}
|
|
if (observe) {
|
|
useMutationObserver(elRef, updateCssVar, {
|
|
attributeFilter: ["style", "class"],
|
|
window: window2
|
|
});
|
|
}
|
|
watch(
|
|
[elRef, () => toValue2(prop)],
|
|
(_2, old) => {
|
|
if (old[0] && old[1])
|
|
old[0].style.removeProperty(old[1]);
|
|
updateCssVar();
|
|
},
|
|
{ immediate: true }
|
|
);
|
|
watch(
|
|
variable,
|
|
(val) => {
|
|
var _a;
|
|
const raw_prop = toValue2(prop);
|
|
if (((_a = elRef.value) == null ? void 0 : _a.style) && raw_prop) {
|
|
if (val == null)
|
|
elRef.value.style.removeProperty(raw_prop);
|
|
else
|
|
elRef.value.style.setProperty(raw_prop, val);
|
|
}
|
|
}
|
|
);
|
|
return variable;
|
|
}
|
|
function useDocumentVisibility(options = {}) {
|
|
const { document: document2 = defaultDocument } = options;
|
|
if (!document2)
|
|
return ref("visible");
|
|
const visibility = ref(document2.visibilityState);
|
|
useEventListener(document2, "visibilitychange", () => {
|
|
visibility.value = document2.visibilityState;
|
|
});
|
|
return visibility;
|
|
}
|
|
function useResizeObserver(target2, callback, options = {}) {
|
|
const { window: window2 = defaultWindow, ...observerOptions } = options;
|
|
let observer;
|
|
const isSupported = useSupported(() => window2 && "ResizeObserver" in window2);
|
|
const cleanup = () => {
|
|
if (observer) {
|
|
observer.disconnect();
|
|
observer = void 0;
|
|
}
|
|
};
|
|
const targets = computed(() => {
|
|
const _targets = toValue2(target2);
|
|
return Array.isArray(_targets) ? _targets.map((el) => unrefElement(el)) : [unrefElement(_targets)];
|
|
});
|
|
const stopWatch = watch(
|
|
targets,
|
|
(els) => {
|
|
cleanup();
|
|
if (isSupported.value && window2) {
|
|
observer = new ResizeObserver(callback);
|
|
for (const _el of els) {
|
|
if (_el)
|
|
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,
|
|
updateTiming = "sync"
|
|
} = 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 recalculate() {
|
|
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;
|
|
}
|
|
function update2() {
|
|
if (updateTiming === "sync")
|
|
recalculate();
|
|
else if (updateTiming === "next-frame")
|
|
requestAnimationFrame(() => recalculate());
|
|
}
|
|
useResizeObserver(target2, update2);
|
|
watch(() => unrefElement(target2), (ele) => !ele && update2());
|
|
useMutationObserver(target2, update2, {
|
|
attributeFilter: ["style", "class"]
|
|
});
|
|
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
|
|
};
|
|
}
|
|
function useElementSize(target2, initialSize = { width: 0, height: 0 }, options = {}) {
|
|
const { window: window2 = defaultWindow, box = "content-box" } = options;
|
|
const isSVG = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = unrefElement(target2)) == null ? void 0 : _a.namespaceURI) == null ? void 0 : _b.includes("svg");
|
|
});
|
|
const width = ref(initialSize.width);
|
|
const height = ref(initialSize.height);
|
|
const { stop: stop1 } = useResizeObserver(
|
|
target2,
|
|
([entry]) => {
|
|
const boxSize = box === "border-box" ? entry.borderBoxSize : box === "content-box" ? entry.contentBoxSize : entry.devicePixelContentBoxSize;
|
|
if (window2 && isSVG.value) {
|
|
const $elem = unrefElement(target2);
|
|
if ($elem) {
|
|
const rect = $elem.getBoundingClientRect();
|
|
width.value = rect.width;
|
|
height.value = rect.height;
|
|
}
|
|
} else {
|
|
if (boxSize) {
|
|
const formatBoxSize = Array.isArray(boxSize) ? boxSize : [boxSize];
|
|
width.value = formatBoxSize.reduce((acc, { inlineSize }) => acc + inlineSize, 0);
|
|
height.value = formatBoxSize.reduce((acc, { blockSize }) => acc + blockSize, 0);
|
|
} else {
|
|
width.value = entry.contentRect.width;
|
|
height.value = entry.contentRect.height;
|
|
}
|
|
}
|
|
},
|
|
options
|
|
);
|
|
tryOnMounted(() => {
|
|
const ele = unrefElement(target2);
|
|
if (ele) {
|
|
width.value = "offsetWidth" in ele ? ele.offsetWidth : initialSize.width;
|
|
height.value = "offsetHeight" in ele ? ele.offsetHeight : initialSize.height;
|
|
}
|
|
});
|
|
const stop2 = watch(
|
|
() => unrefElement(target2),
|
|
(ele) => {
|
|
width.value = ele ? initialSize.width : 0;
|
|
height.value = ele ? initialSize.height : 0;
|
|
}
|
|
);
|
|
function stop() {
|
|
stop1();
|
|
stop2();
|
|
}
|
|
return {
|
|
width,
|
|
height,
|
|
stop
|
|
};
|
|
}
|
|
function useIntersectionObserver(target2, callback, options = {}) {
|
|
const {
|
|
root: root2,
|
|
rootMargin = "0px",
|
|
threshold = 0,
|
|
window: window2 = defaultWindow,
|
|
immediate = true
|
|
} = options;
|
|
const isSupported = useSupported(() => window2 && "IntersectionObserver" in window2);
|
|
const targets = computed(() => {
|
|
const _target = toValue2(target2);
|
|
return (Array.isArray(_target) ? _target : [_target]).map(unrefElement).filter(notNullish);
|
|
});
|
|
let cleanup = noop;
|
|
const isActive = ref(immediate);
|
|
const stopWatch = isSupported.value ? watch(
|
|
() => [targets.value, unrefElement(root2), isActive.value],
|
|
([targets2, root22]) => {
|
|
cleanup();
|
|
if (!isActive.value)
|
|
return;
|
|
if (!targets2.length)
|
|
return;
|
|
const observer = new IntersectionObserver(
|
|
callback,
|
|
{
|
|
root: unrefElement(root22),
|
|
rootMargin,
|
|
threshold
|
|
}
|
|
);
|
|
targets2.forEach((el) => el && observer.observe(el));
|
|
cleanup = () => {
|
|
observer.disconnect();
|
|
cleanup = noop;
|
|
};
|
|
},
|
|
{ immediate, flush: "post" }
|
|
) : noop;
|
|
const stop = () => {
|
|
cleanup();
|
|
stopWatch();
|
|
isActive.value = false;
|
|
};
|
|
tryOnScopeDispose(stop);
|
|
return {
|
|
isSupported,
|
|
isActive,
|
|
pause() {
|
|
cleanup();
|
|
isActive.value = false;
|
|
},
|
|
resume() {
|
|
isActive.value = true;
|
|
},
|
|
stop
|
|
};
|
|
}
|
|
var defaultState = {
|
|
x: 0,
|
|
y: 0,
|
|
pointerId: 0,
|
|
pressure: 0,
|
|
tiltX: 0,
|
|
tiltY: 0,
|
|
width: 0,
|
|
height: 0,
|
|
twist: 0,
|
|
pointerType: null
|
|
};
|
|
var keys = Object.keys(defaultState);
|
|
var DEFAULT_UNITS = [
|
|
{ max: 6e4, value: 1e3, name: "second" },
|
|
{ max: 276e4, value: 6e4, name: "minute" },
|
|
{ max: 72e6, value: 36e5, name: "hour" },
|
|
{ max: 5184e5, value: 864e5, name: "day" },
|
|
{ max: 24192e5, value: 6048e5, name: "week" },
|
|
{ max: 28512e6, value: 2592e6, name: "month" },
|
|
{ max: Number.POSITIVE_INFINITY, value: 31536e6, name: "year" }
|
|
];
|
|
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 = Object.assign({}, { linear: identity }, _TransitionPresets);
|
|
function useVModel(props2, key, emit, options = {}) {
|
|
var _a, _b, _c;
|
|
const {
|
|
clone: clone2 = false,
|
|
passive = false,
|
|
eventName,
|
|
deep = false,
|
|
defaultValue,
|
|
shouldEmit
|
|
} = options;
|
|
const vm = getCurrentInstance();
|
|
const _emit = emit || (vm == null ? void 0 : vm.emit) || ((_a = vm == null ? void 0 : vm.$emit) == null ? void 0 : _a.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) {
|
|
key = "modelValue";
|
|
}
|
|
event = event || `update:${key.toString()}`;
|
|
const cloneFn = (val) => !clone2 ? val : typeof clone2 === "function" ? clone2(val) : cloneFnJSON(val);
|
|
const getValue3 = () => isDef(props2[key]) ? cloneFn(props2[key]) : defaultValue;
|
|
const triggerEmit = (value) => {
|
|
if (shouldEmit) {
|
|
if (shouldEmit(value))
|
|
_emit(event, value);
|
|
} else {
|
|
_emit(event, value);
|
|
}
|
|
};
|
|
if (passive) {
|
|
const initialValue = getValue3();
|
|
const proxy = ref(initialValue);
|
|
let isUpdating = false;
|
|
watch(
|
|
() => props2[key],
|
|
(v2) => {
|
|
if (!isUpdating) {
|
|
isUpdating = true;
|
|
proxy.value = cloneFn(v2);
|
|
nextTick(() => isUpdating = false);
|
|
}
|
|
}
|
|
);
|
|
watch(
|
|
proxy,
|
|
(v2) => {
|
|
if (!isUpdating && (v2 !== props2[key] || deep))
|
|
triggerEmit(v2);
|
|
},
|
|
{ deep }
|
|
);
|
|
return proxy;
|
|
} else {
|
|
return computed({
|
|
get() {
|
|
return getValue3();
|
|
},
|
|
set(value) {
|
|
triggerEmit(value);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function useWindowFocus(options = {}) {
|
|
const { window: window2 = defaultWindow } = options;
|
|
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 = Number.POSITIVE_INFINITY,
|
|
initialHeight = Number.POSITIVE_INFINITY,
|
|
listenOrientation = true,
|
|
includeScrollbar = true,
|
|
type: type4 = "inner"
|
|
} = options;
|
|
const width = ref(initialWidth);
|
|
const height = ref(initialHeight);
|
|
const update2 = () => {
|
|
if (window2) {
|
|
if (type4 === "outer") {
|
|
width.value = window2.outerWidth;
|
|
height.value = window2.outerHeight;
|
|
} else 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) {
|
|
const matches2 = useMediaQuery("(orientation: portrait)");
|
|
watch(matches2, () => update2());
|
|
}
|
|
return { width, height };
|
|
}
|
|
|
|
// node_modules/element-plus/es/utils/browser.mjs
|
|
var isFirefox = () => isClient && /firefox/i.test(window.navigator.userAgent);
|
|
var isAndroid = () => isClient && /android/i.test(window.navigator.userAgent);
|
|
|
|
// 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 isObject3(value) {
|
|
var type4 = typeof value;
|
|
return value != null && (type4 == "object" || type4 == "function");
|
|
}
|
|
var isObject_default = isObject3;
|
|
|
|
// 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 identity2(value) {
|
|
return value;
|
|
}
|
|
var identity_default = identity2;
|
|
|
|
// 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 WeakMap2 = getNative_default(root_default, "WeakMap");
|
|
var WeakMap_default = WeakMap2;
|
|
|
|
// 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 noop2() {
|
|
}
|
|
var noop_default = noop2;
|
|
|
|
// 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 keys2(object4) {
|
|
return isArrayLike_default(object4) ? arrayLikeKeys_default(object4) : baseKeys_default(object4);
|
|
}
|
|
var keys_default = keys2;
|
|
|
|
// 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 toString2(value) {
|
|
return value == null ? "" : baseToString_default(value);
|
|
}
|
|
var toString_default = toString2;
|
|
|
|
// 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 clamp2(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 = clamp2;
|
|
|
|
// 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(set2) {
|
|
var index = -1, result2 = Array(set2.size);
|
|
set2.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(set2) {
|
|
var index = -1, result2 = Array(set2.size);
|
|
set2.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];
|
|
baseAssignValue_default(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
|
|
var objectProto27 = Object.prototype;
|
|
var hasOwnProperty23 = objectProto27.hasOwnProperty;
|
|
function baseUnset(object4, path) {
|
|
path = castPath_default(path, object4);
|
|
var index = -1, length = path.length;
|
|
if (!length) {
|
|
return true;
|
|
}
|
|
while (++index < length) {
|
|
var key = toKey_default(path[index]);
|
|
if (key === "__proto__" && !hasOwnProperty23.call(object4, "__proto__")) {
|
|
return false;
|
|
}
|
|
if ((key === "constructor" || key === "prototype") && index < length - 1) {
|
|
return false;
|
|
}
|
|
}
|
|
var obj = parent_default(object4, path);
|
|
return obj == null || delete obj[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, step2, fromRight) {
|
|
var index = -1, length = nativeMax13(nativeCeil4((end - start) / (step2 || 1)), 0), result2 = Array(length);
|
|
while (length--) {
|
|
result2[fromRight ? length : ++index] = start;
|
|
start += step2;
|
|
}
|
|
return result2;
|
|
}
|
|
var baseRange_default = baseRange;
|
|
|
|
// node_modules/lodash-es/_createRange.js
|
|
function createRange(fromRight) {
|
|
return function(start, end, step2) {
|
|
if (step2 && typeof step2 != "number" && isIterateeCall_default(start, end, step2)) {
|
|
end = step2 = void 0;
|
|
}
|
|
start = toFinite_default(start);
|
|
if (end === void 0) {
|
|
end = start;
|
|
start = 0;
|
|
} else {
|
|
end = toFinite_default(end);
|
|
}
|
|
step2 = step2 === void 0 ? start < end ? 1 : -1 : toFinite_default(step2);
|
|
return baseRange_default(start, end, step2, 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 objectProto28 = Object.prototype;
|
|
var hasOwnProperty24 = objectProto28.hasOwnProperty;
|
|
function customDefaultsAssignIn(objValue, srcValue, key, object4) {
|
|
if (objValue === void 0 || eq_default(objValue, objectProto28[key]) && !hasOwnProperty24.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 INVALID_TEMPL_IMPORTS_ERROR_TEXT = "Invalid `imports` 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 objectProto29 = Object.prototype;
|
|
var hasOwnProperty25 = objectProto29.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 = assignWith_default({}, options, settings, customDefaultsAssignIn_default);
|
|
var imports = assignWith_default({}, options.imports, settings.imports, customDefaultsAssignIn_default), importsKeys = keys_default(imports), importsValues = baseValues_default(imports, importsKeys);
|
|
arrayEach_default(importsKeys, function(key) {
|
|
if (reForbiddenIdentifierChars.test(key)) {
|
|
throw new Error(INVALID_TEMPL_IMPORTS_ERROR_TEXT);
|
|
}
|
|
});
|
|
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 = hasOwnProperty25.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 = hasOwnProperty25.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 set2 = iteratee2 ? null : createSet_default(array4);
|
|
if (set2) {
|
|
return setToArray_default(set2);
|
|
}
|
|
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.18.1";
|
|
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 objectProto30 = Object.prototype;
|
|
var hasOwnProperty26 = objectProto30.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 (!hasOwnProperty26.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 (!hasOwnProperty26.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/element-plus/es/directives/click-outside/index.mjs
|
|
var nodeList = /* @__PURE__ */ 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/directives/repeat-click/index.mjs
|
|
var REPEAT_INTERVAL = 100;
|
|
var REPEAT_DELAY = 600;
|
|
var SCOPE = "_RepeatClick";
|
|
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;
|
|
}
|
|
};
|
|
const start = (evt) => {
|
|
if (evt.button !== 0)
|
|
return;
|
|
clear();
|
|
handler();
|
|
document.addEventListener("mouseup", clear, { once: true });
|
|
delayId = setTimeout(() => {
|
|
intervalId = setInterval(() => {
|
|
handler();
|
|
}, interval);
|
|
}, delay2);
|
|
};
|
|
el[SCOPE] = {
|
|
start,
|
|
clear
|
|
};
|
|
el.addEventListener("mousedown", start);
|
|
},
|
|
unmounted(el) {
|
|
if (!el[SCOPE])
|
|
return;
|
|
const { start, clear } = el[SCOPE];
|
|
if (start)
|
|
el.removeEventListener("mousedown", start);
|
|
if (clear) {
|
|
clear();
|
|
document.removeEventListener("mouseup", clear);
|
|
}
|
|
el[SCOPE] = 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 isShadowRoot = (e) => {
|
|
if (typeof ShadowRoot === "undefined")
|
|
return false;
|
|
return e instanceof ShadowRoot;
|
|
};
|
|
var isHTMLElement = (e) => {
|
|
if (typeof Element === "undefined")
|
|
return false;
|
|
return e instanceof Element;
|
|
};
|
|
var isVisible = (element) => {
|
|
return getComputedStyle(element).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);
|
|
return siblings[Array.prototype.indexOf.call(siblings, el) + distance] || null;
|
|
};
|
|
var focusElement = (el, options) => {
|
|
if (!el || !el.focus)
|
|
return;
|
|
let cleanup = false;
|
|
if (isHTMLElement(el) && !isFocusable(el) && !el.getAttribute("tabindex")) {
|
|
el.setAttribute("tabindex", "-1");
|
|
cleanup = true;
|
|
}
|
|
el.focus(options);
|
|
if (isHTMLElement(el) && cleanup)
|
|
el.removeAttribute("tabindex");
|
|
};
|
|
var focusNode = (el) => {
|
|
if (!el)
|
|
return;
|
|
focusElement(el);
|
|
!isLeaf(el) && el.click();
|
|
};
|
|
|
|
// 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;
|
|
};
|
|
var getEventCode = (event) => {
|
|
if (event.code && event.code !== "Unidentified")
|
|
return event.code;
|
|
const key = getEventKey(event);
|
|
if (key) {
|
|
if (Object.values(EVENT_CODE).includes(key))
|
|
return key;
|
|
switch (key) {
|
|
case " ":
|
|
return EVENT_CODE.space;
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
return "";
|
|
};
|
|
var getEventKey = (event) => {
|
|
let key = event.key && event.key !== "Unidentified" ? event.key : "";
|
|
if (!key && event.type === "keyup" && isAndroid()) {
|
|
const target2 = event.target;
|
|
key = target2.value.charAt(target2.selectionStart - 1);
|
|
}
|
|
return key;
|
|
};
|
|
|
|
// node_modules/element-plus/es/directives/trap-focus/index.mjs
|
|
var FOCUSABLE_CHILDREN = "_trap-focus-children";
|
|
var FOCUS_STACK = [];
|
|
var FOCUS_HANDLER = (e) => {
|
|
if (FOCUS_STACK.length === 0)
|
|
return;
|
|
const code = getEventCode(e);
|
|
const focusableElement = FOCUS_STACK[FOCUS_STACK.length - 1][FOCUSABLE_CHILDREN];
|
|
if (focusableElement.length > 0 && 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();
|
|
}
|
|
}
|
|
};
|
|
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/normalize-wheel-es/dist/index.mjs
|
|
var v = false;
|
|
var o;
|
|
var f;
|
|
var s;
|
|
var u;
|
|
var d;
|
|
var N;
|
|
var l;
|
|
var p;
|
|
var m;
|
|
var w;
|
|
var D;
|
|
var x;
|
|
var E;
|
|
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), E = /\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);
|
|
N = 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() || N > 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 || E || w || F;
|
|
}, nativeApp: function() {
|
|
return a() || M;
|
|
}, android: function() {
|
|
return a() || w;
|
|
}, ipad: function() {
|
|
return a() || E;
|
|
} };
|
|
var A = _;
|
|
var c = !!(typeof window < "u" && window.document && window.document.createElement);
|
|
var U = { canUseDOM: c, canUseWorkers: typeof Worker < "u", canUseEventListeners: c && !!(window.addEventListener || window.attachEvent), canUseViewport: c && !!window.screen, isInWorker: !c };
|
|
var h2 = U;
|
|
var X;
|
|
h2.canUseDOM && (X = 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 && X && e === "wheel" && (r = document.implementation.hasFeature("Events.wheel", "3.0")), r;
|
|
}
|
|
var b = S;
|
|
var O = 10;
|
|
var I = 40;
|
|
var P = 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 *= I, t *= I) : (r *= P, t *= P)), 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 SCOPE2 = "_Mousewheel";
|
|
var mousewheel = function(element, callback) {
|
|
if (element && element.addEventListener) {
|
|
removeWheelHandler(element);
|
|
const fn2 = function(event) {
|
|
const normalized = Y(event);
|
|
callback && Reflect.apply(callback, this, [event, normalized]);
|
|
};
|
|
element[SCOPE2] = { wheelHandler: fn2 };
|
|
element.addEventListener("wheel", fn2, { passive: true });
|
|
}
|
|
};
|
|
var removeWheelHandler = (element) => {
|
|
var _a;
|
|
if ((_a = element[SCOPE2]) == null ? void 0 : _a.wheelHandler) {
|
|
element.removeEventListener("wheel", element[SCOPE2].wheelHandler);
|
|
element[SCOPE2] = null;
|
|
}
|
|
};
|
|
var Mousewheel = {
|
|
beforeMount(el, binding) {
|
|
mousewheel(el, binding.value);
|
|
},
|
|
unmounted(el) {
|
|
removeWheelHandler(el);
|
|
},
|
|
updated(el, binding) {
|
|
if (binding.value !== binding.oldValue)
|
|
mousewheel(el, binding.value);
|
|
}
|
|
};
|
|
|
|
// 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/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 epProp = {
|
|
type: type4,
|
|
required: !!required4,
|
|
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,
|
|
[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/components/teleport/src/teleport.mjs
|
|
var teleportProps = buildProps({
|
|
to: {
|
|
type: definePropType([String, Object]),
|
|
required: true
|
|
},
|
|
disabled: Boolean
|
|
});
|
|
|
|
// 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"
|
|
},
|
|
teleported: Boolean,
|
|
appendTo: {
|
|
type: teleportProps.to.type,
|
|
default: "body"
|
|
}
|
|
});
|
|
var affixEmits = {
|
|
scroll: ({ scrollTop, fixed }) => isNumber2(scrollTop) && isBoolean2(fixed),
|
|
[CHANGE_EVENT]: (fixed) => isBoolean2(fixed)
|
|
};
|
|
|
|
// 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) {
|
|
{
|
|
const error = isString(scope) ? new ElementPlusError(`[${scope}] ${message2}`) : scope;
|
|
console.warn(error);
|
|
}
|
|
}
|
|
|
|
// 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 _a;
|
|
return fromPairs_default(Object.entries((_a = instance.proxy) == null ? void 0 : _a.$attrs).filter(([key]) => !allExcludeKeys.value.includes(key) && !(excludeListeners && LISTENER_PREFIX.test(key))));
|
|
});
|
|
};
|
|
|
|
// node_modules/element-plus/es/hooks/use-calc-input-width/index.mjs
|
|
function useCalcInputWidth() {
|
|
const calculatorRef = shallowRef();
|
|
const calculatorWidth = ref(0);
|
|
const inputStyle = computed(() => ({ minWidth: `${Math.max(calculatorWidth.value, MINIMUM_INPUT_WIDTH)}px` }));
|
|
const resetCalculatorWidth = () => {
|
|
var _a, _b;
|
|
calculatorWidth.value = (_b = (_a = calculatorRef.value) == null ? void 0 : _a.getBoundingClientRect().width) != null ? _b : 0;
|
|
};
|
|
useResizeObserver(calculatorRef, resetCalculatorWidth);
|
|
return {
|
|
calculatorRef,
|
|
calculatorWidth,
|
|
inputStyle
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/hooks/use-deprecated/index.mjs
|
|
var useDeprecated = ({ from, replacement, scope, version: version3, ref: ref2, type: type4 = "API" }, condition) => {
|
|
watch(() => unref(condition), (val) => {
|
|
if (val)
|
|
debugWarn(scope, `[${type4}] ${from} is about to be deprecated in version ${version3}, please use ${replacement} instead.
|
|
For more detail, please visit: ${ref2}
|
|
`);
|
|
}, { immediate: true });
|
|
};
|
|
|
|
// 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/utils/dom/style.mjs
|
|
var SCOPE3 = "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 _a;
|
|
if (!isClient || !element || !styleName || isShadowRoot(element))
|
|
return "";
|
|
let key = camelize(styleName);
|
|
if (key === "float")
|
|
key = "cssFloat";
|
|
try {
|
|
const style = element.style[key];
|
|
if (style)
|
|
return style;
|
|
const computed2 = (_a = document.defaultView) == null ? void 0 : _a.getComputedStyle(element, "");
|
|
return computed2 ? computed2[key] : "";
|
|
} catch {
|
|
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 && value !== 0)
|
|
return "";
|
|
if (isNumber2(value) || isStringNumber(value))
|
|
return `${value}${defaultUnit}`;
|
|
else if (isString(value))
|
|
return value;
|
|
debugWarn(SCOPE3, "binding value must be a string or number");
|
|
}
|
|
|
|
// node_modules/element-plus/es/hooks/use-draggable/index.mjs
|
|
var useDraggable = (targetRef, dragRef, draggable2, overflow) => {
|
|
const transform2 = {
|
|
offsetX: 0,
|
|
offsetY: 0
|
|
};
|
|
const isDragging2 = ref(false);
|
|
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 < clientHeight ? targetHeight : 0) + 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) => {
|
|
if (!isDragging2.value)
|
|
isDragging2.value = true;
|
|
adjustPosition(offsetX + e2.clientX - downX, offsetY + e2.clientY - downY);
|
|
};
|
|
const onMouseup = () => {
|
|
isDragging2.value = false;
|
|
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 {
|
|
isDragging: isDragging2,
|
|
resetPosition,
|
|
updatePosition
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/hooks/use-focus/index.mjs
|
|
var useFocus = (el) => {
|
|
return { focus: () => {
|
|
var _a, _b;
|
|
(_b = (_a = el.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
|
|
} };
|
|
};
|
|
|
|
// node_modules/element-plus/es/locale/lang/en.mjs
|
|
var en_default = {
|
|
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",
|
|
alphaDescription: "alpha {alpha}, current color is {color}",
|
|
hueLabel: "pick hue value",
|
|
hueDescription: "hue {hue}, current color is {color}",
|
|
svLabel: "pick saturation and brightness value",
|
|
svDescription: "saturation {saturation}, brightness {brightness}, current color is {color}",
|
|
predefineDescription: "select {value} as the color"
|
|
},
|
|
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",
|
|
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",
|
|
selectAllLabel: "Select all rows",
|
|
selectRowLabel: "Select this row",
|
|
expandRowLabel: "Expand this row",
|
|
collapseRowLabel: "Collapse this row",
|
|
sortLabel: "Sort by {column}",
|
|
filterLabel: "Filter by {column}"
|
|
},
|
|
tag: { close: "Close this tag" },
|
|
tour: {
|
|
next: "Next",
|
|
previous: "Previous",
|
|
finish: "Finish",
|
|
close: "Close this dialog"
|
|
},
|
|
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 _a;
|
|
return `${(_a = option == null ? void 0 : option[key]) != null ? _a : `{${key}}`}`;
|
|
});
|
|
var buildLocaleContext = (locale) => {
|
|
return {
|
|
lang: computed(() => unref(locale).name),
|
|
locale: isRef(locale) ? locale : ref(locale),
|
|
t: buildTranslator(locale)
|
|
};
|
|
};
|
|
var localeContextKey = Symbol("localeContextKey");
|
|
var useLocale = (localeOverrides) => {
|
|
const locale = localeOverrides || inject(localeContextKey, ref());
|
|
return buildLocaleContext(computed(() => locale.value || en_default));
|
|
};
|
|
|
|
// 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));
|
|
return computed(() => {
|
|
return unref(derivedNamespace) || defaultNamespace;
|
|
});
|
|
};
|
|
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/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/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;
|
|
if (isShadowRoot(parent2))
|
|
parent2 = parent2.host;
|
|
else
|
|
parent2 = parent2.parentNode;
|
|
}
|
|
return parent2;
|
|
};
|
|
var scrollBarWidth;
|
|
var getScrollBarWidth = (namespace) => {
|
|
var _a;
|
|
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;
|
|
(_a = outer.parentNode) == null ? void 0 : _a.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 time = Date.now() - 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/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"));
|
|
let scrollBarWidth2 = 0;
|
|
let withoutHiddenClass = false;
|
|
let bodyWidth = "0";
|
|
let cleaned = false;
|
|
const cleanup = () => {
|
|
if (cleaned)
|
|
return;
|
|
cleaned = true;
|
|
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;
|
|
}
|
|
cleaned = false;
|
|
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/hooks/use-modal/index.mjs
|
|
var modalStack = [];
|
|
var closeModal = (e) => {
|
|
if (modalStack.length === 0)
|
|
return;
|
|
if (getEventCode(e) === EVENT_CODE.esc) {
|
|
e.stopPropagation();
|
|
modalStack[modalStack.length - 1].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-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/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/hooks/use-prop/index.mjs
|
|
var useProp = (name) => {
|
|
const vm = getCurrentInstance();
|
|
return computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = vm == null ? void 0 : vm.proxy) == null ? void 0 : _a.$props) == null ? void 0 : _b[name];
|
|
});
|
|
};
|
|
|
|
// node_modules/@popperjs/core/dist/index.mjs
|
|
var L = "top";
|
|
var W = "bottom";
|
|
var T2 = "right";
|
|
var P2 = "left";
|
|
var me = "auto";
|
|
var Q = [L, W, T2, P2];
|
|
var Y2 = "start";
|
|
var Z = "end";
|
|
var Ye = "clippingParents";
|
|
var je = "viewport";
|
|
var ee = "popper";
|
|
var Ge = "reference";
|
|
var De = Q.reduce(function(e, t) {
|
|
return e.concat([t + "-" + Y2, t + "-" + Z]);
|
|
}, []);
|
|
var Ee = [].concat(Q, [me]).reduce(function(e, t) {
|
|
return e.concat([t, t + "-" + Y2, t + "-" + Z]);
|
|
}, []);
|
|
var Je = "beforeRead";
|
|
var Ke = "read";
|
|
var Qe = "afterRead";
|
|
var Ze = "beforeMain";
|
|
var et = "main";
|
|
var tt = "afterMain";
|
|
var nt = "beforeWrite";
|
|
var rt = "write";
|
|
var ot = "afterWrite";
|
|
var it = [Je, Ke, Qe, Ze, et, tt, nt, rt, ot];
|
|
function V(e) {
|
|
return e ? (e.nodeName || "").toLowerCase() : null;
|
|
}
|
|
function B(e) {
|
|
if (e == null)
|
|
return window;
|
|
if (e.toString() !== "[object Window]") {
|
|
var t = e.ownerDocument;
|
|
return t && t.defaultView || window;
|
|
}
|
|
return e;
|
|
}
|
|
function G(e) {
|
|
var t = B(e).Element;
|
|
return e instanceof t || e instanceof Element;
|
|
}
|
|
function R(e) {
|
|
var t = B(e).HTMLElement;
|
|
return e instanceof t || e instanceof HTMLElement;
|
|
}
|
|
function Ae(e) {
|
|
if (typeof ShadowRoot == "undefined")
|
|
return false;
|
|
var t = B(e).ShadowRoot;
|
|
return e instanceof t || e instanceof ShadowRoot;
|
|
}
|
|
function Tt(e) {
|
|
var t = e.state;
|
|
Object.keys(t.elements).forEach(function(n) {
|
|
var r = t.styles[n] || {}, o2 = t.attributes[n] || {}, a2 = t.elements[n];
|
|
!R(a2) || !V(a2) || (Object.assign(a2.style, r), Object.keys(o2).forEach(function(c2) {
|
|
var s2 = o2[c2];
|
|
s2 === false ? a2.removeAttribute(c2) : a2.setAttribute(c2, s2 === true ? "" : s2);
|
|
}));
|
|
});
|
|
}
|
|
function Bt(e) {
|
|
var t = e.state, n = { popper: { position: t.options.strategy, left: "0", top: "0", margin: "0" }, arrow: { position: "absolute" }, reference: {} };
|
|
return Object.assign(t.elements.popper.style, n.popper), t.styles = n, t.elements.arrow && Object.assign(t.elements.arrow.style, n.arrow), function() {
|
|
Object.keys(t.elements).forEach(function(r) {
|
|
var o2 = t.elements[r], a2 = t.attributes[r] || {}, c2 = Object.keys(t.styles.hasOwnProperty(r) ? t.styles[r] : n[r]), s2 = c2.reduce(function(i, f2) {
|
|
return i[f2] = "", i;
|
|
}, {});
|
|
!R(o2) || !V(o2) || (Object.assign(o2.style, s2), Object.keys(a2).forEach(function(i) {
|
|
o2.removeAttribute(i);
|
|
}));
|
|
});
|
|
};
|
|
}
|
|
var ke = { name: "applyStyles", enabled: true, phase: "write", fn: Tt, effect: Bt, requires: ["computeStyles"] };
|
|
function C(e) {
|
|
return e.split("-")[0];
|
|
}
|
|
var J = Math.max;
|
|
var ve = Math.min;
|
|
var te = Math.round;
|
|
function Le() {
|
|
var e = navigator.userAgentData;
|
|
return e != null && e.brands && Array.isArray(e.brands) ? e.brands.map(function(t) {
|
|
return t.brand + "/" + t.version;
|
|
}).join(" ") : navigator.userAgent;
|
|
}
|
|
function at2() {
|
|
return !/^((?!chrome|android).)*safari/i.test(Le());
|
|
}
|
|
function ne(e, t, n) {
|
|
t === void 0 && (t = false), n === void 0 && (n = false);
|
|
var r = e.getBoundingClientRect(), o2 = 1, a2 = 1;
|
|
t && R(e) && (o2 = e.offsetWidth > 0 && te(r.width) / e.offsetWidth || 1, a2 = e.offsetHeight > 0 && te(r.height) / e.offsetHeight || 1);
|
|
var c2 = G(e) ? B(e) : window, s2 = c2.visualViewport, i = !at2() && n, f2 = (r.left + (i && s2 ? s2.offsetLeft : 0)) / o2, u2 = (r.top + (i && s2 ? s2.offsetTop : 0)) / a2, m2 = r.width / o2, h3 = r.height / a2;
|
|
return { width: m2, height: h3, top: u2, right: f2 + m2, bottom: u2 + h3, left: f2, x: f2, y: u2 };
|
|
}
|
|
function Pe(e) {
|
|
var t = ne(e), n = e.offsetWidth, r = e.offsetHeight;
|
|
return Math.abs(t.width - n) <= 1 && (n = t.width), Math.abs(t.height - r) <= 1 && (r = t.height), { x: e.offsetLeft, y: e.offsetTop, width: n, height: r };
|
|
}
|
|
function st(e, t) {
|
|
var n = t.getRootNode && t.getRootNode();
|
|
if (e.contains(t))
|
|
return true;
|
|
if (n && Ae(n)) {
|
|
var r = t;
|
|
do {
|
|
if (r && e.isSameNode(r))
|
|
return true;
|
|
r = r.parentNode || r.host;
|
|
} while (r);
|
|
}
|
|
return false;
|
|
}
|
|
function I2(e) {
|
|
return B(e).getComputedStyle(e);
|
|
}
|
|
function Rt(e) {
|
|
return ["table", "td", "th"].indexOf(V(e)) >= 0;
|
|
}
|
|
function N2(e) {
|
|
return ((G(e) ? e.ownerDocument : e.document) || window.document).documentElement;
|
|
}
|
|
function ye(e) {
|
|
return V(e) === "html" ? e : e.assignedSlot || e.parentNode || (Ae(e) ? e.host : null) || N2(e);
|
|
}
|
|
function ft(e) {
|
|
return !R(e) || I2(e).position === "fixed" ? null : e.offsetParent;
|
|
}
|
|
function Ht(e) {
|
|
var t = /firefox/i.test(Le()), n = /Trident/i.test(Le());
|
|
if (n && R(e)) {
|
|
var r = I2(e);
|
|
if (r.position === "fixed")
|
|
return null;
|
|
}
|
|
var o2 = ye(e);
|
|
for (Ae(o2) && (o2 = o2.host); R(o2) && ["html", "body"].indexOf(V(o2)) < 0; ) {
|
|
var a2 = I2(o2);
|
|
if (a2.transform !== "none" || a2.perspective !== "none" || a2.contain === "paint" || ["transform", "perspective"].indexOf(a2.willChange) !== -1 || t && a2.willChange === "filter" || t && a2.filter && a2.filter !== "none")
|
|
return o2;
|
|
o2 = o2.parentNode;
|
|
}
|
|
return null;
|
|
}
|
|
function se(e) {
|
|
for (var t = B(e), n = ft(e); n && Rt(n) && I2(n).position === "static"; )
|
|
n = ft(n);
|
|
return n && (V(n) === "html" || V(n) === "body" && I2(n).position === "static") ? t : n || Ht(e) || t;
|
|
}
|
|
function Me(e) {
|
|
return ["top", "bottom"].indexOf(e) >= 0 ? "x" : "y";
|
|
}
|
|
function fe(e, t, n) {
|
|
return J(e, ve(t, n));
|
|
}
|
|
function St(e, t, n) {
|
|
var r = fe(e, t, n);
|
|
return r > n ? n : r;
|
|
}
|
|
function ct() {
|
|
return { top: 0, right: 0, bottom: 0, left: 0 };
|
|
}
|
|
function ut(e) {
|
|
return Object.assign({}, ct(), e);
|
|
}
|
|
function pt(e, t) {
|
|
return t.reduce(function(n, r) {
|
|
return n[r] = e, n;
|
|
}, {});
|
|
}
|
|
var Vt = function(e, t) {
|
|
return e = typeof e == "function" ? e(Object.assign({}, t.rects, { placement: t.placement })) : e, ut(typeof e != "number" ? e : pt(e, Q));
|
|
};
|
|
function Ct(e) {
|
|
var t, n = e.state, r = e.name, o2 = e.options, a2 = n.elements.arrow, c2 = n.modifiersData.popperOffsets, s2 = C(n.placement), i = Me(s2), f2 = [P2, T2].indexOf(s2) >= 0, u2 = f2 ? "height" : "width";
|
|
if (!(!a2 || !c2)) {
|
|
var m2 = Vt(o2.padding, n), h3 = Pe(a2), l2 = i === "y" ? L : P2, g = i === "y" ? W : T2, p2 = n.rects.reference[u2] + n.rects.reference[i] - c2[i] - n.rects.popper[u2], y = c2[i] - n.rects.reference[i], b2 = se(a2), x2 = b2 ? i === "y" ? b2.clientHeight || 0 : b2.clientWidth || 0 : 0, O2 = p2 / 2 - y / 2, d2 = m2[l2], v2 = x2 - h3[u2] - m2[g], w2 = x2 / 2 - h3[u2] / 2 + O2, $ = fe(d2, w2, v2), j = i;
|
|
n.modifiersData[r] = (t = {}, t[j] = $, t.centerOffset = $ - w2, t);
|
|
}
|
|
}
|
|
function qt(e) {
|
|
var t = e.state, n = e.options, r = n.element, o2 = r === void 0 ? "[data-popper-arrow]" : r;
|
|
o2 != null && (typeof o2 == "string" && (o2 = t.elements.popper.querySelector(o2), !o2) || st(t.elements.popper, o2) && (t.elements.arrow = o2));
|
|
}
|
|
var lt2 = { name: "arrow", enabled: true, phase: "main", fn: Ct, effect: qt, requires: ["popperOffsets"], requiresIfExists: ["preventOverflow"] };
|
|
function re(e) {
|
|
return e.split("-")[1];
|
|
}
|
|
var It = { top: "auto", right: "auto", bottom: "auto", left: "auto" };
|
|
function Nt(e, t) {
|
|
var n = e.x, r = e.y, o2 = t.devicePixelRatio || 1;
|
|
return { x: te(n * o2) / o2 || 0, y: te(r * o2) / o2 || 0 };
|
|
}
|
|
function dt(e) {
|
|
var t, n = e.popper, r = e.popperRect, o2 = e.placement, a2 = e.variation, c2 = e.offsets, s2 = e.position, i = e.gpuAcceleration, f2 = e.adaptive, u2 = e.roundOffsets, m2 = e.isFixed, h3 = c2.x, l2 = h3 === void 0 ? 0 : h3, g = c2.y, p2 = g === void 0 ? 0 : g, y = typeof u2 == "function" ? u2({ x: l2, y: p2 }) : { x: l2, y: p2 };
|
|
l2 = y.x, p2 = y.y;
|
|
var b2 = c2.hasOwnProperty("x"), x2 = c2.hasOwnProperty("y"), O2 = P2, d2 = L, v2 = window;
|
|
if (f2) {
|
|
var w2 = se(n), $ = "clientHeight", j = "clientWidth";
|
|
if (w2 === B(n) && (w2 = N2(n), I2(w2).position !== "static" && s2 === "absolute" && ($ = "scrollHeight", j = "scrollWidth")), w2 = w2, o2 === L || (o2 === P2 || o2 === T2) && a2 === Z) {
|
|
d2 = W;
|
|
var D2 = m2 && w2 === v2 && v2.visualViewport ? v2.visualViewport.height : w2[$];
|
|
p2 -= D2 - r.height, p2 *= i ? 1 : -1;
|
|
}
|
|
if (o2 === P2 || (o2 === L || o2 === W) && a2 === Z) {
|
|
O2 = T2;
|
|
var E2 = m2 && w2 === v2 && v2.visualViewport ? v2.visualViewport.width : w2[j];
|
|
l2 -= E2 - r.width, l2 *= i ? 1 : -1;
|
|
}
|
|
}
|
|
var A2 = Object.assign({ position: s2 }, f2 && It), H = u2 === true ? Nt({ x: l2, y: p2 }, B(n)) : { x: l2, y: p2 };
|
|
if (l2 = H.x, p2 = H.y, i) {
|
|
var k;
|
|
return Object.assign({}, A2, (k = {}, k[d2] = x2 ? "0" : "", k[O2] = b2 ? "0" : "", k.transform = (v2.devicePixelRatio || 1) <= 1 ? "translate(" + l2 + "px, " + p2 + "px)" : "translate3d(" + l2 + "px, " + p2 + "px, 0)", k));
|
|
}
|
|
return Object.assign({}, A2, (t = {}, t[d2] = x2 ? p2 + "px" : "", t[O2] = b2 ? l2 + "px" : "", t.transform = "", t));
|
|
}
|
|
function Ft(e) {
|
|
var t = e.state, n = e.options, r = n.gpuAcceleration, o2 = r === void 0 ? true : r, a2 = n.adaptive, c2 = a2 === void 0 ? true : a2, s2 = n.roundOffsets, i = s2 === void 0 ? true : s2, f2 = { placement: C(t.placement), variation: re(t.placement), popper: t.elements.popper, popperRect: t.rects.popper, gpuAcceleration: o2, isFixed: t.options.strategy === "fixed" };
|
|
t.modifiersData.popperOffsets != null && (t.styles.popper = Object.assign({}, t.styles.popper, dt(Object.assign({}, f2, { offsets: t.modifiersData.popperOffsets, position: t.options.strategy, adaptive: c2, roundOffsets: i })))), t.modifiersData.arrow != null && (t.styles.arrow = Object.assign({}, t.styles.arrow, dt(Object.assign({}, f2, { offsets: t.modifiersData.arrow, position: "absolute", adaptive: false, roundOffsets: i })))), t.attributes.popper = Object.assign({}, t.attributes.popper, { "data-popper-placement": t.placement });
|
|
}
|
|
var We = { name: "computeStyles", enabled: true, phase: "beforeWrite", fn: Ft, data: {} };
|
|
var ge = { passive: true };
|
|
function Ut(e) {
|
|
var t = e.state, n = e.instance, r = e.options, o2 = r.scroll, a2 = o2 === void 0 ? true : o2, c2 = r.resize, s2 = c2 === void 0 ? true : c2, i = B(t.elements.popper), f2 = [].concat(t.scrollParents.reference, t.scrollParents.popper);
|
|
return a2 && f2.forEach(function(u2) {
|
|
u2.addEventListener("scroll", n.update, ge);
|
|
}), s2 && i.addEventListener("resize", n.update, ge), function() {
|
|
a2 && f2.forEach(function(u2) {
|
|
u2.removeEventListener("scroll", n.update, ge);
|
|
}), s2 && i.removeEventListener("resize", n.update, ge);
|
|
};
|
|
}
|
|
var Te = { name: "eventListeners", enabled: true, phase: "write", fn: function() {
|
|
}, effect: Ut, data: {} };
|
|
var _t = { left: "right", right: "left", bottom: "top", top: "bottom" };
|
|
function be(e) {
|
|
return e.replace(/left|right|bottom|top/g, function(t) {
|
|
return _t[t];
|
|
});
|
|
}
|
|
var zt = { start: "end", end: "start" };
|
|
function ht(e) {
|
|
return e.replace(/start|end/g, function(t) {
|
|
return zt[t];
|
|
});
|
|
}
|
|
function Be(e) {
|
|
var t = B(e), n = t.pageXOffset, r = t.pageYOffset;
|
|
return { scrollLeft: n, scrollTop: r };
|
|
}
|
|
function Re(e) {
|
|
return ne(N2(e)).left + Be(e).scrollLeft;
|
|
}
|
|
function Xt(e, t) {
|
|
var n = B(e), r = N2(e), o2 = n.visualViewport, a2 = r.clientWidth, c2 = r.clientHeight, s2 = 0, i = 0;
|
|
if (o2) {
|
|
a2 = o2.width, c2 = o2.height;
|
|
var f2 = at2();
|
|
(f2 || !f2 && t === "fixed") && (s2 = o2.offsetLeft, i = o2.offsetTop);
|
|
}
|
|
return { width: a2, height: c2, x: s2 + Re(e), y: i };
|
|
}
|
|
function Yt(e) {
|
|
var t, n = N2(e), r = Be(e), o2 = (t = e.ownerDocument) == null ? void 0 : t.body, a2 = J(n.scrollWidth, n.clientWidth, o2 ? o2.scrollWidth : 0, o2 ? o2.clientWidth : 0), c2 = J(n.scrollHeight, n.clientHeight, o2 ? o2.scrollHeight : 0, o2 ? o2.clientHeight : 0), s2 = -r.scrollLeft + Re(e), i = -r.scrollTop;
|
|
return I2(o2 || n).direction === "rtl" && (s2 += J(n.clientWidth, o2 ? o2.clientWidth : 0) - a2), { width: a2, height: c2, x: s2, y: i };
|
|
}
|
|
function He(e) {
|
|
var t = I2(e), n = t.overflow, r = t.overflowX, o2 = t.overflowY;
|
|
return /auto|scroll|overlay|hidden/.test(n + o2 + r);
|
|
}
|
|
function mt(e) {
|
|
return ["html", "body", "#document"].indexOf(V(e)) >= 0 ? e.ownerDocument.body : R(e) && He(e) ? e : mt(ye(e));
|
|
}
|
|
function ce(e, t) {
|
|
var n;
|
|
t === void 0 && (t = []);
|
|
var r = mt(e), o2 = r === ((n = e.ownerDocument) == null ? void 0 : n.body), a2 = B(r), c2 = o2 ? [a2].concat(a2.visualViewport || [], He(r) ? r : []) : r, s2 = t.concat(c2);
|
|
return o2 ? s2 : s2.concat(ce(ye(c2)));
|
|
}
|
|
function Se(e) {
|
|
return Object.assign({}, e, { left: e.x, top: e.y, right: e.x + e.width, bottom: e.y + e.height });
|
|
}
|
|
function Gt(e, t) {
|
|
var n = ne(e, false, t === "fixed");
|
|
return n.top = n.top + e.clientTop, n.left = n.left + e.clientLeft, n.bottom = n.top + e.clientHeight, n.right = n.left + e.clientWidth, n.width = e.clientWidth, n.height = e.clientHeight, n.x = n.left, n.y = n.top, n;
|
|
}
|
|
function vt(e, t, n) {
|
|
return t === je ? Se(Xt(e, n)) : G(t) ? Gt(t, n) : Se(Yt(N2(e)));
|
|
}
|
|
function Jt(e) {
|
|
var t = ce(ye(e)), n = ["absolute", "fixed"].indexOf(I2(e).position) >= 0, r = n && R(e) ? se(e) : e;
|
|
return G(r) ? t.filter(function(o2) {
|
|
return G(o2) && st(o2, r) && V(o2) !== "body";
|
|
}) : [];
|
|
}
|
|
function Kt(e, t, n, r) {
|
|
var o2 = t === "clippingParents" ? Jt(e) : [].concat(t), a2 = [].concat(o2, [n]), c2 = a2[0], s2 = a2.reduce(function(i, f2) {
|
|
var u2 = vt(e, f2, r);
|
|
return i.top = J(u2.top, i.top), i.right = ve(u2.right, i.right), i.bottom = ve(u2.bottom, i.bottom), i.left = J(u2.left, i.left), i;
|
|
}, vt(e, c2, r));
|
|
return s2.width = s2.right - s2.left, s2.height = s2.bottom - s2.top, s2.x = s2.left, s2.y = s2.top, s2;
|
|
}
|
|
function yt(e) {
|
|
var t = e.reference, n = e.element, r = e.placement, o2 = r ? C(r) : null, a2 = r ? re(r) : null, c2 = t.x + t.width / 2 - n.width / 2, s2 = t.y + t.height / 2 - n.height / 2, i;
|
|
switch (o2) {
|
|
case L:
|
|
i = { x: c2, y: t.y - n.height };
|
|
break;
|
|
case W:
|
|
i = { x: c2, y: t.y + t.height };
|
|
break;
|
|
case T2:
|
|
i = { x: t.x + t.width, y: s2 };
|
|
break;
|
|
case P2:
|
|
i = { x: t.x - n.width, y: s2 };
|
|
break;
|
|
default:
|
|
i = { x: t.x, y: t.y };
|
|
}
|
|
var f2 = o2 ? Me(o2) : null;
|
|
if (f2 != null) {
|
|
var u2 = f2 === "y" ? "height" : "width";
|
|
switch (a2) {
|
|
case Y2:
|
|
i[f2] = i[f2] - (t[u2] / 2 - n[u2] / 2);
|
|
break;
|
|
case Z:
|
|
i[f2] = i[f2] + (t[u2] / 2 - n[u2] / 2);
|
|
break;
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
function oe(e, t) {
|
|
t === void 0 && (t = {});
|
|
var n = t, r = n.placement, o2 = r === void 0 ? e.placement : r, a2 = n.strategy, c2 = a2 === void 0 ? e.strategy : a2, s2 = n.boundary, i = s2 === void 0 ? Ye : s2, f2 = n.rootBoundary, u2 = f2 === void 0 ? je : f2, m2 = n.elementContext, h3 = m2 === void 0 ? ee : m2, l2 = n.altBoundary, g = l2 === void 0 ? false : l2, p2 = n.padding, y = p2 === void 0 ? 0 : p2, b2 = ut(typeof y != "number" ? y : pt(y, Q)), x2 = h3 === ee ? Ge : ee, O2 = e.rects.popper, d2 = e.elements[g ? x2 : h3], v2 = Kt(G(d2) ? d2 : d2.contextElement || N2(e.elements.popper), i, u2, c2), w2 = ne(e.elements.reference), $ = yt({ reference: w2, element: O2, placement: o2 }), j = Se(Object.assign({}, O2, $)), D2 = h3 === ee ? j : w2, E2 = { top: v2.top - D2.top + b2.top, bottom: D2.bottom - v2.bottom + b2.bottom, left: v2.left - D2.left + b2.left, right: D2.right - v2.right + b2.right }, A2 = e.modifiersData.offset;
|
|
if (h3 === ee && A2) {
|
|
var H = A2[o2];
|
|
Object.keys(E2).forEach(function(k) {
|
|
var F2 = [T2, W].indexOf(k) >= 0 ? 1 : -1, U2 = [L, W].indexOf(k) >= 0 ? "y" : "x";
|
|
E2[k] += H[U2] * F2;
|
|
});
|
|
}
|
|
return E2;
|
|
}
|
|
function Qt(e, t) {
|
|
t === void 0 && (t = {});
|
|
var n = t, r = n.placement, o2 = n.boundary, a2 = n.rootBoundary, c2 = n.padding, s2 = n.flipVariations, i = n.allowedAutoPlacements, f2 = i === void 0 ? Ee : i, u2 = re(r), m2 = u2 ? s2 ? De : De.filter(function(g) {
|
|
return re(g) === u2;
|
|
}) : Q, h3 = m2.filter(function(g) {
|
|
return f2.indexOf(g) >= 0;
|
|
});
|
|
h3.length === 0 && (h3 = m2);
|
|
var l2 = h3.reduce(function(g, p2) {
|
|
return g[p2] = oe(e, { placement: p2, boundary: o2, rootBoundary: a2, padding: c2 })[C(p2)], g;
|
|
}, {});
|
|
return Object.keys(l2).sort(function(g, p2) {
|
|
return l2[g] - l2[p2];
|
|
});
|
|
}
|
|
function Zt(e) {
|
|
if (C(e) === me)
|
|
return [];
|
|
var t = be(e);
|
|
return [ht(e), t, ht(t)];
|
|
}
|
|
function en(e) {
|
|
var t = e.state, n = e.options, r = e.name;
|
|
if (!t.modifiersData[r]._skip) {
|
|
for (var o2 = n.mainAxis, a2 = o2 === void 0 ? true : o2, c2 = n.altAxis, s2 = c2 === void 0 ? true : c2, i = n.fallbackPlacements, f2 = n.padding, u2 = n.boundary, m2 = n.rootBoundary, h3 = n.altBoundary, l2 = n.flipVariations, g = l2 === void 0 ? true : l2, p2 = n.allowedAutoPlacements, y = t.options.placement, b2 = C(y), x2 = b2 === y, O2 = i || (x2 || !g ? [be(y)] : Zt(y)), d2 = [y].concat(O2).reduce(function(z, q) {
|
|
return z.concat(C(q) === me ? Qt(t, { placement: q, boundary: u2, rootBoundary: m2, padding: f2, flipVariations: g, allowedAutoPlacements: p2 }) : q);
|
|
}, []), v2 = t.rects.reference, w2 = t.rects.popper, $ = /* @__PURE__ */ new Map(), j = true, D2 = d2[0], E2 = 0; E2 < d2.length; E2++) {
|
|
var A2 = d2[E2], H = C(A2), k = re(A2) === Y2, F2 = [L, W].indexOf(H) >= 0, U2 = F2 ? "width" : "height", M2 = oe(t, { placement: A2, boundary: u2, rootBoundary: m2, altBoundary: h3, padding: f2 }), S2 = F2 ? k ? T2 : P2 : k ? W : L;
|
|
v2[U2] > w2[U2] && (S2 = be(S2));
|
|
var ue = be(S2), _2 = [];
|
|
if (a2 && _2.push(M2[H] <= 0), s2 && _2.push(M2[S2] <= 0, M2[ue] <= 0), _2.every(function(z) {
|
|
return z;
|
|
})) {
|
|
D2 = A2, j = false;
|
|
break;
|
|
}
|
|
$.set(A2, _2);
|
|
}
|
|
if (j)
|
|
for (var pe = g ? 3 : 1, xe = function(z) {
|
|
var q = d2.find(function(de) {
|
|
var ae = $.get(de);
|
|
if (ae)
|
|
return ae.slice(0, z).every(function(K) {
|
|
return K;
|
|
});
|
|
});
|
|
if (q)
|
|
return D2 = q, "break";
|
|
}, ie = pe; ie > 0; ie--) {
|
|
var le = xe(ie);
|
|
if (le === "break")
|
|
break;
|
|
}
|
|
t.placement !== D2 && (t.modifiersData[r]._skip = true, t.placement = D2, t.reset = true);
|
|
}
|
|
}
|
|
var gt2 = { name: "flip", enabled: true, phase: "main", fn: en, requiresIfExists: ["offset"], data: { _skip: false } };
|
|
function bt(e, t, n) {
|
|
return n === void 0 && (n = { x: 0, y: 0 }), { top: e.top - t.height - n.y, right: e.right - t.width + n.x, bottom: e.bottom - t.height + n.y, left: e.left - t.width - n.x };
|
|
}
|
|
function wt(e) {
|
|
return [L, T2, W, P2].some(function(t) {
|
|
return e[t] >= 0;
|
|
});
|
|
}
|
|
function tn(e) {
|
|
var t = e.state, n = e.name, r = t.rects.reference, o2 = t.rects.popper, a2 = t.modifiersData.preventOverflow, c2 = oe(t, { elementContext: "reference" }), s2 = oe(t, { altBoundary: true }), i = bt(c2, r), f2 = bt(s2, o2, a2), u2 = wt(i), m2 = wt(f2);
|
|
t.modifiersData[n] = { referenceClippingOffsets: i, popperEscapeOffsets: f2, isReferenceHidden: u2, hasPopperEscaped: m2 }, t.attributes.popper = Object.assign({}, t.attributes.popper, { "data-popper-reference-hidden": u2, "data-popper-escaped": m2 });
|
|
}
|
|
var xt = { name: "hide", enabled: true, phase: "main", requiresIfExists: ["preventOverflow"], fn: tn };
|
|
function nn(e, t, n) {
|
|
var r = C(e), o2 = [P2, L].indexOf(r) >= 0 ? -1 : 1, a2 = typeof n == "function" ? n(Object.assign({}, t, { placement: e })) : n, c2 = a2[0], s2 = a2[1];
|
|
return c2 = c2 || 0, s2 = (s2 || 0) * o2, [P2, T2].indexOf(r) >= 0 ? { x: s2, y: c2 } : { x: c2, y: s2 };
|
|
}
|
|
function rn(e) {
|
|
var t = e.state, n = e.options, r = e.name, o2 = n.offset, a2 = o2 === void 0 ? [0, 0] : o2, c2 = Ee.reduce(function(u2, m2) {
|
|
return u2[m2] = nn(m2, t.rects, a2), u2;
|
|
}, {}), s2 = c2[t.placement], i = s2.x, f2 = s2.y;
|
|
t.modifiersData.popperOffsets != null && (t.modifiersData.popperOffsets.x += i, t.modifiersData.popperOffsets.y += f2), t.modifiersData[r] = c2;
|
|
}
|
|
var Ot = { name: "offset", enabled: true, phase: "main", requires: ["popperOffsets"], fn: rn };
|
|
function on(e) {
|
|
var t = e.state, n = e.name;
|
|
t.modifiersData[n] = yt({ reference: t.rects.reference, element: t.rects.popper, placement: t.placement });
|
|
}
|
|
var Ve = { name: "popperOffsets", enabled: true, phase: "read", fn: on, data: {} };
|
|
function an(e) {
|
|
return e === "x" ? "y" : "x";
|
|
}
|
|
function sn(e) {
|
|
var t = e.state, n = e.options, r = e.name, o2 = n.mainAxis, a2 = o2 === void 0 ? true : o2, c2 = n.altAxis, s2 = c2 === void 0 ? false : c2, i = n.boundary, f2 = n.rootBoundary, u2 = n.altBoundary, m2 = n.padding, h3 = n.tether, l2 = h3 === void 0 ? true : h3, g = n.tetherOffset, p2 = g === void 0 ? 0 : g, y = oe(t, { boundary: i, rootBoundary: f2, padding: m2, altBoundary: u2 }), b2 = C(t.placement), x2 = re(t.placement), O2 = !x2, d2 = Me(b2), v2 = an(d2), w2 = t.modifiersData.popperOffsets, $ = t.rects.reference, j = t.rects.popper, D2 = typeof p2 == "function" ? p2(Object.assign({}, t.rects, { placement: t.placement })) : p2, E2 = typeof D2 == "number" ? { mainAxis: D2, altAxis: D2 } : Object.assign({ mainAxis: 0, altAxis: 0 }, D2), A2 = t.modifiersData.offset ? t.modifiersData.offset[t.placement] : null, H = { x: 0, y: 0 };
|
|
if (w2) {
|
|
if (a2) {
|
|
var k, F2 = d2 === "y" ? L : P2, U2 = d2 === "y" ? W : T2, M2 = d2 === "y" ? "height" : "width", S2 = w2[d2], ue = S2 + y[F2], _2 = S2 - y[U2], pe = l2 ? -j[M2] / 2 : 0, xe = x2 === Y2 ? $[M2] : j[M2], ie = x2 === Y2 ? -j[M2] : -$[M2], le = t.elements.arrow, z = l2 && le ? Pe(le) : { width: 0, height: 0 }, q = t.modifiersData["arrow#persistent"] ? t.modifiersData["arrow#persistent"].padding : ct(), de = q[F2], ae = q[U2], K = fe(0, $[M2], z[M2]), Et = O2 ? $[M2] / 2 - pe - K - de - E2.mainAxis : xe - K - de - E2.mainAxis, At = O2 ? -$[M2] / 2 + pe + K + ae + E2.mainAxis : ie + K + ae + E2.mainAxis, Oe = t.elements.arrow && se(t.elements.arrow), kt = Oe ? d2 === "y" ? Oe.clientTop || 0 : Oe.clientLeft || 0 : 0, Ce = (k = A2 == null ? void 0 : A2[d2]) != null ? k : 0, Lt = S2 + Et - Ce - kt, Pt = S2 + At - Ce, qe = fe(l2 ? ve(ue, Lt) : ue, S2, l2 ? J(_2, Pt) : _2);
|
|
w2[d2] = qe, H[d2] = qe - S2;
|
|
}
|
|
if (s2) {
|
|
var Ie, Mt = d2 === "x" ? L : P2, Wt = d2 === "x" ? W : T2, X2 = w2[v2], he = v2 === "y" ? "height" : "width", Ne = X2 + y[Mt], Fe = X2 - y[Wt], $e = [L, P2].indexOf(b2) !== -1, Ue = (Ie = A2 == null ? void 0 : A2[v2]) != null ? Ie : 0, _e = $e ? Ne : X2 - $[he] - j[he] - Ue + E2.altAxis, ze = $e ? X2 + $[he] + j[he] - Ue - E2.altAxis : Fe, Xe = l2 && $e ? St(_e, X2, ze) : fe(l2 ? _e : Ne, X2, l2 ? ze : Fe);
|
|
w2[v2] = Xe, H[v2] = Xe - X2;
|
|
}
|
|
t.modifiersData[r] = H;
|
|
}
|
|
}
|
|
var $t = { name: "preventOverflow", enabled: true, phase: "main", fn: sn, requiresIfExists: ["offset"] };
|
|
function fn(e) {
|
|
return { scrollLeft: e.scrollLeft, scrollTop: e.scrollTop };
|
|
}
|
|
function cn(e) {
|
|
return e === B(e) || !R(e) ? Be(e) : fn(e);
|
|
}
|
|
function un(e) {
|
|
var t = e.getBoundingClientRect(), n = te(t.width) / e.offsetWidth || 1, r = te(t.height) / e.offsetHeight || 1;
|
|
return n !== 1 || r !== 1;
|
|
}
|
|
function pn(e, t, n) {
|
|
n === void 0 && (n = false);
|
|
var r = R(t), o2 = R(t) && un(t), a2 = N2(t), c2 = ne(e, o2, n), s2 = { scrollLeft: 0, scrollTop: 0 }, i = { x: 0, y: 0 };
|
|
return (r || !r && !n) && ((V(t) !== "body" || He(a2)) && (s2 = cn(t)), R(t) ? (i = ne(t, true), i.x += t.clientLeft, i.y += t.clientTop) : a2 && (i.x = Re(a2))), { x: c2.left + s2.scrollLeft - i.x, y: c2.top + s2.scrollTop - i.y, width: c2.width, height: c2.height };
|
|
}
|
|
function ln(e) {
|
|
var t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Set(), r = [];
|
|
e.forEach(function(a2) {
|
|
t.set(a2.name, a2);
|
|
});
|
|
function o2(a2) {
|
|
n.add(a2.name);
|
|
var c2 = [].concat(a2.requires || [], a2.requiresIfExists || []);
|
|
c2.forEach(function(s2) {
|
|
if (!n.has(s2)) {
|
|
var i = t.get(s2);
|
|
i && o2(i);
|
|
}
|
|
}), r.push(a2);
|
|
}
|
|
return e.forEach(function(a2) {
|
|
n.has(a2.name) || o2(a2);
|
|
}), r;
|
|
}
|
|
function dn(e) {
|
|
var t = ln(e);
|
|
return it.reduce(function(n, r) {
|
|
return n.concat(t.filter(function(o2) {
|
|
return o2.phase === r;
|
|
}));
|
|
}, []);
|
|
}
|
|
function hn(e) {
|
|
var t;
|
|
return function() {
|
|
return t || (t = new Promise(function(n) {
|
|
Promise.resolve().then(function() {
|
|
t = void 0, n(e());
|
|
});
|
|
})), t;
|
|
};
|
|
}
|
|
function mn(e) {
|
|
var t = e.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(t).map(function(n) {
|
|
return t[n];
|
|
});
|
|
}
|
|
var jt = { placement: "bottom", modifiers: [], strategy: "absolute" };
|
|
function Dt() {
|
|
for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
|
|
t[n] = arguments[n];
|
|
return !t.some(function(r) {
|
|
return !(r && typeof r.getBoundingClientRect == "function");
|
|
});
|
|
}
|
|
function we(e) {
|
|
e === void 0 && (e = {});
|
|
var t = e, n = t.defaultModifiers, r = n === void 0 ? [] : n, o2 = t.defaultOptions, a2 = o2 === void 0 ? jt : o2;
|
|
return function(c2, s2, i) {
|
|
i === void 0 && (i = a2);
|
|
var f2 = { placement: "bottom", orderedModifiers: [], options: Object.assign({}, jt, a2), modifiersData: {}, elements: { reference: c2, popper: s2 }, attributes: {}, styles: {} }, u2 = [], m2 = false, h3 = { state: f2, setOptions: function(p2) {
|
|
var y = typeof p2 == "function" ? p2(f2.options) : p2;
|
|
g(), f2.options = Object.assign({}, a2, f2.options, y), f2.scrollParents = { reference: G(c2) ? ce(c2) : c2.contextElement ? ce(c2.contextElement) : [], popper: ce(s2) };
|
|
var b2 = dn(mn([].concat(r, f2.options.modifiers)));
|
|
return f2.orderedModifiers = b2.filter(function(x2) {
|
|
return x2.enabled;
|
|
}), l2(), h3.update();
|
|
}, forceUpdate: function() {
|
|
if (!m2) {
|
|
var p2 = f2.elements, y = p2.reference, b2 = p2.popper;
|
|
if (Dt(y, b2)) {
|
|
f2.rects = { reference: pn(y, se(b2), f2.options.strategy === "fixed"), popper: Pe(b2) }, f2.reset = false, f2.placement = f2.options.placement, f2.orderedModifiers.forEach(function(j) {
|
|
return f2.modifiersData[j.name] = Object.assign({}, j.data);
|
|
});
|
|
for (var x2 = 0; x2 < f2.orderedModifiers.length; x2++) {
|
|
if (f2.reset === true) {
|
|
f2.reset = false, x2 = -1;
|
|
continue;
|
|
}
|
|
var O2 = f2.orderedModifiers[x2], d2 = O2.fn, v2 = O2.options, w2 = v2 === void 0 ? {} : v2, $ = O2.name;
|
|
typeof d2 == "function" && (f2 = d2({ state: f2, options: w2, name: $, instance: h3 }) || f2);
|
|
}
|
|
}
|
|
}
|
|
}, update: hn(function() {
|
|
return new Promise(function(p2) {
|
|
h3.forceUpdate(), p2(f2);
|
|
});
|
|
}), destroy: function() {
|
|
g(), m2 = true;
|
|
} };
|
|
if (!Dt(c2, s2))
|
|
return h3;
|
|
h3.setOptions(i).then(function(p2) {
|
|
!m2 && i.onFirstUpdate && i.onFirstUpdate(p2);
|
|
});
|
|
function l2() {
|
|
f2.orderedModifiers.forEach(function(p2) {
|
|
var y = p2.name, b2 = p2.options, x2 = b2 === void 0 ? {} : b2, O2 = p2.effect;
|
|
if (typeof O2 == "function") {
|
|
var d2 = O2({ state: f2, name: y, instance: h3, options: x2 }), v2 = function() {
|
|
};
|
|
u2.push(d2 || v2);
|
|
}
|
|
});
|
|
}
|
|
function g() {
|
|
u2.forEach(function(p2) {
|
|
return p2();
|
|
}), u2 = [];
|
|
}
|
|
return h3;
|
|
};
|
|
}
|
|
var vn = we();
|
|
var yn = [Te, Ve, We, ke];
|
|
var gn = we({ defaultModifiers: yn });
|
|
var bn = [Te, Ve, We, ke, Ot, gt2, $t, lt2, xt];
|
|
var wn = we({ defaultModifiers: bn });
|
|
|
|
// 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 = wn(referenceElement, popperElement, unref(options));
|
|
});
|
|
onBeforeUnmount(() => {
|
|
destroy();
|
|
});
|
|
return {
|
|
state: computed(() => {
|
|
var _a;
|
|
return { ...((_a = unref(instanceRef)) == null ? void 0 : _a.state) || {} };
|
|
}),
|
|
styles: computed(() => unref(states).styles),
|
|
attributes: computed(() => unref(states).attributes),
|
|
update: () => {
|
|
var _a;
|
|
return (_a = unref(instanceRef)) == null ? void 0 : _a.update();
|
|
},
|
|
forceUpdate: () => {
|
|
var _a;
|
|
return (_a = unref(instanceRef)) == null ? void 0 : _a.forceUpdate();
|
|
},
|
|
instanceRef: computed(() => unref(instanceRef))
|
|
};
|
|
};
|
|
function deriveState(state) {
|
|
const elements = Object.keys(state.elements);
|
|
return {
|
|
styles: fromPairs_default(elements.map((element) => [element, state.styles[element] || {}])),
|
|
attributes: fromPairs_default(elements.map((element) => [element, state.attributes[element]]))
|
|
};
|
|
}
|
|
|
|
// 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/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-throttle-render/index.mjs
|
|
var useThrottleRender = (loading, throttle2 = 0) => {
|
|
if (throttle2 === 0)
|
|
return loading;
|
|
const throttled = ref(isObject(throttle2) && Boolean(throttle2.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/hooks/use-timeout/index.mjs
|
|
function useTimeout() {
|
|
let timeoutHandle;
|
|
const registerTimeout = (fn2, delay2) => {
|
|
cancelTimeout();
|
|
timeoutHandle = globalThis.setTimeout(fn2, delay2);
|
|
};
|
|
const cancelTimeout = () => {
|
|
if (timeoutHandle === void 0)
|
|
return;
|
|
globalThis.clearTimeout(timeoutHandle);
|
|
timeoutHandle = void 0;
|
|
};
|
|
tryOnScopeDispose(() => cancelTimeout());
|
|
return {
|
|
registerTimeout,
|
|
cancelTimeout
|
|
};
|
|
}
|
|
|
|
// 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-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();
|
|
return computedEager(() => unref(deterministicId) || `${namespace.value}-id-${idInjection.prefix}-${idInjection.current++}`);
|
|
};
|
|
|
|
// node_modules/element-plus/es/hooks/use-escape-keydown/index.mjs
|
|
var registeredEscapeHandlers = [];
|
|
var cachedHandler = (event) => {
|
|
if (getEventCode(event) === 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/hooks/use-popper-container/index.mjs
|
|
var usePopperContainerId = () => {
|
|
const namespace = useGetDerivedNamespace();
|
|
const idInjection = useIdInjection();
|
|
const id = computed(() => {
|
|
return `${namespace.value}-popper-container-${idInjection.prefix}`;
|
|
});
|
|
return {
|
|
id,
|
|
selector: computed(() => `#${id.value}`)
|
|
};
|
|
};
|
|
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/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/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 useDelayedTogglePropsDefaults = {
|
|
showAfter: 0,
|
|
hideAfter: 200,
|
|
autoClose: 0
|
|
};
|
|
var useDelayedToggle = ({ showAfter, hideAfter, autoClose, open, close: close2 }) => {
|
|
const { registerTimeout } = useTimeout();
|
|
const { registerTimeout: registerTimeoutForAutoClose, cancelTimeout: cancelTimeoutForAutoClose } = useTimeout();
|
|
const onOpen = (event, delay2 = unref(showAfter)) => {
|
|
registerTimeout(() => {
|
|
open(event);
|
|
const _autoClose = unref(autoClose);
|
|
if (isNumber2(_autoClose) && _autoClose > 0)
|
|
registerTimeoutForAutoClose(() => {
|
|
close2(event);
|
|
}, _autoClose);
|
|
}, delay2);
|
|
};
|
|
const onClose = (event, delay2 = unref(hideAfter)) => {
|
|
cancelTimeoutForAutoClose();
|
|
registerTimeout(() => {
|
|
close2(event);
|
|
}, delay2);
|
|
};
|
|
return {
|
|
onOpen,
|
|
onClose
|
|
};
|
|
};
|
|
|
|
// 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/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/@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 min2 = Math.min;
|
|
var max2 = Math.max;
|
|
var round2 = Math.round;
|
|
var floor2 = Math.floor;
|
|
var createCoords = (v2) => ({
|
|
x: v2,
|
|
y: v2
|
|
});
|
|
var oppositeSideMap = {
|
|
left: "right",
|
|
right: "left",
|
|
bottom: "top",
|
|
top: "bottom"
|
|
};
|
|
function clamp3(start, value, end) {
|
|
return max2(start, min2(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) {
|
|
const firstChar = placement[0];
|
|
return firstChar === "t" || firstChar === "b" ? "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.includes("start") ? placement.replace("start", "end") : placement.replace("end", "start");
|
|
}
|
|
var lrPlacement = ["left", "right"];
|
|
var rlPlacement = ["right", "left"];
|
|
var tbPlacement = ["top", "bottom"];
|
|
var btPlacement = ["bottom", "top"];
|
|
function getSideList(side, isStart, rtl) {
|
|
switch (side) {
|
|
case "top":
|
|
case "bottom":
|
|
if (rtl)
|
|
return isStart ? rlPlacement : lrPlacement;
|
|
return isStart ? lrPlacement : rlPlacement;
|
|
case "left":
|
|
case "right":
|
|
return isStart ? tbPlacement : btPlacement;
|
|
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) {
|
|
const side = getSide(placement);
|
|
return oppositeSideMap[side] + placement.slice(side.length);
|
|
}
|
|
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;
|
|
}
|
|
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 MAX_RESET_COUNT = 50;
|
|
var computePosition = async (reference, floating, config) => {
|
|
const {
|
|
placement = "bottom",
|
|
strategy = "absolute",
|
|
middleware = [],
|
|
platform: platform2
|
|
} = config;
|
|
const platformWithDetectOverflow = platform2.detectOverflow ? platform2 : {
|
|
...platform2,
|
|
detectOverflow
|
|
};
|
|
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 resetCount = 0;
|
|
const middlewareData = {};
|
|
for (let i = 0; i < middleware.length; i++) {
|
|
const currentMiddleware = middleware[i];
|
|
if (!currentMiddleware) {
|
|
continue;
|
|
}
|
|
const {
|
|
name,
|
|
fn: fn2
|
|
} = currentMiddleware;
|
|
const {
|
|
x: nextX,
|
|
y: nextY,
|
|
data,
|
|
reset
|
|
} = await fn2({
|
|
x: x2,
|
|
y,
|
|
initialPlacement: placement,
|
|
placement: statefulPlacement,
|
|
strategy,
|
|
middlewareData,
|
|
rects,
|
|
platform: platformWithDetectOverflow,
|
|
elements: {
|
|
reference,
|
|
floating
|
|
}
|
|
});
|
|
x2 = nextX != null ? nextX : x2;
|
|
y = nextY != null ? nextY : y;
|
|
middlewareData[name] = {
|
|
...middlewareData[name],
|
|
...data
|
|
};
|
|
if (reset && resetCount < MAX_RESET_COUNT) {
|
|
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
|
|
};
|
|
};
|
|
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 = min2(paddingObject[minProp], largestPossiblePadding);
|
|
const maxPadding = min2(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 platform2.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) {
|
|
const ignoreCrossAxisOverflow = checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false;
|
|
if (!ignoreCrossAxisOverflow || overflowsData.every((d2) => getSideAxis(d2.placement) === initialSideAxis ? d2.overflows[0] > 0 : true)) {
|
|
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 {};
|
|
}
|
|
};
|
|
};
|
|
var originSides = /* @__PURE__ */ new Set(["left", "top"]);
|
|
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 = originSides.has(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,
|
|
platform: platform2
|
|
} = 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 platform2.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/dom/floating-ui.utils.dom.esm.js
|
|
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 isHTMLElement2(value) {
|
|
if (!hasWindow()) {
|
|
return false;
|
|
}
|
|
return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
|
|
}
|
|
function isShadowRoot2(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) && display !== "inline" && display !== "contents";
|
|
}
|
|
function isTableElement(element) {
|
|
return /^(table|td|th)$/.test(getNodeName(element));
|
|
}
|
|
function isTopLayer(element) {
|
|
try {
|
|
if (element.matches(":popover-open")) {
|
|
return true;
|
|
}
|
|
} catch (_e) {
|
|
}
|
|
try {
|
|
return element.matches(":modal");
|
|
} catch (_e) {
|
|
return false;
|
|
}
|
|
}
|
|
var willChangeRe = /transform|translate|scale|rotate|perspective|filter/;
|
|
var containRe = /paint|layout|strict|content/;
|
|
var isNotNone = (value) => !!value && value !== "none";
|
|
var isWebKitValue;
|
|
function isContainingBlock(elementOrCss) {
|
|
const css = isElement3(elementOrCss) ? getComputedStyle2(elementOrCss) : elementOrCss;
|
|
return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || "") || containRe.test(css.contain || "");
|
|
}
|
|
function getContainingBlock(element) {
|
|
let currentNode = getParentNode(element);
|
|
while (isHTMLElement2(currentNode) && !isLastTraversableNode(currentNode)) {
|
|
if (isContainingBlock(currentNode)) {
|
|
return currentNode;
|
|
} else if (isTopLayer(currentNode)) {
|
|
return null;
|
|
}
|
|
currentNode = getParentNode(currentNode);
|
|
}
|
|
return null;
|
|
}
|
|
function isWebKit() {
|
|
if (isWebKitValue == null) {
|
|
isWebKitValue = typeof CSS !== "undefined" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none");
|
|
}
|
|
return isWebKitValue;
|
|
}
|
|
function isLastTraversableNode(node) {
|
|
return /^(html|body|#document)$/.test(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 || isShadowRoot2(node) && node.host || getDocumentElement(node);
|
|
return isShadowRoot2(result2) ? result2.host : result2;
|
|
}
|
|
function getNearestOverflowAncestor(node) {
|
|
const parentNode = getParentNode(node);
|
|
if (isLastTraversableNode(parentNode)) {
|
|
return node.ownerDocument ? node.ownerDocument.body : node.body;
|
|
}
|
|
if (isHTMLElement2(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) : []);
|
|
} else {
|
|
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 = isHTMLElement2(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 (!isHTMLElement2(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) {
|
|
const htmlRect = documentElement.getBoundingClientRect();
|
|
const x2 = htmlRect.left + scroll.scrollLeft - 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 = isHTMLElement2(offsetParent);
|
|
if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
|
|
if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
|
|
scroll = getNodeScroll(offsetParent);
|
|
}
|
|
if (isOffsetParentAnElement) {
|
|
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) : 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 = max2(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
|
|
const height = max2(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
|
|
let x2 = -scroll.scrollLeft + getWindowScrollBarX(element);
|
|
const y = -scroll.scrollTop;
|
|
if (getComputedStyle2(body).direction === "rtl") {
|
|
x2 += max2(html.clientWidth, body.clientWidth) - width;
|
|
}
|
|
return {
|
|
width,
|
|
height,
|
|
x: x2,
|
|
y
|
|
};
|
|
}
|
|
var SCROLLBAR_MAX = 25;
|
|
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;
|
|
}
|
|
}
|
|
const windowScrollbarX = getWindowScrollBarX(html);
|
|
if (windowScrollbarX <= 0) {
|
|
const doc = html.ownerDocument;
|
|
const body = doc.body;
|
|
const bodyStyles = getComputedStyle(body);
|
|
const bodyMarginInline = doc.compatMode === "CSS1Compat" ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
|
|
const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
|
|
if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) {
|
|
width -= clippingStableScrollbarWidth;
|
|
}
|
|
} else if (windowScrollbarX <= SCROLLBAR_MAX) {
|
|
width += windowScrollbarX;
|
|
}
|
|
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 = isHTMLElement2(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 && (currentContainingBlockComputedStyle.position === "absolute" || currentContainingBlockComputedStyle.position === "fixed") || 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 firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy);
|
|
let top = firstRect.top;
|
|
let right = firstRect.right;
|
|
let bottom = firstRect.bottom;
|
|
let left = firstRect.left;
|
|
for (let i = 1; i < clippingAncestors.length; i++) {
|
|
const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i], strategy);
|
|
top = max2(rect.top, top);
|
|
right = min2(rect.right, right);
|
|
bottom = min2(rect.bottom, bottom);
|
|
left = max2(rect.left, left);
|
|
}
|
|
return {
|
|
width: right - left,
|
|
height: bottom - top,
|
|
x: left,
|
|
y: top
|
|
};
|
|
}
|
|
function getDimensions(element) {
|
|
const {
|
|
width,
|
|
height
|
|
} = getCssDimensions(element);
|
|
return {
|
|
width,
|
|
height
|
|
};
|
|
}
|
|
function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
|
|
const isOffsetParentAnElement = isHTMLElement2(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);
|
|
function setLeftRTLScrollbarOffset() {
|
|
offsets.x = getWindowScrollBarX(documentElement);
|
|
}
|
|
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) {
|
|
setLeftRTLScrollbarOffset();
|
|
}
|
|
}
|
|
if (isFixed && !isOffsetParentAnElement && documentElement) {
|
|
setLeftRTLScrollbarOffset();
|
|
}
|
|
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 (!isHTMLElement2(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 (!isHTMLElement2(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 isRTL(element) {
|
|
return getComputedStyle2(element).direction === "rtl";
|
|
}
|
|
var platform = {
|
|
convertOffsetParentRelativeRectToViewportRelativeRect,
|
|
getDocumentElement,
|
|
getClippingRect,
|
|
getOffsetParent,
|
|
getElementRects,
|
|
getClientRects,
|
|
getDimensions,
|
|
getScale,
|
|
isElement: isElement3,
|
|
isRTL
|
|
};
|
|
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 = floor2(top);
|
|
const insetRight = floor2(root2.clientWidth - (left + width));
|
|
const insetBottom = floor2(root2.clientHeight - (top + height));
|
|
const insetLeft = floor2(left);
|
|
const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
|
|
const options = {
|
|
rootMargin,
|
|
threshold: max2(0, min2(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) : [], ...floating ? 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 && floating) {
|
|
resizeObserver.unobserve(floating);
|
|
cancelAnimationFrame(reobserveFrame);
|
|
reobserveFrame = requestAnimationFrame(() => {
|
|
var _resizeObserver;
|
|
(_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
|
|
});
|
|
}
|
|
update2();
|
|
});
|
|
if (referenceEl && !animationFrame) {
|
|
resizeObserver.observe(referenceEl);
|
|
}
|
|
if (floating) {
|
|
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 = /* @__PURE__ */ 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 states = {
|
|
x: ref(),
|
|
y: ref(),
|
|
placement,
|
|
strategy,
|
|
middlewareData: ref({})
|
|
};
|
|
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/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;
|
|
selectionInfo = {
|
|
selectionStart,
|
|
selectionEnd,
|
|
value,
|
|
beforeTxt: value.slice(0, Math.max(0, selectionStart)),
|
|
afterTxt: value.slice(Math.max(0, selectionEnd))
|
|
};
|
|
}
|
|
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/vue/vnode.mjs
|
|
var SCOPE4 = "utils/vue/vnode";
|
|
var PatchFlags = function(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;
|
|
}({});
|
|
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(SCOPE4, "[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 flattedChildren = (children) => {
|
|
const vNodes = isArray(children) ? children : [children];
|
|
const result2 = [];
|
|
vNodes.forEach((child) => {
|
|
var _a;
|
|
if (isArray(child))
|
|
result2.push(...flattedChildren(child));
|
|
else if (isVNode(child) && ((_a = child.component) == null ? void 0 : _a.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) => {
|
|
return flattedChildren(vm.subTree).filter((n) => {
|
|
var _a;
|
|
return isVNode(n) && ((_a = n.type) == null ? void 0 : _a.name) === childComponentName && !!n.component;
|
|
}).map((n) => n.component.uid).map((uid2) => children[uid2]).filter((p2) => !!p2);
|
|
};
|
|
var useOrderedChildren = (vm, childComponentName) => {
|
|
const children = shallowRef({});
|
|
const orderedChildren = shallowRef([]);
|
|
const nodesMap = /* @__PURE__ */ new WeakMap();
|
|
const addChild = (child) => {
|
|
children.value[child.uid] = child;
|
|
triggerRef(children);
|
|
onMounted(() => {
|
|
const childNode = child.getVnode().el;
|
|
const parentNode = childNode.parentNode;
|
|
if (!nodesMap.has(parentNode)) {
|
|
nodesMap.set(parentNode, []);
|
|
const originalFn = parentNode.insertBefore.bind(parentNode);
|
|
parentNode.insertBefore = (node, anchor) => {
|
|
if (nodesMap.get(parentNode).some((el) => node === el || anchor === el))
|
|
triggerRef(children);
|
|
return originalFn(node, anchor);
|
|
};
|
|
}
|
|
nodesMap.get(parentNode).push(childNode);
|
|
});
|
|
};
|
|
const removeChild = (child) => {
|
|
delete children.value[child.uid];
|
|
triggerRef(children);
|
|
const childNode = child.getVnode().el;
|
|
const parentNode = childNode.parentNode;
|
|
const childNodes = nodesMap.get(parentNode);
|
|
const index = childNodes.indexOf(childNode);
|
|
childNodes.splice(index, 1);
|
|
};
|
|
const sortChildren = () => {
|
|
orderedChildren.value = getOrderedChildren(vm, childComponentName, children.value);
|
|
};
|
|
const IsolatedRenderer = (props2) => {
|
|
return props2.render();
|
|
};
|
|
return {
|
|
children: orderedChildren,
|
|
addChild,
|
|
removeChild,
|
|
ChildrenSorter: defineComponent({ setup(_2, { slots }) {
|
|
return () => {
|
|
sortChildren();
|
|
return slots.default ? h(IsolatedRenderer, { render: slots.default }) : null;
|
|
};
|
|
} })
|
|
};
|
|
};
|
|
|
|
// 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-focus-controller/index.mjs
|
|
function useFocusController(target2, { disabled, beforeFocus, afterFocus, beforeBlur, afterBlur } = {}) {
|
|
const { emit } = getCurrentInstance();
|
|
const wrapperRef = shallowRef();
|
|
const isFocused = ref(false);
|
|
const handleFocus = (event) => {
|
|
const cancelFocus = isFunction(beforeFocus) ? beforeFocus(event) : false;
|
|
if (unref(disabled) || isFocused.value || cancelFocus)
|
|
return;
|
|
isFocused.value = true;
|
|
emit("focus", event);
|
|
afterFocus == null ? void 0 : afterFocus();
|
|
};
|
|
const handleBlur = (event) => {
|
|
var _a;
|
|
const cancelBlur = isFunction(beforeBlur) ? beforeBlur(event) : false;
|
|
if (unref(disabled) || event.relatedTarget && ((_a = wrapperRef.value) == null ? void 0 : _a.contains(event.relatedTarget)) || cancelBlur)
|
|
return;
|
|
isFocused.value = false;
|
|
emit("blur", event);
|
|
afterBlur == null ? void 0 : afterBlur();
|
|
};
|
|
const handleClick = (event) => {
|
|
var _a, _b;
|
|
if (unref(disabled) || isFocusable(event.target) || ((_a = wrapperRef.value) == null ? void 0 : _a.contains(document.activeElement)) && wrapperRef.value !== document.activeElement)
|
|
return;
|
|
(_b = target2.value) == null ? void 0 : _b.focus();
|
|
};
|
|
watch([wrapperRef, () => unref(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);
|
|
return {
|
|
isFocused,
|
|
wrapperRef,
|
|
handleFocus,
|
|
handleBlur
|
|
};
|
|
}
|
|
|
|
// 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) => {
|
|
emit == null ? void 0 : emit("compositionupdate", event);
|
|
isComposing.value = true;
|
|
};
|
|
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-empty-values/index.mjs
|
|
var emptyValuesContextKey = Symbol("emptyValuesContextKey");
|
|
var SCOPE5 = "use-empty-values";
|
|
var DEFAULT_EMPTY_VALUES = [
|
|
"",
|
|
void 0,
|
|
null
|
|
];
|
|
var DEFAULT_VALUE_ON_CLEAR = void 0;
|
|
var useEmptyValuesProps = buildProps({
|
|
emptyValues: Array,
|
|
valueOnClear: {
|
|
type: definePropType([
|
|
String,
|
|
Number,
|
|
Boolean,
|
|
Function
|
|
]),
|
|
default: void 0,
|
|
validator: (val) => {
|
|
val = isFunction(val) ? val() : val;
|
|
if (isArray(val))
|
|
return val.every((item) => !item);
|
|
return !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) => {
|
|
let result2 = true;
|
|
if (isArray(value))
|
|
result2 = emptyValues.value.some((emptyValue) => {
|
|
return isEqual_default(value, emptyValue);
|
|
});
|
|
else
|
|
result2 = emptyValues.value.includes(value);
|
|
return result2;
|
|
};
|
|
if (!isEmptyValue2(valueOnClear.value))
|
|
debugWarn(SCOPE5, "value-on-clear should be a value of empty-values");
|
|
return {
|
|
emptyValues,
|
|
valueOnClear,
|
|
isEmptyValue: isEmptyValue2
|
|
};
|
|
};
|
|
|
|
// 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/vue/install.mjs
|
|
var withPropsDefaultsSetter = (target2) => {
|
|
const _p = target2.props;
|
|
const props2 = isArray(_p) ? fromPairs_default(_p.map((key) => [key, {}])) : _p;
|
|
target2.setPropsDefaults = (defaults2) => {
|
|
if (!props2)
|
|
return;
|
|
for (const [key, value] of Object.entries(defaults2)) {
|
|
const prop = props2[key];
|
|
if (!hasOwn(props2, key))
|
|
continue;
|
|
if (isPlainObject_default(prop)) {
|
|
props2[key] = {
|
|
...prop,
|
|
default: value
|
|
};
|
|
continue;
|
|
}
|
|
props2[key] = {
|
|
type: prop,
|
|
default: value
|
|
};
|
|
}
|
|
target2.props = props2;
|
|
};
|
|
};
|
|
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;
|
|
withPropsDefaultsSetter(main);
|
|
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;
|
|
withPropsDefaultsSetter(component2);
|
|
return component2;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/teleport/src/teleport.vue_vue_type_script_setup_true_lang.mjs
|
|
var teleport_vue_vue_type_script_setup_true_lang_default = 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"]));
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/teleport/src/teleport2.mjs
|
|
var teleport_default = teleport_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/teleport/index.mjs
|
|
var ElTeleport = withInstall(teleport_default);
|
|
|
|
// node_modules/element-plus/es/components/affix/src/affix.vue_vue_type_script_setup_true_lang.mjs
|
|
var COMPONENT_NAME = "ElAffix";
|
|
var affix_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: COMPONENT_NAME,
|
|
__name: "affix",
|
|
props: affixProps,
|
|
emits: affixEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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, left: rootLeft, update: updateRoot } = useElementBounding(root2, { windowScroll: false });
|
|
const targetRect = useElementBounding(target2);
|
|
const fixed = ref(false);
|
|
const scrollTop = ref(0);
|
|
const transform2 = ref(0);
|
|
const teleportDisabled = computed(() => {
|
|
return !props2.teleported || !fixed.value;
|
|
});
|
|
const rootStyle = computed(() => {
|
|
return {
|
|
display: "flow-root",
|
|
height: fixed.value ? `${rootHeight.value}px` : "",
|
|
width: fixed.value ? `${rootWidth.value}px` : ""
|
|
};
|
|
});
|
|
const affixStyle = computed(() => {
|
|
if (!fixed.value)
|
|
return {};
|
|
const offset3 = addUnit(props2.offset);
|
|
return {
|
|
height: `${rootHeight.value}px`,
|
|
width: `${rootWidth.value}px`,
|
|
top: props2.position === "top" ? offset3 : "",
|
|
bottom: props2.position === "bottom" ? offset3 : "",
|
|
left: props2.teleported ? `${rootLeft.value}px` : "",
|
|
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: target3, offset: offset3 } = props2;
|
|
const rootHeightOffset = offset3 + rootHeight.value;
|
|
if (position === "top")
|
|
if (target3) {
|
|
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 (target3) {
|
|
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 updateRootRect = async () => {
|
|
if (!fixed.value) {
|
|
updateRoot();
|
|
return;
|
|
}
|
|
fixed.value = false;
|
|
await nextTick();
|
|
updateRoot();
|
|
fixed.value = true;
|
|
};
|
|
const handleScroll2 = async () => {
|
|
updateRoot();
|
|
await nextTick();
|
|
emit("scroll", {
|
|
scrollTop: scrollTop.value,
|
|
fixed: fixed.value
|
|
});
|
|
};
|
|
watch(fixed, (val) => emit(CHANGE_EVENT, val));
|
|
onMounted(() => {
|
|
var _a;
|
|
if (props2.target) {
|
|
target2.value = (_a = document.querySelector(props2.target)) != null ? _a : 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();
|
|
});
|
|
onActivated(() => {
|
|
nextTick(updateRootRect);
|
|
});
|
|
onDeactivated(() => {
|
|
fixed.value = false;
|
|
});
|
|
useEventListener(scrollContainer, "scroll", handleScroll2);
|
|
watchEffect(update2);
|
|
__expose({
|
|
update: update2,
|
|
updateRoot: updateRootRect
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "root",
|
|
ref: root2,
|
|
class: normalizeClass(unref(ns).b()),
|
|
style: normalizeStyle(rootStyle.value)
|
|
}, [createVNode(unref(ElTeleport), {
|
|
disabled: teleportDisabled.value,
|
|
to: __props.appendTo
|
|
}, {
|
|
default: withCtx(() => [createBaseVNode("div", {
|
|
class: normalizeClass({ [unref(ns).m("fixed")]: fixed.value }),
|
|
style: normalizeStyle(affixStyle.value)
|
|
}, [renderSlot(_ctx.$slots, "default")], 6)]),
|
|
_: 3
|
|
}, 8, ["disabled", "to"])], 6);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/affix/src/affix2.mjs
|
|
var affix_default = affix_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/affix/index.mjs
|
|
var ElAffix = withInstall(affix_default);
|
|
|
|
// 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/alert.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/icon/src/icon.mjs
|
|
var iconProps = buildProps({
|
|
size: { type: definePropType([Number, String]) },
|
|
color: { type: String }
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/icon/src/icon.vue_vue_type_script_setup_true_lang.mjs
|
|
var icon_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElIcon",
|
|
inheritAttrs: false,
|
|
__name: "icon",
|
|
props: iconProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("icon");
|
|
const style = computed(() => {
|
|
const { size: size3, color } = props2;
|
|
const fontSize = addUnit(size3);
|
|
if (!fontSize && !color)
|
|
return {};
|
|
return {
|
|
fontSize,
|
|
"--color": color
|
|
};
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("i", mergeProps({
|
|
class: unref(ns).b(),
|
|
style: style.value
|
|
}, _ctx.$attrs), [renderSlot(_ctx.$slots, "default")], 16);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/icon/src/icon2.mjs
|
|
var icon_default = icon_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/icon/index.mjs
|
|
var ElIcon = withInstall(icon_default);
|
|
|
|
// node_modules/element-plus/es/components/alert/src/alert.vue_vue_type_script_setup_true_lang.mjs
|
|
var alert_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElAlert",
|
|
__name: "alert",
|
|
props: alertProps,
|
|
emits: alertEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const { Close } = TypeComponents;
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const slots = useSlots();
|
|
const ns = useNamespace("alert");
|
|
const visible = ref(true);
|
|
const iconComponent = computed(() => TypeComponentsMap[props2.type]);
|
|
const hasDesc = computed(() => {
|
|
var _a;
|
|
if (props2.description)
|
|
return true;
|
|
const slotContent = (_a = slots.default) == null ? void 0 : _a.call(slots);
|
|
if (!slotContent)
|
|
return false;
|
|
return flattedChildren(slotContent).some((child) => !isComment(child));
|
|
});
|
|
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(__props.type),
|
|
unref(ns).is("center", __props.center),
|
|
unref(ns).is(__props.effect)
|
|
]),
|
|
role: "alert"
|
|
}, [__props.showIcon && (_ctx.$slots.icon || iconComponent.value) ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("icon"), unref(ns).is("big", hasDesc.value)])
|
|
}, {
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "icon", {}, () => [(openBlock(), createBlock(resolveDynamicComponent(iconComponent.value)))])]),
|
|
_: 3
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true), createBaseVNode("div", { class: normalizeClass(unref(ns).e("content")) }, [
|
|
__props.title || _ctx.$slots.title ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("title"), { "with-description": hasDesc.value }])
|
|
}, [renderSlot(_ctx.$slots, "title", {}, () => [createTextVNode(toDisplayString(__props.title), 1)])], 2)) : createCommentVNode("v-if", true),
|
|
hasDesc.value ? (openBlock(), createElementBlock("p", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("description"))
|
|
}, [renderSlot(_ctx.$slots, "default", {}, () => [createTextVNode(toDisplayString(__props.description), 1)])], 2)) : createCommentVNode("v-if", true),
|
|
__props.closable ? (openBlock(), createElementBlock(Fragment, { key: 2 }, [__props.closeText ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("close-btn"), unref(ns).is("customed")]),
|
|
onClick: close2
|
|
}, toDisplayString(__props.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"]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/alert/src/alert2.mjs
|
|
var alert_default = alert_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/alert/index.mjs
|
|
var ElAlert = withInstall(alert_default);
|
|
|
|
// 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/constants.mjs
|
|
var POPPER_INJECTION_KEY = Symbol("popper");
|
|
var POPPER_CONTENT_INJECTION_KEY = Symbol("popperContent");
|
|
|
|
// node_modules/element-plus/es/components/popper/src/arrow.vue_vue_type_script_setup_true_lang.mjs
|
|
var arrow_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElPopperArrow",
|
|
inheritAttrs: false,
|
|
__name: "arrow",
|
|
setup(__props, { expose: __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);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/popper/src/arrow2.mjs
|
|
var arrow_default = arrow_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// 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/components/slot/src/only-child.mjs
|
|
var NAME = "ElOnlyChild";
|
|
var OnlyChild = defineComponent({
|
|
name: NAME,
|
|
setup(_2, { slots, attrs }) {
|
|
var _a, _b;
|
|
const forwardRefDirective = useForwardRefDirective((_b = (_a = inject(FORWARD_REF_INJECTION_KEY)) == null ? void 0 : _a.setForwardRef) != null ? _b : NOOP);
|
|
return () => {
|
|
var _a2;
|
|
const defaultSlot = (_a2 = slots.default) == null ? void 0 : _a2.call(slots, attrs);
|
|
if (!defaultSlot)
|
|
return null;
|
|
const [firstLegitNode, length] = findFirstLegitChild(defaultSlot);
|
|
if (!firstLegitNode) {
|
|
debugWarn(NAME, "no valid child node found");
|
|
return null;
|
|
}
|
|
if (length > 1)
|
|
debugWarn(NAME, "requires exact only one valid child.");
|
|
return withDirectives(cloneVNode(firstLegitNode, attrs), [[forwardRefDirective]]);
|
|
};
|
|
}
|
|
});
|
|
function findFirstLegitChild(node) {
|
|
if (!node)
|
|
return [null, 0];
|
|
const children = node;
|
|
const len = children.filter((c2) => c2.type !== Comment).length;
|
|
for (const child of children) {
|
|
if (isObject(child))
|
|
switch (child.type) {
|
|
case Comment:
|
|
continue;
|
|
case Text:
|
|
case "svg":
|
|
return [wrapTextContent(child), len];
|
|
case Fragment:
|
|
return findFirstLegitChild(child.children);
|
|
default:
|
|
return [child, len];
|
|
}
|
|
return [wrapTextContent(child), len];
|
|
}
|
|
return [null, 0];
|
|
}
|
|
function wrapTextContent(s2) {
|
|
const ns = useNamespace("only-child");
|
|
return createVNode("span", { "class": ns.e("content") }, [s2]);
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/popper/src/trigger.vue_vue_type_script_setup_true_lang.mjs
|
|
var trigger_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElPopperTrigger",
|
|
inheritAttrs: false,
|
|
__name: "trigger",
|
|
props: popperTriggerProps,
|
|
setup(__props, { expose: __expose }) {
|
|
const props2 = __props;
|
|
const { role, triggerRef: triggerRef2 } = inject(POPPER_INJECTION_KEY, void 0);
|
|
useForwardRef(triggerRef2);
|
|
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;
|
|
});
|
|
const ariaHaspopup = computed(() => {
|
|
if (role && role.value !== "tooltip")
|
|
return role.value;
|
|
});
|
|
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)
|
|
triggerRef2.value = unrefElement(virtualEl);
|
|
}, { immediate: true });
|
|
watch(triggerRef2, (el, prevEl) => {
|
|
virtualTriggerAriaStopWatch == null ? void 0 : virtualTriggerAriaStopWatch();
|
|
virtualTriggerAriaStopWatch = void 0;
|
|
if (isElement2(prevEl))
|
|
TRIGGER_ELE_EVENTS.forEach((eventName) => {
|
|
const handler = props2[eventName];
|
|
if (handler)
|
|
prevEl.removeEventListener(eventName.slice(2).toLowerCase(), handler, ["onFocus", "onBlur"].includes(eventName));
|
|
});
|
|
if (isElement2(el)) {
|
|
TRIGGER_ELE_EVENTS.forEach((eventName) => {
|
|
const handler = props2[eventName];
|
|
if (handler)
|
|
el.addEventListener(eventName.slice(2).toLowerCase(), handler, ["onFocus", "onBlur"].includes(eventName));
|
|
});
|
|
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 (triggerRef2.value && isElement2(triggerRef2.value)) {
|
|
const el = triggerRef2.value;
|
|
TRIGGER_ELE_EVENTS.forEach((eventName) => {
|
|
const handler = props2[eventName];
|
|
if (handler)
|
|
el.removeEventListener(eventName.slice(2).toLowerCase(), handler, ["onFocus", "onBlur"].includes(eventName));
|
|
});
|
|
triggerRef2.value = void 0;
|
|
}
|
|
});
|
|
__expose({ triggerRef: triggerRef2 });
|
|
return (_ctx, _cache) => {
|
|
return !__props.virtualTriggering ? (openBlock(), createBlock(unref(OnlyChild), mergeProps({ key: 0 }, _ctx.$attrs, {
|
|
"aria-controls": ariaControls.value,
|
|
"aria-describedby": ariaDescribedby.value,
|
|
"aria-expanded": ariaExpanded.value,
|
|
"aria-haspopup": ariaHaspopup.value
|
|
}), {
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
|
|
_: 3
|
|
}, 16, [
|
|
"aria-controls",
|
|
"aria-describedby",
|
|
"aria-expanded",
|
|
"aria-haspopup"
|
|
])) : createCommentVNode("v-if", true);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/popper/src/trigger2.mjs
|
|
var trigger_default = trigger_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/popper/src/arrow.mjs
|
|
var popperArrowProps = buildProps({ arrowOffset: {
|
|
type: Number,
|
|
default: 5
|
|
} });
|
|
var popperArrowPropsDefaults = { arrowOffset: 5 };
|
|
var usePopperArrowProps = popperArrowProps;
|
|
|
|
// 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: Boolean,
|
|
trapping: Boolean,
|
|
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"]),
|
|
loop: Boolean
|
|
});
|
|
var popperCoreConfigPropsDefaults = {
|
|
boundariesPadding: 0,
|
|
gpuAcceleration: true,
|
|
offset: 12,
|
|
placement: "bottom",
|
|
popperOptions: () => ({}),
|
|
strategy: "absolute"
|
|
};
|
|
var popperContentPropsDefaults = {
|
|
...popperCoreConfigPropsDefaults,
|
|
...popperArrowPropsDefaults,
|
|
effect: "dark",
|
|
enterable: true,
|
|
stopPopperMouseEvent: true,
|
|
visible: false,
|
|
pure: false,
|
|
focusOnShow: false,
|
|
trapping: false,
|
|
virtualTriggering: false,
|
|
loop: false,
|
|
style: void 0,
|
|
popperStyle: void 0
|
|
};
|
|
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/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: definePropType([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/constants.mjs
|
|
var formContextKey = Symbol("formContextKey");
|
|
var formItemContextKey = Symbol("formItemContextKey");
|
|
|
|
// 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(() => {
|
|
var _a, _b, _c;
|
|
return (_c = (_b = (_a = disabled.value) != null ? _a : unref(fallback)) != null ? _b : form == null ? void 0 : form.disabled) != null ? _c : false;
|
|
});
|
|
};
|
|
var useSize = useFormSize;
|
|
var useDisabled = useFormDisabled;
|
|
|
|
// node_modules/element-plus/es/components/form/src/hooks/use-form-item.mjs
|
|
var useFormItem = () => {
|
|
return {
|
|
form: inject(formContextKey, void 0),
|
|
formItem: inject(formItemContextKey, void 0)
|
|
};
|
|
};
|
|
var useFormItemInputId = (props2, { formItemContext, disableIdGeneration, disableIdManagement }) => {
|
|
if (!disableIdGeneration)
|
|
disableIdGeneration = ref(false);
|
|
if (!disableIdManagement)
|
|
disableIdManagement = ref(false);
|
|
const instance = getCurrentInstance();
|
|
const inLabel = () => {
|
|
let parent2 = instance == null ? void 0 : instance.parent;
|
|
while (parent2) {
|
|
if (parent2.type.name === "ElFormItem")
|
|
return false;
|
|
if (parent2.type.name === "ElLabelWrap")
|
|
return true;
|
|
parent2 = parent2.parent;
|
|
}
|
|
return false;
|
|
};
|
|
const inputId = ref();
|
|
let idUnwatch = void 0;
|
|
const isLabeledByFormItem = computed(() => {
|
|
var _a;
|
|
return !!(!(props2.label || props2.ariaLabel) && formItemContext && formItemContext.inputIds && ((_a = formItemContext.inputIds) == null ? void 0 : _a.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) && !inLabel()) {
|
|
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/components/form/src/form-item.mjs
|
|
var formItemValidateStates = [
|
|
"",
|
|
"error",
|
|
"validating",
|
|
"success"
|
|
];
|
|
var formItemProps = buildProps({
|
|
label: String,
|
|
labelWidth: { type: [String, Number] },
|
|
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: Boolean,
|
|
default: void 0
|
|
},
|
|
showMessage: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
size: {
|
|
type: String,
|
|
values: componentSizes
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/utils/arrays.mjs
|
|
var unique = (arr) => [...new Set(arr)];
|
|
var extractFirst = (arr) => {
|
|
return isArray(arr) ? arr[0] : arr;
|
|
};
|
|
var castArray2 = (arr) => {
|
|
if (!arr && arr !== 0)
|
|
return [];
|
|
return isArray(arr) ? arr : [arr];
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/form/src/utils.mjs
|
|
var SCOPE6 = "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(SCOPE6, `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).map((prop) => isArray(prop) ? prop.join(".") : prop);
|
|
return normalized.length > 0 ? fields.filter((field) => field.propString && normalized.includes(field.propString)) : fields;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/form/src/form.vue_vue_type_script_setup_true_lang.mjs
|
|
var COMPONENT_NAME2 = "ElForm";
|
|
var form_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: COMPONENT_NAME2,
|
|
__name: "form",
|
|
props: formProps,
|
|
emits: formEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const formRef = ref();
|
|
const fields = reactive([]);
|
|
const initialValues = /* @__PURE__ */ new Map();
|
|
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 filterFields(fields, [prop])[0];
|
|
};
|
|
const addField = (field) => {
|
|
if (!fields.includes(field))
|
|
fields.push(field);
|
|
if (field.propString)
|
|
if (initialValues.has(field.propString))
|
|
field.setInitialValue(initialValues.get(field.propString));
|
|
else
|
|
initialValues.set(field.propString, cloneDeep_default(field.fieldValue));
|
|
};
|
|
const removeField = (field, oldPropString) => {
|
|
if (oldPropString) {
|
|
initialValues.delete(oldPropString);
|
|
return;
|
|
}
|
|
const idx = fields.indexOf(field);
|
|
if (idx > -1) {
|
|
fields.splice(idx, 1);
|
|
if (field.propString)
|
|
initialValues.set(field.propString, cloneDeep_default(field.getInitialValue()));
|
|
}
|
|
};
|
|
const setInitialValues = (initModel) => {
|
|
if (!props2.model) {
|
|
debugWarn(COMPONENT_NAME2, "model is required for setInitialValues to work.");
|
|
return;
|
|
}
|
|
if (!initModel) {
|
|
debugWarn(COMPONENT_NAME2, "initModel is required for setInitialValues to work.");
|
|
return;
|
|
}
|
|
for (const key of initialValues.keys())
|
|
initialValues.set(key, cloneDeep_default(getProp(initModel, key).value));
|
|
fields.forEach((field) => {
|
|
if (field.prop)
|
|
field.setInitialValue(getProp(initModel, field.prop).value);
|
|
});
|
|
};
|
|
const resetFields = (properties = []) => {
|
|
if (!props2.model) {
|
|
debugWarn(COMPONENT_NAME2, "model is required for resetFields to work.");
|
|
return;
|
|
}
|
|
filterFields(fields, properties).forEach((field) => field.resetField());
|
|
const activePropStrings = new Set(fields.map((f2) => f2.propString).filter(Boolean));
|
|
const propsToCheck = properties.length > 0 ? castArray_default(properties).map((p2) => isArray(p2) ? p2.join(".") : p2) : [...initialValues.keys()];
|
|
for (const propString of propsToCheck)
|
|
if (!activePropStrings.has(propString) && initialValues.has(propString))
|
|
getProp(props2.model, propString).value = cloneDeep_default(initialValues.get(propString));
|
|
};
|
|
const clearValidate = (props3 = []) => {
|
|
filterFields(fields, props3).forEach((field) => field.clearValidate());
|
|
};
|
|
const isValidatable = computed(() => {
|
|
const hasModel = !!props2.model;
|
|
if (!hasModel)
|
|
debugWarn(COMPONENT_NAME2, "model is required for validate to work.");
|
|
return hasModel;
|
|
});
|
|
const obtainValidateFields = (props3) => {
|
|
if (fields.length === 0)
|
|
return [];
|
|
const filteredFields = filterFields(fields, props3);
|
|
if (!filteredFields.length) {
|
|
debugWarn(COMPONENT_NAME2, "please pass correct props!");
|
|
return [];
|
|
}
|
|
return filteredFields;
|
|
};
|
|
const validate = async (callback) => validateField(void 0, callback);
|
|
const doValidateField = async (props3 = []) => {
|
|
if (!isValidatable.value)
|
|
return false;
|
|
const fields2 = obtainValidateFields(props3);
|
|
if (fields2.length === 0)
|
|
return true;
|
|
let validationErrors = {};
|
|
for (const field of fields2)
|
|
try {
|
|
await field.validate("");
|
|
if (field.validateState === "error" && !field.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) => {
|
|
var _a;
|
|
let result2 = false;
|
|
const shouldThrow = !isFunction(callback);
|
|
try {
|
|
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)
|
|
(_a = formRef.value.querySelector(`.${ns.b()}-item.is-error`)) == null ? void 0 : _a.scrollIntoView(props2.scrollIntoViewOptions);
|
|
}
|
|
!result2 && await (callback == null ? void 0 : callback(false, invalidFields));
|
|
return shouldThrow && Promise.reject(invalidFields);
|
|
}
|
|
};
|
|
const scrollToField = (prop) => {
|
|
var _a;
|
|
const field = getField(prop);
|
|
if (field)
|
|
(_a = field.$el) == null ? void 0 : _a.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,
|
|
setInitialValues,
|
|
...useFormLabelWidth()
|
|
}));
|
|
__expose({
|
|
validate,
|
|
validateField,
|
|
resetFields,
|
|
clearValidate,
|
|
scrollToField,
|
|
getField,
|
|
fields,
|
|
setInitialValues
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("form", {
|
|
ref_key: "formRef",
|
|
ref: formRef,
|
|
class: normalizeClass(formClasses.value)
|
|
}, [renderSlot(_ctx.$slots, "default")], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/form/src/form2.mjs
|
|
var form_default = form_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/form/src/form-label-wrap.mjs
|
|
var COMPONENT_NAME3 = "ElLabelWrap";
|
|
var form_label_wrap_default = defineComponent({
|
|
name: COMPONENT_NAME3,
|
|
props: {
|
|
isAutoWidth: Boolean,
|
|
updateAll: Boolean
|
|
},
|
|
setup(props2, { slots }) {
|
|
const formContext = inject(formContextKey, void 0);
|
|
const formItemContext = inject(formItemContextKey);
|
|
if (!formItemContext)
|
|
throwError(COMPONENT_NAME3, "usage: <el-form-item><label-wrap /></el-form-item>");
|
|
const ns = useNamespace("form");
|
|
const el = ref();
|
|
const computedWidth = ref(0);
|
|
const getLabelWidth = () => {
|
|
var _a;
|
|
if ((_a = el.value) == null ? void 0 : _a.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 _a, _b;
|
|
return (_b = (_a = el.value) == null ? void 0 : _a.firstElementChild) != null ? _b : null;
|
|
}), updateLabelWidthFn);
|
|
return () => {
|
|
var _a, _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 marginPosition = (formItemContext.labelPosition || formContext.labelPosition) === "left" ? "marginRight" : "marginLeft";
|
|
if (marginWidth)
|
|
style[marginPosition] = `${marginWidth}px`;
|
|
}
|
|
return createVNode("div", {
|
|
"ref": el,
|
|
"class": [ns.be("item", "label-wrap")],
|
|
"style": style
|
|
}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
|
|
} else
|
|
return createVNode(Fragment, { "ref": el }, [(_b = slots.default) == null ? void 0 : _b.call(slots)]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// 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" ? /* @__PURE__ */ 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(oe2) {
|
|
var fieldValue;
|
|
if (rule.fullFields) {
|
|
fieldValue = getValue2(source, rule.fullFields);
|
|
} else {
|
|
fieldValue = source[oe2.field || rule.fullField];
|
|
}
|
|
if (isErrorObj(oe2)) {
|
|
oe2.field = oe2.field || rule.fullField;
|
|
oe2.fieldValue = fieldValue;
|
|
return oe2;
|
|
}
|
|
return {
|
|
message: typeof oe2 === "function" ? oe2() : oe2,
|
|
fieldValue,
|
|
field: oe2.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-item.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_1 = ["role", "aria-labelledby"];
|
|
var form_item_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElFormItem",
|
|
__name: "form-item",
|
|
props: formItemProps,
|
|
setup(__props, { expose: __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(() => {
|
|
var _a;
|
|
if (labelPosition.value === "top")
|
|
return {};
|
|
return { width: addUnit((_a = props2.labelWidth) != null ? _a : formContext == null ? void 0 : formContext.labelWidth) };
|
|
});
|
|
const contentStyle = computed(() => {
|
|
var _a;
|
|
if (labelPosition.value === "top" || (formContext == null ? void 0 : formContext.inline))
|
|
return {};
|
|
if (!props2.label && !props2.labelWidth && isNested)
|
|
return {};
|
|
const labelWidth = addUnit((_a = props2.labelWidth) != null ? _a : 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 isArray(props2.prop) ? props2.prop.join(".") : props2.prop;
|
|
});
|
|
const hasLabel = computed(() => {
|
|
return !!(props2.label || slots.label);
|
|
});
|
|
const labelFor = computed(() => {
|
|
var _a;
|
|
return (_a = props2.for) != null ? _a : 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]) => "required" in rule);
|
|
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) => {
|
|
return normalizedRules.value.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 _a;
|
|
return validateStateDebounced.value === "error" && props2.showMessage && ((_a = formContext == null ? void 0 : formContext.showMessage) != null ? _a : true);
|
|
});
|
|
const currentLabel = computed(() => `${props2.label || ""}${(formContext == null ? void 0 : formContext.labelSuffix) || ""}`);
|
|
const setValidationState = (state) => {
|
|
validateState.value = state;
|
|
};
|
|
const onValidationFailed = (error) => {
|
|
var _a, _b;
|
|
const { errors, fields } = error;
|
|
if (!errors || !fields)
|
|
console.error(error);
|
|
setValidationState("error");
|
|
validateMessage.value = errors ? (_b = (_a = errors == null ? void 0 : errors[0]) == null ? void 0 : _a.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;
|
|
return new Schema({ [modelName]: rules2 }).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 = cloneDeep_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);
|
|
};
|
|
const setInitialValue = (value) => {
|
|
initialValue = cloneDeep_default(value);
|
|
};
|
|
const getInitialValue = () => initialValue;
|
|
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,
|
|
validateMessage,
|
|
validateState,
|
|
labelId,
|
|
inputIds,
|
|
isGroup,
|
|
hasLabel,
|
|
fieldValue,
|
|
addInputId,
|
|
removeInputId,
|
|
resetField,
|
|
clearValidate,
|
|
validate,
|
|
propString,
|
|
setInitialValue,
|
|
getInitialValue
|
|
});
|
|
provide(formItemContextKey, context);
|
|
watch(propString, (newPropString, oldPropString) => {
|
|
if (!formContext || !oldPropString)
|
|
return;
|
|
formContext.removeField(context, oldPropString);
|
|
if (newPropString) {
|
|
setInitialValue(fieldValue.value);
|
|
formContext.addField(context);
|
|
}
|
|
});
|
|
onMounted(() => {
|
|
if (props2.prop) {
|
|
setInitialValue(fieldValue.value);
|
|
formContext == null ? void 0 : formContext.addField(context);
|
|
}
|
|
});
|
|
onBeforeUnmount(() => {
|
|
formContext == null ? void 0 : formContext.removeField(context);
|
|
});
|
|
__expose({
|
|
size: _size,
|
|
validateMessage,
|
|
validateState,
|
|
validate,
|
|
clearValidate,
|
|
resetField,
|
|
setInitialValue
|
|
});
|
|
return (_ctx, _cache) => {
|
|
var _a;
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "formItemRef",
|
|
ref: formItemRef,
|
|
class: normalizeClass(formItemClasses.value),
|
|
role: isGroup.value ? "group" : void 0,
|
|
"aria-labelledby": isGroup.value ? unref(labelId) : void 0
|
|
}, [createVNode(unref(form_label_wrap_default), {
|
|
"is-auto-width": labelStyle.value.width === "auto",
|
|
"update-all": ((_a = unref(formContext)) == null ? void 0 : _a.labelWidth) === "auto"
|
|
}, {
|
|
default: withCtx(() => [!!(__props.label || _ctx.$slots.label) ? (openBlock(), createBlock(resolveDynamicComponent(labelFor.value ? "label" : "div"), {
|
|
key: 0,
|
|
id: unref(labelId),
|
|
for: labelFor.value,
|
|
class: normalizeClass(unref(ns).e("label")),
|
|
style: normalizeStyle(labelStyle.value)
|
|
}, {
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "label", { label: currentLabel.value }, () => [createTextVNode(toDisplayString(currentLabel.value), 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(contentStyle.value)
|
|
}, [renderSlot(_ctx.$slots, "default"), createVNode(TransitionGroup, { name: `${unref(ns).namespace.value}-zoom-in-top` }, {
|
|
default: withCtx(() => [shouldShowError.value ? renderSlot(_ctx.$slots, "error", {
|
|
key: 0,
|
|
error: validateMessage.value
|
|
}, () => [createBaseVNode("div", { class: normalizeClass(validateClasses.value) }, toDisplayString(validateMessage.value), 3)]) : createCommentVNode("v-if", true)]),
|
|
_: 3
|
|
}, 8, ["name"])], 6)], 10, _hoisted_1);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/form/src/form-item2.mjs
|
|
var form_item_default = form_item_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/form/index.mjs
|
|
var ElForm = withInstall(form_default, { FormItem: form_item_default });
|
|
var ElFormItem = withNoopInstall(form_item_default);
|
|
|
|
// 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 (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);
|
|
return [getVisibleElement(focusable, container), getVisibleElement(focusable.reverse(), container)];
|
|
};
|
|
var isSelectable = (element) => {
|
|
return element instanceof HTMLInputElement && "select" in element;
|
|
};
|
|
var tryFocus = (element, shouldSelect) => {
|
|
if (element) {
|
|
const prevFocusedElement = document.activeElement;
|
|
focusElement(element, { preventScroll: true });
|
|
lastAutomatedFocusTimestamp.value = window.performance.now();
|
|
if (element !== prevFocusedElement && isSelectable(element) && shouldSelect)
|
|
element.select();
|
|
}
|
|
};
|
|
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 _a, _b;
|
|
stack = removeFromStack(stack, layer);
|
|
(_b = (_a = stack[0]) == null ? void 0 : _a.resume) == null ? void 0 : _b.call(_a);
|
|
};
|
|
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.vue_vue_type_script_lang.mjs
|
|
var focus_trap_vue_vue_type_script_lang_default = 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 { altKey, ctrlKey, metaKey, currentTarget, shiftKey } = e;
|
|
const { loop } = props2;
|
|
const isTabbing = getEventCode(e) === EVENT_CODE.tab && !altKey && !ctrlKey && !metaKey;
|
|
const currentFocusingEl = document.activeElement;
|
|
if (isTabbing && currentFocusingEl) {
|
|
const container = currentTarget;
|
|
const [first, last2] = getEdges(container);
|
|
if (!(first && last2)) {
|
|
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) {
|
|
if (!(relatedTarget && trapContainer.contains(relatedTarget)))
|
|
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;
|
|
if (!(target2 && trapContainer.contains(target2)))
|
|
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;
|
|
if (!trapContainer.contains(prevFocusedElement)) {
|
|
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);
|
|
lastFocusBeforeTrapped = null;
|
|
lastFocusAfterTrapped = null;
|
|
}
|
|
}
|
|
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;
|
|
}
|
|
lastFocusBeforeTrapped = null;
|
|
lastFocusAfterTrapped = null;
|
|
});
|
|
return { onKeydown };
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/_virtual/_plugin-vue_export-helper.mjs
|
|
var _plugin_vue_export_helper_default = (sfc, props2) => {
|
|
const target2 = sfc.__vccOpts || sfc;
|
|
for (const [key, val] of props2)
|
|
target2[key] = val;
|
|
return target2;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/focus-trap/src/focus-trap.mjs
|
|
function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return renderSlot(_ctx.$slots, "default", { handleKeydown: _ctx.onKeydown });
|
|
}
|
|
var focus_trap_default = _plugin_vue_export_helper_default(focus_trap_vue_vue_type_script_lang_default, [["render", _sfc_render]]);
|
|
|
|
// node_modules/element-plus/es/components/focus-trap/index.mjs
|
|
var focus_trap_default$1 = focus_trap_default;
|
|
|
|
// 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: 0,
|
|
bottom: 0,
|
|
left: 0,
|
|
right: 0
|
|
} }
|
|
},
|
|
{
|
|
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: triggerRef2, 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 _a;
|
|
const arrowEl = unref(arrowRef);
|
|
const offset3 = (_a = unref(arrowOffset)) != null ? _a : 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(triggerRef2));
|
|
const { attributes: attributes2, state, styles, update: update2, forceUpdate, instanceRef } = usePopper(computedReference, contentRef, options);
|
|
watch(instanceRef, (instance) => popperInstanceRef.value = instance, { flush: "sync" });
|
|
onMounted(() => {
|
|
watch(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = unref(computedReference)) == null ? void 0 : _a.getBoundingClientRect) == null ? void 0 : _b.call(_a);
|
|
}, () => {
|
|
update2();
|
|
});
|
|
});
|
|
let stopResizeObserver;
|
|
watch(() => props2.visible, (visible) => {
|
|
stopResizeObserver == null ? void 0 : stopResizeObserver();
|
|
stopResizeObserver = void 0;
|
|
if (visible)
|
|
stopResizeObserver = useResizeObserver(contentRef, update2).stop;
|
|
});
|
|
onBeforeUnmount(() => {
|
|
popperInstanceRef.value = void 0;
|
|
stopResizeObserver == null ? void 0 : stopResizeObserver();
|
|
stopResizeObserver = void 0;
|
|
});
|
|
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/composables/use-focus-trap.mjs
|
|
var usePopperContentFocusTrap = (props2, emit) => {
|
|
const trapped = ref(false);
|
|
const focusStartRef = ref();
|
|
const onFocusAfterTrapped = () => {
|
|
emit("focus");
|
|
};
|
|
const onFocusAfterReleased = (event) => {
|
|
var _a;
|
|
if (((_a = event.detail) == null ? void 0 : _a.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");
|
|
};
|
|
onBeforeUnmount(() => {
|
|
focusStartRef.value = void 0;
|
|
});
|
|
return {
|
|
focusStartRef,
|
|
trapped,
|
|
onFocusAfterReleased,
|
|
onFocusAfterTrapped,
|
|
onFocusInTrap,
|
|
onFocusoutPrevented,
|
|
onReleaseRequested
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/popper/src/content.vue_vue_type_script_setup_true_lang.mjs
|
|
var content_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElPopperContent",
|
|
__name: "content",
|
|
props: popperContentProps,
|
|
emits: popperContentEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const emit = __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;
|
|
contentRef.value = 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: _cache[0] || (_cache[0] = (e) => _ctx.$emit("mouseenter", e)),
|
|
onMouseleave: _cache[1] || (_cache[1] = (e) => _ctx.$emit("mouseleave", e))
|
|
}), [createVNode(unref(focus_trap_default$1), {
|
|
loop: __props.loop,
|
|
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, [
|
|
"loop",
|
|
"trapped",
|
|
"focus-trap-el",
|
|
"focus-start-el",
|
|
"onFocusAfterTrapped",
|
|
"onFocusAfterReleased",
|
|
"onFocusin",
|
|
"onFocusoutPrevented",
|
|
"onReleaseRequested"
|
|
])], 16);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/popper/src/content2.mjs
|
|
var content_default = content_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/popper/src/popper.vue_vue_type_script_setup_true_lang.mjs
|
|
var popper_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElPopper",
|
|
inheritAttrs: false,
|
|
__name: "popper",
|
|
props: popperProps,
|
|
setup(__props, { expose: __expose }) {
|
|
const props2 = __props;
|
|
const popperProvides = {
|
|
triggerRef: ref(),
|
|
popperInstanceRef: ref(),
|
|
contentRef: ref(),
|
|
referenceRef: ref(),
|
|
role: computed(() => props2.role)
|
|
};
|
|
__expose(popperProvides);
|
|
provide(POPPER_INJECTION_KEY, popperProvides);
|
|
return (_ctx, _cache) => {
|
|
return renderSlot(_ctx.$slots, "default");
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/popper/src/popper2.mjs
|
|
var popper_default = popper_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/popper/index.mjs
|
|
var ElPopper = withInstall(popper_default);
|
|
|
|
// node_modules/element-plus/es/components/tooltip/src/content.mjs
|
|
var useTooltipContentPropsDefaults = {
|
|
...useDelayedTogglePropsDefaults,
|
|
...popperContentPropsDefaults,
|
|
content: "",
|
|
visible: null,
|
|
teleported: true
|
|
};
|
|
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/trigger.mjs
|
|
var useTooltipTriggerPropsDefaults = {
|
|
trigger: "hover",
|
|
triggerKeys: () => [
|
|
EVENT_CODE.enter,
|
|
EVENT_CODE.numpadEnter,
|
|
EVENT_CODE.space
|
|
]
|
|
};
|
|
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
|
|
]
|
|
},
|
|
focusOnTarget: Boolean
|
|
});
|
|
|
|
// 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/components/tooltip/src/constants.mjs
|
|
var TOOLTIP_INJECTION_KEY = Symbol("elTooltip");
|
|
|
|
// 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/components/tooltip/src/trigger.vue_vue_type_script_setup_true_lang.mjs
|
|
var trigger_vue_vue_type_script_setup_true_lang_default2 = defineComponent({
|
|
name: "ElTooltipTrigger",
|
|
__name: "trigger",
|
|
props: useTooltipTriggerProps,
|
|
setup(__props, { expose: __expose }) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("tooltip");
|
|
const { controlled, id, open, onOpen, onClose, onToggle } = inject(TOOLTIP_INJECTION_KEY, void 0);
|
|
const triggerRef2 = ref(null);
|
|
const stopWhenControlledOrDisabled = () => {
|
|
if (unref(controlled) || props2.disabled)
|
|
return true;
|
|
};
|
|
const trigger = toRef(props2, "trigger");
|
|
const onMouseenter = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "hover", (e) => {
|
|
onOpen(e);
|
|
if (props2.focusOnTarget && e.target)
|
|
nextTick(() => {
|
|
focusElement(e.target, { preventScroll: true });
|
|
});
|
|
}));
|
|
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 = getEventCode(e);
|
|
if (props2.triggerKeys.includes(code)) {
|
|
e.preventDefault();
|
|
onToggle(e);
|
|
}
|
|
});
|
|
__expose({ triggerRef: triggerRef2 });
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(trigger_default), {
|
|
id: unref(id),
|
|
"virtual-ref": __props.virtualRef,
|
|
open: unref(open),
|
|
"virtual-triggering": __props.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"
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tooltip/src/trigger2.mjs
|
|
var trigger_default2 = trigger_vue_vue_type_script_setup_true_lang_default2;
|
|
|
|
// node_modules/element-plus/es/components/tooltip/src/content.vue_vue_type_script_setup_true_lang.mjs
|
|
var content_vue_vue_type_script_setup_true_lang_default2 = defineComponent({
|
|
name: "ElTooltipContent",
|
|
inheritAttrs: false,
|
|
__name: "content",
|
|
props: useTooltipContentProps,
|
|
setup(__props, { expose: __expose }) {
|
|
const props2 = __props;
|
|
const { selector } = usePopperContainerId();
|
|
const ns = useNamespace("tooltip");
|
|
const contentRef = ref();
|
|
const popperContentRef = computedEager(() => {
|
|
var _a;
|
|
return (_a = contentRef.value) == null ? void 0 : _a.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(() => {
|
|
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 _a;
|
|
return (_a = props2.style) != null ? _a : {};
|
|
});
|
|
const ariaHidden = ref(true);
|
|
const onTransitionLeave = () => {
|
|
onHide();
|
|
isFocusInsideContent() && focusElement(document.body, { preventScroll: true });
|
|
ariaHidden.value = true;
|
|
};
|
|
const stopWhenControlled = () => {
|
|
if (unref(controlled))
|
|
return true;
|
|
};
|
|
const onContentEnter = composeEventHandlers(stopWhenControlled, () => {
|
|
if (props2.enterable && isTriggerType(unref(trigger), "hover"))
|
|
onOpen();
|
|
});
|
|
const onContentLeave = composeEventHandlers(stopWhenControlled, () => {
|
|
if (isTriggerType(unref(trigger), "hover"))
|
|
onClose();
|
|
});
|
|
const onBeforeEnter = () => {
|
|
var _a, _b;
|
|
(_b = (_a = contentRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
|
|
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 _a;
|
|
const popperContent = (_a = contentRef.value) == null ? void 0 : _a.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;
|
|
if (castArray2(unref(trigger)).every((item) => {
|
|
return item !== "hover" && item !== "focus";
|
|
}))
|
|
onClose();
|
|
}, { detectIframe: true });
|
|
}
|
|
}, { flush: "post" });
|
|
__expose({
|
|
contentRef,
|
|
isFocusInsideContent
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElTeleport), {
|
|
disabled: !__props.teleported,
|
|
to: appendTo.value
|
|
}, {
|
|
default: withCtx(() => [shouldRender.value || !ariaHidden.value ? (openBlock(), createBlock(Transition, {
|
|
key: 0,
|
|
name: transitionClass.value,
|
|
appear: !persistentRef.value,
|
|
onAfterLeave: onTransitionLeave,
|
|
onBeforeEnter,
|
|
onAfterEnter: onAfterShow,
|
|
onBeforeLeave,
|
|
persisted: ""
|
|
}, {
|
|
default: withCtx(() => [withDirectives(createVNode(unref(content_default), mergeProps({
|
|
id: unref(id),
|
|
ref_key: "contentRef",
|
|
ref: contentRef
|
|
}, _ctx.$attrs, {
|
|
"aria-label": __props.ariaLabel,
|
|
"aria-hidden": ariaHidden.value,
|
|
"boundaries-padding": __props.boundariesPadding,
|
|
"fallback-placements": __props.fallbackPlacements,
|
|
"gpu-acceleration": __props.gpuAcceleration,
|
|
offset: __props.offset,
|
|
placement: __props.placement,
|
|
"popper-options": __props.popperOptions,
|
|
"arrow-offset": __props.arrowOffset,
|
|
strategy: __props.strategy,
|
|
effect: __props.effect,
|
|
enterable: __props.enterable,
|
|
pure: __props.pure,
|
|
"popper-class": __props.popperClass,
|
|
"popper-style": [__props.popperStyle, contentStyle.value],
|
|
"reference-el": __props.referenceEl,
|
|
"trigger-target-el": __props.triggerTargetEl,
|
|
visible: shouldShow.value,
|
|
"z-index": __props.zIndex,
|
|
loop: __props.loop,
|
|
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",
|
|
"loop",
|
|
"onMouseenter",
|
|
"onMouseleave",
|
|
"onClose"
|
|
]), [[vShow, shouldShow.value]])]),
|
|
_: 3
|
|
}, 8, ["name", "appear"])) : createCommentVNode("v-if", true)]),
|
|
_: 3
|
|
}, 8, ["disabled", "to"]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tooltip/src/content2.mjs
|
|
var content_default2 = content_vue_vue_type_script_setup_true_lang_default2;
|
|
|
|
// node_modules/element-plus/es/components/tooltip/src/tooltip.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_12 = ["innerHTML"];
|
|
var _hoisted_2 = { key: 1 };
|
|
var tooltip_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElTooltip",
|
|
__name: "tooltip",
|
|
props: useTooltipProps,
|
|
emits: tooltipEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
usePopperContainer();
|
|
const ns = useNamespace("tooltip");
|
|
const id = useId();
|
|
const popperRef = ref();
|
|
const contentRef = ref();
|
|
const updatePopper = () => {
|
|
var _a;
|
|
const popperComponent = unref(popperRef);
|
|
if (popperComponent)
|
|
(_a = popperComponent.popperInstanceRef) == null ? void 0 : _a.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,
|
|
onClose,
|
|
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;
|
|
if (!disabled && isBoolean2(props2.visible))
|
|
open.value = props2.visible;
|
|
});
|
|
const isFocusInsideContent = (event) => {
|
|
var _a;
|
|
return (_a = contentRef.value) == null ? void 0 : _a.isFocusInsideContent(event);
|
|
};
|
|
onDeactivated(() => open.value && hide2());
|
|
onBeforeUnmount(() => {
|
|
toggleReason.value = void 0;
|
|
});
|
|
__expose({
|
|
popperRef,
|
|
contentRef,
|
|
isFocusInsideContent,
|
|
updatePopper,
|
|
onOpen,
|
|
onClose,
|
|
hide: hide2
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElPopper), {
|
|
ref_key: "popperRef",
|
|
ref: popperRef,
|
|
role: __props.role
|
|
}, {
|
|
default: withCtx(() => [createVNode(trigger_default2, {
|
|
disabled: __props.disabled,
|
|
trigger: __props.trigger,
|
|
"trigger-keys": __props.triggerKeys,
|
|
"virtual-ref": __props.virtualRef,
|
|
"virtual-triggering": __props.virtualTriggering,
|
|
"focus-on-target": __props.focusOnTarget
|
|
}, {
|
|
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",
|
|
"focus-on-target"
|
|
]), createVNode(content_default2, {
|
|
ref_key: "contentRef",
|
|
ref: contentRef,
|
|
"aria-label": __props.ariaLabel,
|
|
"boundaries-padding": __props.boundariesPadding,
|
|
content: __props.content,
|
|
disabled: __props.disabled,
|
|
effect: __props.effect,
|
|
enterable: __props.enterable,
|
|
"fallback-placements": __props.fallbackPlacements,
|
|
"hide-after": __props.hideAfter,
|
|
"gpu-acceleration": __props.gpuAcceleration,
|
|
offset: __props.offset,
|
|
persistent: __props.persistent,
|
|
"popper-class": kls.value,
|
|
"popper-style": __props.popperStyle,
|
|
placement: __props.placement,
|
|
"popper-options": __props.popperOptions,
|
|
"arrow-offset": __props.arrowOffset,
|
|
pure: __props.pure,
|
|
"raw-content": __props.rawContent,
|
|
"reference-el": __props.referenceEl,
|
|
"trigger-target-el": __props.triggerTargetEl,
|
|
"show-after": __props.showAfter,
|
|
strategy: __props.strategy,
|
|
teleported: __props.teleported,
|
|
transition: __props.transition,
|
|
"virtual-triggering": __props.virtualTriggering,
|
|
"z-index": __props.zIndex,
|
|
"append-to": __props.appendTo,
|
|
loop: __props.loop
|
|
}, {
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "content", {}, () => [__props.rawContent ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
innerHTML: __props.content
|
|
}, null, 8, _hoisted_12)) : (openBlock(), createElementBlock("span", _hoisted_2, toDisplayString(__props.content), 1))]), __props.showArrow ? (openBlock(), createBlock(unref(arrow_default), { 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",
|
|
"loop"
|
|
])]),
|
|
_: 3
|
|
}, 8, ["role"]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tooltip/src/tooltip2.mjs
|
|
var tooltip_default = tooltip_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/tooltip/index.mjs
|
|
var ElTooltip = withInstall(tooltip_default);
|
|
|
|
// 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: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
modelValue: {
|
|
type: definePropType([
|
|
String,
|
|
Number,
|
|
Object
|
|
]),
|
|
default: ""
|
|
},
|
|
modelModifiers: {
|
|
type: definePropType(Object),
|
|
default: () => ({})
|
|
},
|
|
maxlength: { type: [String, Number] },
|
|
minlength: { type: [String, Number] },
|
|
type: {
|
|
type: definePropType(String),
|
|
default: "text"
|
|
},
|
|
resize: {
|
|
type: String,
|
|
values: [
|
|
"none",
|
|
"both",
|
|
"horizontal",
|
|
"vertical"
|
|
]
|
|
},
|
|
autosize: {
|
|
type: definePropType([Boolean, Object]),
|
|
default: false
|
|
},
|
|
autocomplete: {
|
|
type: definePropType(String),
|
|
default: "off"
|
|
},
|
|
formatter: { type: Function },
|
|
parser: { type: Function },
|
|
placeholder: { type: String },
|
|
form: { type: String },
|
|
readonly: Boolean,
|
|
clearable: Boolean,
|
|
clearIcon: {
|
|
type: iconPropType,
|
|
default: circle_close_default
|
|
},
|
|
showPassword: Boolean,
|
|
showWordLimit: Boolean,
|
|
wordLimitPosition: {
|
|
type: String,
|
|
values: ["inside", "outside"],
|
|
default: "inside"
|
|
},
|
|
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({})
|
|
},
|
|
countGraphemes: { type: definePropType(Function) },
|
|
autofocus: Boolean,
|
|
rows: {
|
|
type: Number,
|
|
default: 2
|
|
},
|
|
...useAriaProps(["ariaLabel"]),
|
|
inputmode: {
|
|
type: definePropType(String),
|
|
default: void 0
|
|
},
|
|
name: String
|
|
});
|
|
var inputEmits = {
|
|
[UPDATE_MODEL_EVENT]: (value) => isString(value),
|
|
input: (value) => isString(value),
|
|
change: (value, evt) => isString(value) && (evt instanceof Event || evt === void 0),
|
|
focus: (evt) => evt instanceof FocusEvent,
|
|
blur: (evt) => evt instanceof FocusEvent,
|
|
clear: (evt) => evt === void 0 || evt instanceof MouseEvent,
|
|
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
|
|
};
|
|
var inputPropsDefaults = {
|
|
disabled: void 0,
|
|
modelValue: "",
|
|
modelModifiers: () => ({}),
|
|
type: "text",
|
|
autocomplete: "off",
|
|
clearIcon: markRaw(circle_close_default),
|
|
wordLimitPosition: "inside",
|
|
tabindex: 0,
|
|
validateEvent: true,
|
|
inputStyle: () => ({}),
|
|
rows: 2
|
|
};
|
|
|
|
// 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",
|
|
"word-break"
|
|
];
|
|
var looseToNumber = (val) => {
|
|
const n = Number.parseFloat(val);
|
|
return Number.isNaN(n) ? val : n;
|
|
};
|
|
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"));
|
|
return {
|
|
contextStyle: CONTEXT_STYLE.map((name) => [name, style.getPropertyValue(name)]),
|
|
paddingSize,
|
|
borderSize,
|
|
boxSizing
|
|
};
|
|
}
|
|
function calcTextareaHeight(targetElement, minRows = 1, maxRows) {
|
|
var _a;
|
|
if (!hiddenTextarea) {
|
|
hiddenTextarea = document.createElement("textarea");
|
|
let hostNode = document.body;
|
|
if (!isFirefox() && targetElement.parentNode)
|
|
hostNode = targetElement.parentNode;
|
|
hostNode.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`;
|
|
(_a = hiddenTextarea.parentNode) == null ? void 0 : _a.removeChild(hiddenTextarea);
|
|
hiddenTextarea = void 0;
|
|
return result2;
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/input/src/input.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_13 = [
|
|
"id",
|
|
"name",
|
|
"minlength",
|
|
"maxlength",
|
|
"type",
|
|
"disabled",
|
|
"readonly",
|
|
"autocomplete",
|
|
"tabindex",
|
|
"aria-label",
|
|
"placeholder",
|
|
"form",
|
|
"autofocus",
|
|
"role",
|
|
"inputmode"
|
|
];
|
|
var _hoisted_22 = [
|
|
"id",
|
|
"name",
|
|
"minlength",
|
|
"maxlength",
|
|
"tabindex",
|
|
"disabled",
|
|
"readonly",
|
|
"autocomplete",
|
|
"aria-label",
|
|
"placeholder",
|
|
"form",
|
|
"autofocus",
|
|
"rows",
|
|
"role",
|
|
"inputmode"
|
|
];
|
|
var COMPONENT_NAME4 = "ElInput";
|
|
var input_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: COMPONENT_NAME4,
|
|
inheritAttrs: false,
|
|
__name: "input",
|
|
props: inputProps,
|
|
emits: inputEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const rawAttrs = useAttrs();
|
|
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 attrs = useAttrs2();
|
|
const maxlength = computed(() => {
|
|
var _a;
|
|
return (_a = props2.maxlength) == null ? void 0 : _a.toString();
|
|
});
|
|
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 saveValue = ref("");
|
|
const _ref = computed(() => input.value || textarea.value);
|
|
const { wrapperRef, isFocused, handleFocus, handleBlur } = useFocusController(_ref, {
|
|
disabled: inputDisabled,
|
|
afterBlur() {
|
|
var _a;
|
|
if (props2.validateEvent)
|
|
(_a = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a.call(elFormItem, "blur").catch((err) => debugWarn(err));
|
|
}
|
|
});
|
|
const needStatusIcon = computed(() => {
|
|
var _a;
|
|
return (_a = elForm == null ? void 0 : elForm.statusIcon) != null ? _a : 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 && !!maxlength.value && (props2.type === "text" || props2.type === "textarea") && !inputDisabled.value && !props2.readonly && !props2.showPassword);
|
|
const textLength = computed(() => {
|
|
if (props2.countGraphemes && props2.showWordLimit)
|
|
return props2.countGraphemes(nativeInputValue.value);
|
|
return nativeInputValue.value.length;
|
|
});
|
|
const inputExceed = computed(() => !!isWordLimitVisible.value && textLength.value > Number(maxlength.value));
|
|
const suffixVisible = computed(() => !!slots.suffix || !!props2.suffixIcon || showClear.value || props2.showPassword || isWordLimitVisible.value || !!validateState.value && needStatusIcon.value);
|
|
const hasModelModifiers = computed(() => !!Object.keys(props2.modelModifiers).length);
|
|
const [recordCursor, setCursor] = useCursor(input);
|
|
useResizeObserver(textarea, (entries) => {
|
|
onceInitSizeTextarea();
|
|
if (!isWordLimitVisible.value || props2.resize !== "both" && props2.resize !== "horizontal")
|
|
return;
|
|
const { width } = entries[0].contentRect;
|
|
countStyle.value = { right: `calc(100% - ${width + 22 - 10}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 _a;
|
|
if (isInit || !props2.autosize)
|
|
return;
|
|
if (!(((_a = textarea.value) == null ? void 0 : _a.offsetParent) === null)) {
|
|
setTimeout(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 || props2.type === "file")
|
|
return;
|
|
input2.value = formatterValue;
|
|
};
|
|
const formatValue = (value) => {
|
|
const { trim: trim2, number: number4 } = props2.modelModifiers;
|
|
if (trim2)
|
|
value = value.trim();
|
|
if (number4)
|
|
value = `${looseToNumber(value)}`;
|
|
if (props2.formatter && props2.parser)
|
|
value = props2.parser(value);
|
|
return value;
|
|
};
|
|
const handleInput = async (event) => {
|
|
if (isComposing.value)
|
|
return;
|
|
const { lazy } = props2.modelModifiers;
|
|
let { value } = event.target;
|
|
let shouldForceNativeUpdate = false;
|
|
if (lazy) {
|
|
emit(INPUT_EVENT, value);
|
|
return;
|
|
}
|
|
value = formatValue(value);
|
|
if (props2.countGraphemes && maxlength.value != null) {
|
|
const limit = Number(maxlength.value);
|
|
const graphemes = props2.countGraphemes(value);
|
|
const saveGraphemes = props2.countGraphemes(saveValue.value);
|
|
if (graphemes > limit && graphemes > saveGraphemes)
|
|
if (saveGraphemes > limit) {
|
|
value = saveValue.value;
|
|
shouldForceNativeUpdate = true;
|
|
} else {
|
|
const prevValue = saveValue.value;
|
|
const nextValue = value;
|
|
let prefixLen = 0;
|
|
while (prefixLen < prevValue.length && prefixLen < nextValue.length && prevValue[prefixLen] === nextValue[prefixLen])
|
|
prefixLen++;
|
|
let prevSuffixIndex = prevValue.length;
|
|
let nextSuffixIndex = nextValue.length;
|
|
while (prevSuffixIndex > prefixLen && nextSuffixIndex > prefixLen && prevValue[prevSuffixIndex - 1] === nextValue[nextSuffixIndex - 1]) {
|
|
prevSuffixIndex--;
|
|
nextSuffixIndex--;
|
|
}
|
|
const before2 = nextValue.slice(0, prefixLen);
|
|
const removed = prevValue.slice(prefixLen, prevSuffixIndex);
|
|
const inserted = nextValue.slice(prefixLen, nextSuffixIndex);
|
|
const after2 = nextValue.slice(nextSuffixIndex);
|
|
const baseCount = saveGraphemes - props2.countGraphemes(removed);
|
|
const availableInserted = Math.max(0, limit - baseCount);
|
|
let acceptedInserted = "";
|
|
if (availableInserted > 0)
|
|
if (typeof Intl !== "undefined" && "Segmenter" in Intl) {
|
|
const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
|
|
for (const { segment } of segmenter.segment(inserted)) {
|
|
const candidate = acceptedInserted + segment;
|
|
if (props2.countGraphemes(candidate) > availableInserted)
|
|
break;
|
|
acceptedInserted = candidate;
|
|
}
|
|
} else
|
|
for (const char of Array.from(inserted)) {
|
|
const candidate = acceptedInserted + char;
|
|
if (props2.countGraphemes(candidate) > availableInserted)
|
|
break;
|
|
acceptedInserted = candidate;
|
|
}
|
|
value = before2 + acceptedInserted + after2;
|
|
shouldForceNativeUpdate = true;
|
|
}
|
|
}
|
|
if (String(value) === nativeInputValue.value) {
|
|
if (props2.formatter || shouldForceNativeUpdate) {
|
|
const target2 = event.target;
|
|
const blockedValue = target2.value;
|
|
const selectionStart = target2.selectionStart;
|
|
const selectionEnd = target2.selectionEnd;
|
|
setNativeInputValue();
|
|
if (shouldForceNativeUpdate && _ref.value && selectionStart != null && selectionEnd != null) {
|
|
const restoredValue = _ref.value.value;
|
|
const afterTxt = blockedValue.slice(Math.max(0, selectionEnd));
|
|
let caretPos = Math.min(selectionStart, restoredValue.length);
|
|
if (afterTxt && restoredValue.endsWith(afterTxt))
|
|
caretPos = restoredValue.length - afterTxt.length;
|
|
_ref.value.setSelectionRange(caretPos, caretPos);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
saveValue.value = value;
|
|
recordCursor();
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emit(INPUT_EVENT, value);
|
|
await nextTick();
|
|
if (props2.formatter && props2.parser || !hasModelModifiers.value)
|
|
setNativeInputValue();
|
|
setCursor();
|
|
};
|
|
const handleChange = async (event) => {
|
|
let { value } = event.target;
|
|
value = formatValue(value);
|
|
if (props2.modelModifiers.lazy)
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emit(CHANGE_EVENT, value, event);
|
|
await nextTick();
|
|
setNativeInputValue();
|
|
};
|
|
const { isComposing, handleCompositionStart, handleCompositionUpdate, handleCompositionEnd } = useComposition({
|
|
emit,
|
|
afterComposition: handleInput
|
|
});
|
|
const handlePasswordVisible = () => {
|
|
passwordVisible.value = !passwordVisible.value;
|
|
};
|
|
const focus = () => {
|
|
var _a;
|
|
return (_a = _ref.value) == null ? void 0 : _a.focus();
|
|
};
|
|
const blur = () => {
|
|
var _a;
|
|
return (_a = _ref.value) == null ? void 0 : _a.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 _a;
|
|
(_a = _ref.value) == null ? void 0 : _a.select();
|
|
};
|
|
const clear = (evt) => {
|
|
emit(UPDATE_MODEL_EVENT, "");
|
|
emit(CHANGE_EVENT, "");
|
|
emit("clear", evt);
|
|
emit(INPUT_EVENT, "");
|
|
};
|
|
watch(() => props2.modelValue, () => {
|
|
var _a;
|
|
nextTick(() => resizeTextarea());
|
|
if (props2.validateEvent)
|
|
(_a = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a.call(elFormItem, "change").catch((err) => debugWarn(err));
|
|
});
|
|
watch(() => nativeInputValue.value, (val) => {
|
|
saveValue.value = val;
|
|
}, { immediate: true });
|
|
watch(nativeInputValue, (newValue) => {
|
|
if (!_ref.value)
|
|
return;
|
|
const { trim: trim2, number: number4 } = props2.modelModifiers;
|
|
const elValue = _ref.value.value;
|
|
const displayValue = (number4 || props2.type === "number") && !/^0\d/.test(elValue) ? `${looseToNumber(elValue)}` : elValue;
|
|
if (displayValue === newValue)
|
|
return;
|
|
if (document.activeElement === _ref.value && _ref.value.type !== "range") {
|
|
if (trim2 && displayValue.trim() === newValue)
|
|
return;
|
|
}
|
|
setNativeInputValue();
|
|
});
|
|
watch(() => props2.type, async () => {
|
|
await nextTick();
|
|
setNativeInputValue();
|
|
resizeTextarea();
|
|
});
|
|
onMounted(() => {
|
|
if (!props2.formatter && props2.parser)
|
|
debugWarn(COMPONENT_NAME4, "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,
|
|
passwordVisible,
|
|
focus,
|
|
blur,
|
|
select,
|
|
clear,
|
|
resizeTextarea
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([containerKls.value, {
|
|
[unref(nsInput).bm("group", "append")]: _ctx.$slots.append,
|
|
[unref(nsInput).bm("group", "prepend")]: _ctx.$slots.prepend
|
|
}]),
|
|
style: normalizeStyle(containerStyle.value),
|
|
onMouseenter: handleMouseEnter,
|
|
onMouseleave: handleMouseLeave
|
|
}, [createCommentVNode(" input "), __props.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(wrapperKls.value)
|
|
}, [
|
|
createCommentVNode(" prefix slot "),
|
|
_ctx.$slots.prefix || __props.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"), __props.prefixIcon ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(nsInput).e("icon"))
|
|
}, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.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), {
|
|
name: __props.name,
|
|
minlength: __props.countGraphemes ? void 0 : __props.minlength,
|
|
maxlength: __props.countGraphemes ? void 0 : maxlength.value,
|
|
type: __props.showPassword ? passwordVisible.value ? "text" : "password" : __props.type,
|
|
disabled: unref(inputDisabled),
|
|
readonly: __props.readonly,
|
|
autocomplete: __props.autocomplete,
|
|
tabindex: __props.tabindex,
|
|
"aria-label": __props.ariaLabel,
|
|
placeholder: __props.placeholder,
|
|
style: __props.inputStyle,
|
|
form: __props.form,
|
|
autofocus: __props.autofocus,
|
|
role: __props.containerRole,
|
|
inputmode: __props.inputmode,
|
|
onCompositionstart: _cache[0] || (_cache[0] = (...args) => unref(handleCompositionStart) && unref(handleCompositionStart)(...args)),
|
|
onCompositionupdate: _cache[1] || (_cache[1] = (...args) => unref(handleCompositionUpdate) && unref(handleCompositionUpdate)(...args)),
|
|
onCompositionend: _cache[2] || (_cache[2] = (...args) => unref(handleCompositionEnd) && unref(handleCompositionEnd)(...args)),
|
|
onInput: handleInput,
|
|
onChange: handleChange,
|
|
onKeydown: handleKeydown
|
|
}), null, 16, _hoisted_13),
|
|
createCommentVNode(" suffix slot "),
|
|
suffixVisible.value ? (openBlock(), createElementBlock("span", {
|
|
key: 1,
|
|
class: normalizeClass(unref(nsInput).e("suffix"))
|
|
}, [createBaseVNode("span", { class: normalizeClass(unref(nsInput).e("suffix-inner")) }, [
|
|
!showClear.value || !showPwdVisible.value || !isWordLimitVisible.value ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [renderSlot(_ctx.$slots, "suffix"), __props.suffixIcon ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(nsInput).e("icon"))
|
|
}, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.suffixIcon)))]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true)], 64)) : createCommentVNode("v-if", true),
|
|
showClear.value ? (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(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.clearIcon)))]),
|
|
_: 1
|
|
}, 8, ["class", "onMousedown"])) : createCommentVNode("v-if", true),
|
|
showPwdVisible.value ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 2,
|
|
class: normalizeClass([unref(nsInput).e("icon"), unref(nsInput).e("password")]),
|
|
onClick: handlePasswordVisible,
|
|
onMousedown: withModifiers(unref(NOOP), ["prevent"]),
|
|
onMouseup: withModifiers(unref(NOOP), ["prevent"])
|
|
}, {
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "password-icon", { visible: passwordVisible.value }, () => [(openBlock(), createBlock(resolveDynamicComponent(passwordIcon.value)))])]),
|
|
_: 3
|
|
}, 8, [
|
|
"class",
|
|
"onMousedown",
|
|
"onMouseup"
|
|
])) : createCommentVNode("v-if", true),
|
|
isWordLimitVisible.value ? (openBlock(), createElementBlock("span", {
|
|
key: 3,
|
|
class: normalizeClass([unref(nsInput).e("count"), unref(nsInput).is("outside", __props.wordLimitPosition === "outside")])
|
|
}, [createBaseVNode("span", { class: normalizeClass(unref(nsInput).e("count-inner")) }, toDisplayString(textLength.value) + " / " + toDisplayString(maxlength.value), 3)], 2)) : createCommentVNode("v-if", true),
|
|
validateState.value && validateIcon.value && needStatusIcon.value ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 4,
|
|
class: normalizeClass([
|
|
unref(nsInput).e("icon"),
|
|
unref(nsInput).e("validateIcon"),
|
|
unref(nsInput).is("loading", validateState.value === "validating")
|
|
])
|
|
}, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(validateIcon.value)))]),
|
|
_: 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(nsTextarea).is("clearable", __props.clearable)
|
|
]
|
|
}, unref(attrs), {
|
|
name: __props.name,
|
|
minlength: __props.countGraphemes ? void 0 : __props.minlength,
|
|
maxlength: __props.countGraphemes ? void 0 : maxlength.value,
|
|
tabindex: __props.tabindex,
|
|
disabled: unref(inputDisabled),
|
|
readonly: __props.readonly,
|
|
autocomplete: __props.autocomplete,
|
|
style: textareaStyle.value,
|
|
"aria-label": __props.ariaLabel,
|
|
placeholder: __props.placeholder,
|
|
form: __props.form,
|
|
autofocus: __props.autofocus,
|
|
rows: __props.rows,
|
|
role: __props.containerRole,
|
|
inputmode: __props.inputmode,
|
|
onCompositionstart: _cache[3] || (_cache[3] = (...args) => unref(handleCompositionStart) && unref(handleCompositionStart)(...args)),
|
|
onCompositionupdate: _cache[4] || (_cache[4] = (...args) => unref(handleCompositionUpdate) && unref(handleCompositionUpdate)(...args)),
|
|
onCompositionend: _cache[5] || (_cache[5] = (...args) => unref(handleCompositionEnd) && unref(handleCompositionEnd)(...args)),
|
|
onInput: handleInput,
|
|
onFocus: _cache[6] || (_cache[6] = (...args) => unref(handleFocus) && unref(handleFocus)(...args)),
|
|
onBlur: _cache[7] || (_cache[7] = (...args) => unref(handleBlur) && unref(handleBlur)(...args)),
|
|
onChange: handleChange,
|
|
onKeydown: handleKeydown
|
|
}), null, 16, _hoisted_22),
|
|
showClear.value ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass([unref(nsTextarea).e("icon"), unref(nsTextarea).e("clear")]),
|
|
onMousedown: withModifiers(unref(NOOP), ["prevent"]),
|
|
onClick: clear
|
|
}, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.clearIcon)))]),
|
|
_: 1
|
|
}, 8, ["class", "onMousedown"])) : createCommentVNode("v-if", true),
|
|
isWordLimitVisible.value ? (openBlock(), createElementBlock("span", {
|
|
key: 1,
|
|
style: normalizeStyle(countStyle.value),
|
|
class: normalizeClass([unref(nsInput).e("count"), unref(nsInput).is("outside", __props.wordLimitPosition === "outside")])
|
|
}, toDisplayString(textLength.value) + " / " + toDisplayString(maxlength.value), 7)) : createCommentVNode("v-if", true)
|
|
], 64))], 38);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/input/src/input2.mjs
|
|
var input_default = input_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/input/index.mjs
|
|
var ElInput = withInstall(input_default);
|
|
|
|
// node_modules/element-plus/es/components/autocomplete/src/autocomplete.mjs
|
|
var autocompleteProps = buildProps({
|
|
...inputProps,
|
|
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: useTooltipContentProps.popperClass,
|
|
popperStyle: useTooltipContentProps.popperStyle,
|
|
triggerOnFocus: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
selectWhenUnmatched: Boolean,
|
|
hideLoading: Boolean,
|
|
teleported: useTooltipContentProps.teleported,
|
|
appendTo: useTooltipContentProps.appendTo,
|
|
highlightFirstItem: Boolean,
|
|
fitInputWidth: Boolean,
|
|
loopNavigation: {
|
|
type: Boolean,
|
|
default: true
|
|
}
|
|
});
|
|
var autocompleteEmits = {
|
|
[UPDATE_MODEL_EVENT]: (value) => isString(value) || isNumber2(value),
|
|
[INPUT_EVENT]: (value) => isString(value) || isNumber2(value),
|
|
[CHANGE_EVENT]: (value) => isString(value) || isNumber2(value),
|
|
focus: (evt) => evt instanceof FocusEvent,
|
|
blur: (evt) => evt instanceof FocusEvent,
|
|
clear: () => true,
|
|
select: (item) => isObject(item)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/scrollbar/src/scrollbar.mjs
|
|
var scrollbarProps = buildProps({
|
|
distance: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
height: {
|
|
type: [String, Number],
|
|
default: ""
|
|
},
|
|
maxHeight: {
|
|
type: [String, Number],
|
|
default: ""
|
|
},
|
|
native: Boolean,
|
|
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 = {
|
|
"end-reached": (direction2) => [
|
|
"left",
|
|
"right",
|
|
"top",
|
|
"bottom"
|
|
].includes(direction2),
|
|
scroll: ({ scrollTop, scrollLeft }) => [scrollTop, scrollLeft].every(isNumber2)
|
|
};
|
|
|
|
// 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/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/constants.mjs
|
|
var scrollbarContextKey = Symbol("scrollbarContextKey");
|
|
|
|
// node_modules/element-plus/es/utils/numbers.mjs
|
|
function isGreaterThan(a2, b2, epsilon = 0.03) {
|
|
return a2 - b2 > epsilon;
|
|
}
|
|
|
|
// 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/thumb.vue_vue_type_script_setup_true_lang.mjs
|
|
var COMPONENT_NAME5 = "Thumb";
|
|
var thumb_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
__name: "thumb",
|
|
props: thumbProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const scrollbar = inject(scrollbarContextKey);
|
|
const ns = useNamespace("scrollbar");
|
|
if (!scrollbar)
|
|
throwError(COMPONENT_NAME5, "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 baseScrollHeight = 0;
|
|
let baseScrollWidth = 0;
|
|
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 _a;
|
|
e.stopPropagation();
|
|
if (e.ctrlKey || [1, 2].includes(e.button))
|
|
return;
|
|
(_a = window.getSelection()) == null ? void 0 : _a.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 thumbPositionPercentage = (Math.abs(e.target.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) - thumb.value[bar.value.offset] / 2) * 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;
|
|
baseScrollHeight = scrollbar.wrapElement.scrollHeight;
|
|
baseScrollWidth = scrollbar.wrapElement.scrollWidth;
|
|
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 thumbPositionPercentage = ((instance.value.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) * -1 - (thumb.value[bar.value.offset] - prevPage)) * 100 * offsetRatio.value / instance.value[bar.value.offset];
|
|
if (bar.value.scroll === "scrollLeft")
|
|
scrollbar.wrapElement[bar.value.scroll] = thumbPositionPercentage * baseScrollWidth / 100;
|
|
else
|
|
scrollbar.wrapElement[bar.value.scroll] = thumbPositionPercentage * baseScrollHeight / 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(bar.value.key)]),
|
|
onMousedown: clickTrackHandler,
|
|
onClick: _cache[0] || (_cache[0] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}, [createBaseVNode("div", {
|
|
ref_key: "thumb",
|
|
ref: thumb,
|
|
class: normalizeClass(unref(ns).e("thumb")),
|
|
style: normalizeStyle(thumbStyle.value),
|
|
onMousedown: clickThumbHandler
|
|
}, null, 38)], 34), [[vShow, __props.always || visible.value]])]),
|
|
_: 1
|
|
}, 8, ["name"]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/scrollbar/src/thumb2.mjs
|
|
var thumb_default = thumb_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/scrollbar/src/bar.vue_vue_type_script_setup_true_lang.mjs
|
|
var bar_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
__name: "bar",
|
|
props: barProps,
|
|
setup(__props, { expose: __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_default, {
|
|
move: moveX.value,
|
|
ratio: ratioX.value,
|
|
size: sizeWidth.value,
|
|
always: __props.always
|
|
}, null, 8, [
|
|
"move",
|
|
"ratio",
|
|
"size",
|
|
"always"
|
|
]), createVNode(thumb_default, {
|
|
move: moveY.value,
|
|
ratio: ratioY.value,
|
|
size: sizeHeight.value,
|
|
vertical: "",
|
|
always: __props.always
|
|
}, null, 8, [
|
|
"move",
|
|
"ratio",
|
|
"size",
|
|
"always"
|
|
])], 64);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/scrollbar/src/bar2.mjs
|
|
var bar_default = bar_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/scrollbar/src/scrollbar.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_14 = ["tabindex"];
|
|
var COMPONENT_NAME6 = "ElScrollbar";
|
|
var scrollbar_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: COMPONENT_NAME6,
|
|
__name: "scrollbar",
|
|
props: scrollbarProps,
|
|
emits: scrollbarEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const ns = useNamespace("scrollbar");
|
|
let stopResizeObserver = void 0;
|
|
let stopWrapResizeObserver = void 0;
|
|
let stopResizeListener = void 0;
|
|
let wrapScrollTop = 0;
|
|
let wrapScrollLeft = 0;
|
|
let direction2 = "";
|
|
const distanceScrollState = {
|
|
bottom: false,
|
|
top: false,
|
|
right: false,
|
|
left: false
|
|
};
|
|
const scrollbarRef = ref();
|
|
const wrapRef = ref();
|
|
const resizeRef = ref();
|
|
const barRef = ref();
|
|
const wrapStyle = computed(() => {
|
|
const style = {};
|
|
const height = addUnit(props2.height);
|
|
const maxHeight = addUnit(props2.maxHeight);
|
|
if (height)
|
|
style.height = height;
|
|
if (maxHeight)
|
|
style.maxHeight = 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 shouldSkipDirection = (direction3) => {
|
|
var _a;
|
|
return (_a = distanceScrollState[direction3]) != null ? _a : false;
|
|
};
|
|
const DIRECTION_PAIRS = {
|
|
top: "bottom",
|
|
bottom: "top",
|
|
left: "right",
|
|
right: "left"
|
|
};
|
|
const updateTriggerStatus = (arrivedStates) => {
|
|
const oppositeDirection = DIRECTION_PAIRS[direction2];
|
|
if (!oppositeDirection)
|
|
return;
|
|
const arrived = arrivedStates[direction2];
|
|
const oppositeArrived = arrivedStates[oppositeDirection];
|
|
if (arrived && !distanceScrollState[direction2])
|
|
distanceScrollState[direction2] = true;
|
|
if (!oppositeArrived && distanceScrollState[oppositeDirection])
|
|
distanceScrollState[oppositeDirection] = false;
|
|
};
|
|
const handleScroll2 = () => {
|
|
var _a;
|
|
if (wrapRef.value) {
|
|
(_a = barRef.value) == null ? void 0 : _a.handleScroll(wrapRef.value);
|
|
const prevTop = wrapScrollTop;
|
|
const prevLeft = wrapScrollLeft;
|
|
wrapScrollTop = wrapRef.value.scrollTop;
|
|
wrapScrollLeft = wrapRef.value.scrollLeft;
|
|
const arrivedStates = {
|
|
bottom: !isGreaterThan(wrapRef.value.scrollHeight - props2.distance, wrapRef.value.clientHeight + wrapScrollTop),
|
|
top: wrapScrollTop <= props2.distance && prevTop !== 0,
|
|
right: !isGreaterThan(wrapRef.value.scrollWidth - props2.distance, wrapRef.value.clientWidth + wrapScrollLeft) && prevLeft !== wrapScrollLeft,
|
|
left: wrapScrollLeft <= props2.distance && prevLeft !== 0
|
|
};
|
|
emit("scroll", {
|
|
scrollTop: wrapScrollTop,
|
|
scrollLeft: wrapScrollLeft
|
|
});
|
|
if (prevTop !== wrapScrollTop)
|
|
direction2 = wrapScrollTop > prevTop ? "bottom" : "top";
|
|
if (prevLeft !== wrapScrollLeft)
|
|
direction2 = wrapScrollLeft > prevLeft ? "right" : "left";
|
|
if (props2.distance > 0) {
|
|
if (shouldSkipDirection(direction2))
|
|
return;
|
|
updateTriggerStatus(arrivedStates);
|
|
}
|
|
if (arrivedStates[direction2])
|
|
emit("end-reached", direction2);
|
|
}
|
|
};
|
|
function scrollTo2(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_NAME6, "value must be a number");
|
|
return;
|
|
}
|
|
wrapRef.value.scrollTop = value;
|
|
};
|
|
const setScrollLeft = (value) => {
|
|
if (!isNumber2(value)) {
|
|
debugWarn(COMPONENT_NAME6, "value must be a number");
|
|
return;
|
|
}
|
|
wrapRef.value.scrollLeft = value;
|
|
};
|
|
const update2 = () => {
|
|
var _a, _b;
|
|
(_a = barRef.value) == null ? void 0 : _a.update();
|
|
distanceScrollState[direction2] = false;
|
|
if (wrapRef.value)
|
|
(_b = barRef.value) == null ? void 0 : _b.handleScroll(wrapRef.value);
|
|
};
|
|
watch(() => props2.noresize, (noresize) => {
|
|
if (noresize) {
|
|
stopResizeObserver == null ? void 0 : stopResizeObserver();
|
|
stopWrapResizeObserver == null ? void 0 : stopWrapResizeObserver();
|
|
stopResizeListener == null ? void 0 : stopResizeListener();
|
|
} else {
|
|
({ stop: stopResizeObserver } = useResizeObserver(resizeRef, update2));
|
|
({ stop: stopWrapResizeObserver } = useResizeObserver(wrapRef, update2));
|
|
stopResizeListener = useEventListener("resize", update2);
|
|
}
|
|
}, { immediate: true });
|
|
watch(() => [props2.maxHeight, props2.height], () => {
|
|
if (!props2.native)
|
|
nextTick(() => {
|
|
update2();
|
|
});
|
|
});
|
|
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: scrollTo2,
|
|
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(wrapKls.value),
|
|
style: normalizeStyle(wrapStyle.value),
|
|
tabindex: __props.tabindex,
|
|
onScroll: handleScroll2
|
|
}, [(openBlock(), createBlock(resolveDynamicComponent(__props.tag), {
|
|
id: __props.id,
|
|
ref_key: "resizeRef",
|
|
ref: resizeRef,
|
|
class: normalizeClass(resizeKls.value),
|
|
style: normalizeStyle(__props.viewStyle),
|
|
role: __props.role,
|
|
"aria-label": __props.ariaLabel,
|
|
"aria-orientation": __props.ariaOrientation
|
|
}, {
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
|
|
_: 3
|
|
}, 8, [
|
|
"id",
|
|
"class",
|
|
"style",
|
|
"role",
|
|
"aria-label",
|
|
"aria-orientation"
|
|
]))], 46, _hoisted_14), !__props.native ? (openBlock(), createBlock(bar_default, {
|
|
key: 0,
|
|
ref_key: "barRef",
|
|
ref: barRef,
|
|
always: __props.always,
|
|
"min-size": __props.minSize
|
|
}, null, 8, ["always", "min-size"])) : createCommentVNode("v-if", true)], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/scrollbar/src/scrollbar2.mjs
|
|
var scrollbar_default = scrollbar_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/scrollbar/index.mjs
|
|
var ElScrollbar = withInstall(scrollbar_default);
|
|
|
|
// node_modules/element-plus/es/components/autocomplete/src/autocomplete.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_15 = ["aria-expanded", "aria-owns"];
|
|
var _hoisted_23 = { key: 0 };
|
|
var _hoisted_3 = [
|
|
"id",
|
|
"aria-selected",
|
|
"onClick"
|
|
];
|
|
var COMPONENT_NAME7 = "ElAutocomplete";
|
|
var autocomplete_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: COMPONENT_NAME7,
|
|
inheritAttrs: false,
|
|
__name: "autocomplete",
|
|
props: autocompleteProps,
|
|
emits: autocompleteEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const passInputProps = computed(() => {
|
|
var _a;
|
|
const inputProps2 = (_a = ElInput.props) != null ? _a : [];
|
|
return pick_default(props2, isArray(inputProps2) ? inputProps2 : Object.keys(inputProps2));
|
|
});
|
|
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(() => {
|
|
return (suggestions.value.length > 0 || 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_NAME7, "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 = useDebounceFn(getData2, computed(() => 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 _a;
|
|
if (disabled.value)
|
|
return;
|
|
if (((_a = event.target) == null ? void 0 : _a.tagName) !== "INPUT" || refInput.value.includes(document.activeElement))
|
|
activated.value = true;
|
|
};
|
|
const handleChange = (value) => {
|
|
emit(CHANGE_EVENT, value);
|
|
};
|
|
const handleFocus = (evt) => {
|
|
var _a;
|
|
if (!ignoreFocusEvent) {
|
|
activated.value = true;
|
|
emit("focus", evt);
|
|
const queryString = (_a = props2.modelValue) != null ? _a : "";
|
|
if (props2.triggerOnFocus && !readonly2)
|
|
debouncedGetData(String(queryString));
|
|
} else
|
|
ignoreFocusEvent = false;
|
|
};
|
|
const handleBlur = (evt) => {
|
|
setTimeout(() => {
|
|
var _a;
|
|
if ((_a = popperRef.value) == null ? void 0 : _a.isFocusInsideContent()) {
|
|
ignoreFocusEvent = true;
|
|
return;
|
|
}
|
|
activated.value && close2();
|
|
emit("blur", evt);
|
|
});
|
|
};
|
|
const handleClear = () => {
|
|
activated.value = false;
|
|
emit(UPDATE_MODEL_EVENT, "");
|
|
emit("clear");
|
|
};
|
|
const handleKeyEnter = async () => {
|
|
var _a;
|
|
if ((_a = inputRef.value) == null ? void 0 : _a.isComposing)
|
|
return;
|
|
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;
|
|
}
|
|
activated.value = true;
|
|
debouncedGetData(String(props2.modelValue));
|
|
}
|
|
};
|
|
const handleKeyEscape = (evt) => {
|
|
if (suggestionVisible.value) {
|
|
evt.preventDefault();
|
|
evt.stopPropagation();
|
|
close2();
|
|
}
|
|
};
|
|
const close2 = () => {
|
|
activated.value = false;
|
|
};
|
|
const focus = () => {
|
|
var _a;
|
|
(_a = inputRef.value) == null ? void 0 : _a.focus();
|
|
};
|
|
const blur = () => {
|
|
var _a;
|
|
(_a = inputRef.value) == null ? void 0 : _a.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) => {
|
|
var _a, _b;
|
|
if (!suggestionVisible.value || loading.value)
|
|
return;
|
|
if (index < 0) {
|
|
if (!props2.loopNavigation) {
|
|
highlightedIndex.value = -1;
|
|
return;
|
|
}
|
|
index = suggestions.value.length - 1;
|
|
}
|
|
if (index >= suggestions.value.length)
|
|
index = props2.loopNavigation ? 0 : suggestions.value.length - 1;
|
|
const [suggestion, suggestionList] = getSuggestionContext();
|
|
const highlightItem = suggestionList[index];
|
|
const scrollTop = suggestion.scrollTop;
|
|
const { offsetTop, scrollHeight } = highlightItem;
|
|
if (offsetTop + scrollHeight > scrollTop + suggestion.clientHeight)
|
|
suggestion.scrollTop = offsetTop + scrollHeight - suggestion.clientHeight;
|
|
if (offsetTop < scrollTop)
|
|
suggestion.scrollTop = offsetTop;
|
|
highlightedIndex.value = index;
|
|
(_b = (_a = inputRef.value) == null ? void 0 : _a.ref) == null ? void 0 : _b.setAttribute("aria-activedescendant", `${listboxId.value}-item-${highlightedIndex.value}`);
|
|
};
|
|
const getSuggestionContext = () => {
|
|
const suggestion = regionRef.value.querySelector(`.${ns.be("suggestion", "wrap")}`);
|
|
return [suggestion, suggestion.querySelectorAll(`.${ns.be("suggestion", "list")} li`)];
|
|
};
|
|
const stopHandle = onClickOutside(listboxRef, (event) => {
|
|
var _a;
|
|
if ((_a = popperRef.value) == null ? void 0 : _a.isFocusInsideContent())
|
|
return;
|
|
const hadIgnoredFocus = ignoreFocusEvent;
|
|
ignoreFocusEvent = false;
|
|
if (!suggestionVisible.value)
|
|
return;
|
|
if (hadIgnoredFocus)
|
|
handleBlur(new FocusEvent("blur", event));
|
|
else
|
|
close2();
|
|
});
|
|
const handleKeydown = (e) => {
|
|
switch (getEventCode(e)) {
|
|
case EVENT_CODE.up:
|
|
e.preventDefault();
|
|
highlight(highlightedIndex.value - 1);
|
|
break;
|
|
case EVENT_CODE.down:
|
|
e.preventDefault();
|
|
highlight(highlightedIndex.value + 1);
|
|
break;
|
|
case EVENT_CODE.enter:
|
|
case EVENT_CODE.numpadEnter:
|
|
e.preventDefault();
|
|
handleKeyEnter();
|
|
break;
|
|
case EVENT_CODE.tab:
|
|
close2();
|
|
break;
|
|
case EVENT_CODE.esc:
|
|
handleKeyEscape(e);
|
|
break;
|
|
case EVENT_CODE.home:
|
|
e.preventDefault();
|
|
highlight(0);
|
|
break;
|
|
case EVENT_CODE.end:
|
|
e.preventDefault();
|
|
highlight(suggestions.value.length - 1);
|
|
break;
|
|
case EVENT_CODE.pageUp:
|
|
e.preventDefault();
|
|
highlight(Math.max(0, highlightedIndex.value - 10));
|
|
break;
|
|
case EVENT_CODE.pageDown:
|
|
e.preventDefault();
|
|
highlight(Math.min(suggestions.value.length - 1, highlightedIndex.value + 10));
|
|
break;
|
|
}
|
|
};
|
|
onBeforeUnmount(() => {
|
|
stopHandle == null ? void 0 : stopHandle();
|
|
});
|
|
onMounted(() => {
|
|
var _a;
|
|
const inputElement = (_a = inputRef.value) == null ? void 0 : _a.ref;
|
|
if (!inputElement)
|
|
return;
|
|
[
|
|
{
|
|
key: "role",
|
|
value: "textbox"
|
|
},
|
|
{
|
|
key: "aria-autocomplete",
|
|
value: "list"
|
|
},
|
|
{
|
|
key: "aria-controls",
|
|
value: listboxId.value
|
|
},
|
|
{
|
|
key: "aria-activedescendant",
|
|
value: `${listboxId.value}-item-${highlightedIndex.value}`
|
|
}
|
|
].forEach(({ key, value }) => inputElement.setAttribute(key, value));
|
|
readonly2 = inputElement.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: suggestionVisible.value,
|
|
placement: __props.placement,
|
|
"fallback-placements": ["bottom-start", "top-start"],
|
|
"popper-class": [unref(ns).e("popper"), __props.popperClass],
|
|
"popper-style": __props.popperStyle,
|
|
teleported: __props.teleported,
|
|
"append-to": __props.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", suggestionLoading.value)]),
|
|
style: normalizeStyle({
|
|
[__props.fitInputWidth ? "width" : "minWidth"]: dropdownWidth.value,
|
|
outline: "none"
|
|
}),
|
|
role: "region"
|
|
}, [
|
|
_ctx.$slots.header ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).be("suggestion", "header")),
|
|
onClick: _cache[0] || (_cache[0] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}, [renderSlot(_ctx.$slots, "header")], 2)) : createCommentVNode("v-if", true),
|
|
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(() => [suggestionLoading.value ? (openBlock(), createElementBlock("li", _hoisted_23, [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[__props.valueKey]), 1)])], 10, _hoisted_3);
|
|
}), 128))]),
|
|
_: 3
|
|
}, 8, [
|
|
"id",
|
|
"wrap-class",
|
|
"view-class"
|
|
]),
|
|
_ctx.$slots.footer ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).be("suggestion", "footer")),
|
|
onClick: _cache[1] || (_cache[1] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}, [renderSlot(_ctx.$slots, "footer")], 2)) : createCommentVNode("v-if", true)
|
|
], 6)]),
|
|
default: withCtx(() => [createBaseVNode("div", {
|
|
ref_key: "listboxRef",
|
|
ref: listboxRef,
|
|
class: normalizeClass([unref(ns).b(), _ctx.$attrs.class]),
|
|
style: normalizeStyle(styles.value),
|
|
role: "combobox",
|
|
"aria-haspopup": "listbox",
|
|
"aria-expanded": suggestionVisible.value,
|
|
"aria-owns": unref(listboxId)
|
|
}, [createVNode(unref(ElInput), mergeProps({
|
|
ref_key: "inputRef",
|
|
ref: inputRef
|
|
}, mergeProps(passInputProps.value, _ctx.$attrs), {
|
|
"model-value": __props.modelValue,
|
|
disabled: unref(disabled),
|
|
onInput: handleInput,
|
|
onChange: handleChange,
|
|
onFocus: handleFocus,
|
|
onBlur: handleBlur,
|
|
onClear: handleClear,
|
|
onKeydown: handleKeydown,
|
|
onMousedown: handleMouseDown
|
|
}), createSlots({ _: 2 }, [
|
|
_ctx.$slots.prepend ? {
|
|
name: "prepend",
|
|
fn: withCtx(() => [renderSlot(_ctx.$slots, "prepend")]),
|
|
key: "0"
|
|
} : void 0,
|
|
_ctx.$slots.append ? {
|
|
name: "append",
|
|
fn: withCtx(() => [renderSlot(_ctx.$slots, "append")]),
|
|
key: "1"
|
|
} : void 0,
|
|
_ctx.$slots.prefix ? {
|
|
name: "prefix",
|
|
fn: withCtx(() => [renderSlot(_ctx.$slots, "prefix")]),
|
|
key: "2"
|
|
} : void 0,
|
|
_ctx.$slots.suffix ? {
|
|
name: "suffix",
|
|
fn: withCtx(() => [renderSlot(_ctx.$slots, "suffix")]),
|
|
key: "3"
|
|
} : void 0
|
|
]), 1040, ["model-value", "disabled"])], 14, _hoisted_15)]),
|
|
_: 3
|
|
}, 8, [
|
|
"visible",
|
|
"placement",
|
|
"popper-class",
|
|
"popper-style",
|
|
"teleported",
|
|
"append-to",
|
|
"transition"
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/autocomplete/src/autocomplete2.mjs
|
|
var autocomplete_default = autocomplete_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/autocomplete/index.mjs
|
|
var ElAutocomplete = withInstall(autocomplete_default);
|
|
|
|
// node_modules/element-plus/es/components/avatar/src/avatar.mjs
|
|
var avatarProps = buildProps({
|
|
size: {
|
|
type: [Number, String],
|
|
values: componentSizes,
|
|
validator: (val) => isNumber2(val)
|
|
},
|
|
shape: {
|
|
type: String,
|
|
values: ["circle", "square"]
|
|
},
|
|
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/constants.mjs
|
|
var avatarGroupContextKey = Symbol("avatarGroupContextKey");
|
|
|
|
// node_modules/element-plus/es/components/avatar/src/avatar-group-props.mjs
|
|
var avatarGroupProps = {
|
|
size: {
|
|
type: definePropType([Number, String]),
|
|
values: componentSizes,
|
|
validator: (val) => isNumber2(val)
|
|
},
|
|
shape: {
|
|
type: definePropType(String),
|
|
values: ["circle", "square"]
|
|
},
|
|
collapseAvatars: Boolean,
|
|
collapseAvatarsTooltip: Boolean,
|
|
maxCollapseAvatars: {
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
effect: {
|
|
type: definePropType(String),
|
|
default: "light"
|
|
},
|
|
placement: {
|
|
type: definePropType(String),
|
|
values: Ee,
|
|
default: "top"
|
|
},
|
|
popperClass: useTooltipContentProps.popperClass,
|
|
popperStyle: useTooltipContentProps.popperStyle,
|
|
collapseClass: String,
|
|
collapseStyle: { type: definePropType([
|
|
String,
|
|
Array,
|
|
Object
|
|
]) }
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/avatar/src/avatar.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_16 = [
|
|
"src",
|
|
"alt",
|
|
"srcset"
|
|
];
|
|
var avatar_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElAvatar",
|
|
__name: "avatar",
|
|
props: avatarProps,
|
|
emits: avatarEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const avatarGroupContext = inject(avatarGroupContextKey, void 0);
|
|
const ns = useNamespace("avatar");
|
|
const hasLoadError = ref(false);
|
|
const size3 = computed(() => {
|
|
var _a;
|
|
return (_a = props2.size) != null ? _a : avatarGroupContext == null ? void 0 : avatarGroupContext.size;
|
|
});
|
|
const shape = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = props2.shape) != null ? _a : avatarGroupContext == null ? void 0 : avatarGroupContext.shape) != null ? _b : "circle";
|
|
});
|
|
const avatarClass = computed(() => {
|
|
const { icon } = props2;
|
|
const classList = [ns.b()];
|
|
if (isString(size3.value))
|
|
classList.push(ns.m(size3.value));
|
|
if (icon)
|
|
classList.push(ns.m("icon"));
|
|
if (shape.value)
|
|
classList.push(ns.m(shape.value));
|
|
return classList;
|
|
});
|
|
const sizeStyle = computed(() => {
|
|
return isNumber2(size3.value) ? ns.cssVarBlock({ size: addUnit(size3.value) }) : void 0;
|
|
});
|
|
const fitStyle = computed(() => ({ objectFit: props2.fit }));
|
|
watch(() => [props2.src, props2.srcSet], () => hasLoadError.value = false);
|
|
function handleError(e) {
|
|
hasLoadError.value = true;
|
|
emit("error", e);
|
|
}
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("span", {
|
|
class: normalizeClass(avatarClass.value),
|
|
style: normalizeStyle(sizeStyle.value)
|
|
}, [(__props.src || __props.srcSet) && !hasLoadError.value ? (openBlock(), createElementBlock("img", {
|
|
key: 0,
|
|
src: __props.src,
|
|
alt: __props.alt,
|
|
srcset: __props.srcSet,
|
|
style: normalizeStyle(fitStyle.value),
|
|
onError: handleError
|
|
}, null, 44, _hoisted_16)) : __props.icon ? (openBlock(), createBlock(unref(ElIcon), { key: 1 }, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.icon)))]),
|
|
_: 1
|
|
})) : renderSlot(_ctx.$slots, "default", { key: 2 })], 6);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/avatar/src/avatar2.mjs
|
|
var avatar_default = avatar_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/avatar/src/avatar-group.mjs
|
|
var avatar_group_default = defineComponent({
|
|
name: "ElAvatarGroup",
|
|
props: avatarGroupProps,
|
|
setup(props2, { slots }) {
|
|
const ns = useNamespace("avatar-group");
|
|
provide(avatarGroupContextKey, reactive({
|
|
size: toRef(props2, "size"),
|
|
shape: toRef(props2, "shape")
|
|
}));
|
|
return () => {
|
|
var _a, _b;
|
|
const avatars = flattedChildren((_b = (_a = slots.default) == null ? void 0 : _a.call(slots)) != null ? _b : []);
|
|
let visibleAvatars = avatars;
|
|
if (props2.collapseAvatars && avatars.length > props2.maxCollapseAvatars) {
|
|
visibleAvatars = avatars.slice(0, props2.maxCollapseAvatars);
|
|
const hiddenAvatars = avatars.slice(props2.maxCollapseAvatars);
|
|
visibleAvatars.push(createVNode(ElTooltip, {
|
|
"popperClass": props2.popperClass,
|
|
"popperStyle": props2.popperStyle,
|
|
"placement": props2.placement,
|
|
"effect": props2.effect,
|
|
"disabled": !props2.collapseAvatarsTooltip
|
|
}, {
|
|
default: () => createVNode(avatar_default, {
|
|
"size": props2.size,
|
|
"shape": props2.shape,
|
|
"class": props2.collapseClass,
|
|
"style": props2.collapseStyle
|
|
}, { default: () => [createTextVNode("+ "), hiddenAvatars.length] }),
|
|
content: () => createVNode("div", { "class": ns.e("collapse-avatars") }, [hiddenAvatars.map((node, idx) => {
|
|
var _a2;
|
|
return isVNode(node) ? cloneVNode(node, { key: (_a2 = node.key) != null ? _a2 : idx }) : node;
|
|
})])
|
|
}));
|
|
}
|
|
return createVNode("div", { "class": ns.b() }, [visibleAvatars]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/avatar/index.mjs
|
|
var ElAvatar = withInstall(avatar_default, { AvatarGroup: avatar_group_default });
|
|
var ElAvatarGroup = withNoopInstall(avatar_group_default);
|
|
|
|
// 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 _a;
|
|
(_a = el.value) == null ? void 0 : _a.scrollTo({
|
|
top: 0,
|
|
behavior: "smooth"
|
|
});
|
|
emit("click", event);
|
|
};
|
|
useEventListener(container, "scroll", useThrottleFn(handleScroll2, 300, true));
|
|
onMounted(() => {
|
|
var _a;
|
|
container.value = document;
|
|
el.value = document.documentElement;
|
|
if (props2.target) {
|
|
el.value = (_a = document.querySelector(props2.target)) != null ? _a : 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/backtop.vue_vue_type_script_setup_true_lang.mjs
|
|
var COMPONENT_NAME8 = "ElBacktop";
|
|
var backtop_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: COMPONENT_NAME8,
|
|
__name: "backtop",
|
|
props: backtopProps,
|
|
emits: backtopEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const ns = useNamespace("backtop");
|
|
const { handleClick, visible } = useBackTop(props2, emit, COMPONENT_NAME8);
|
|
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(backTopStyle.value),
|
|
class: normalizeClass(unref(ns).b()),
|
|
onClick: _cache[0] || (_cache[0] = withModifiers((...args) => unref(handleClick) && unref(handleClick)(...args), ["stop"]))
|
|
}, [renderSlot(_ctx.$slots, "default", {}, () => [createVNode(unref(ElIcon), { class: normalizeClass(unref(ns).e("icon")) }, {
|
|
default: withCtx(() => [createVNode(unref(caret_top_default))]),
|
|
_: 1
|
|
}, 8, ["class"])])], 6)) : createCommentVNode("v-if", true)]),
|
|
_: 3
|
|
}, 8, ["name"]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/backtop/src/backtop2.mjs
|
|
var backtop_default = backtop_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/backtop/index.mjs
|
|
var ElBacktop = withInstall(backtop_default);
|
|
|
|
// 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/badge.vue_vue_type_script_setup_true_lang.mjs
|
|
var badge_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElBadge",
|
|
__name: "badge",
|
|
props: badgeProps,
|
|
setup(__props, { expose: __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 _a;
|
|
return [{
|
|
backgroundColor: props2.color,
|
|
marginRight: addUnit(-props2.offset[0]),
|
|
marginTop: addUnit(props2.offset[1])
|
|
}, (_a = props2.badgeStyle) != null ? _a : {}];
|
|
});
|
|
__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` }, {
|
|
default: withCtx(() => [!__props.hidden && (content.value || __props.isDot || _ctx.$slots.content) ? (openBlock(), createElementBlock("sup", {
|
|
key: 0,
|
|
class: normalizeClass([
|
|
unref(ns).e("content"),
|
|
unref(ns).em("content", __props.type),
|
|
unref(ns).is("fixed", !!_ctx.$slots.default),
|
|
unref(ns).is("dot", __props.isDot),
|
|
unref(ns).is("hide-zero", !__props.showZero && __props.value === 0),
|
|
__props.badgeClass
|
|
]),
|
|
style: normalizeStyle(style.value)
|
|
}, [renderSlot(_ctx.$slots, "content", { value: content.value }, () => [createTextVNode(toDisplayString(content.value), 1)])], 6)) : createCommentVNode("v-if", true)]),
|
|
_: 3
|
|
}, 8, ["name"])], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/badge/src/badge2.mjs
|
|
var badge_default = badge_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/badge/index.mjs
|
|
var ElBadge = withInstall(badge_default);
|
|
|
|
// 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/constants.mjs
|
|
var breadcrumbKey = Symbol("breadcrumbKey");
|
|
|
|
// 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/breadcrumb.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_17 = ["aria-label"];
|
|
var breadcrumb_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElBreadcrumb",
|
|
__name: "breadcrumb",
|
|
props: breadcrumbProps,
|
|
setup(__props) {
|
|
const { t } = useLocale();
|
|
const props2 = __props;
|
|
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, _hoisted_17);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/breadcrumb/src/breadcrumb2.mjs
|
|
var breadcrumb_default = breadcrumb_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/breadcrumb/src/breadcrumb-item.vue_vue_type_script_setup_true_lang.mjs
|
|
var breadcrumb_item_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElBreadcrumbItem",
|
|
__name: "breadcrumb-item",
|
|
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 onClick = () => {
|
|
if (!props2.to || !router)
|
|
return;
|
|
props2.replace ? router.replace(props2.to) : router.push(props2.to);
|
|
};
|
|
return (_ctx, _cache) => {
|
|
var _a, _b;
|
|
return openBlock(), createElementBlock("span", { class: normalizeClass(unref(ns).e("item")) }, [createBaseVNode("span", {
|
|
class: normalizeClass([unref(ns).e("inner"), unref(ns).is("link", !!__props.to)]),
|
|
role: "link",
|
|
onClick
|
|
}, [renderSlot(_ctx.$slots, "default")], 2), ((_a = unref(breadcrumbContext)) == null ? void 0 : _a.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);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/breadcrumb/src/breadcrumb-item2.mjs
|
|
var breadcrumb_item_default = breadcrumb_item_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/breadcrumb/index.mjs
|
|
var ElBreadcrumb = withInstall(breadcrumb_default, { BreadcrumbItem: breadcrumb_item_default });
|
|
var ElBreadcrumbItem = withNoopInstall(breadcrumb_item_default);
|
|
|
|
// 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: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
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: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
link: Boolean,
|
|
bg: Boolean,
|
|
autofocus: Boolean,
|
|
round: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
circle: Boolean,
|
|
dashed: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
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/config-provider/src/constants.mjs
|
|
var configProviderContextKey = Symbol();
|
|
|
|
// 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 _a, _b;
|
|
return (_b = (_a = config.value) == null ? void 0 : _a[key]) != null ? _b : defaultValue;
|
|
});
|
|
else
|
|
return config;
|
|
}
|
|
function useGlobalComponentSettings(block, sizeFallback) {
|
|
const config = useGlobalConfig();
|
|
const ns = useNamespace(block, computed(() => {
|
|
var _a;
|
|
return ((_a = config.value) == null ? void 0 : _a.namespace) || defaultNamespace;
|
|
}));
|
|
const locale = useLocale(computed(() => {
|
|
var _a;
|
|
return (_a = config.value) == null ? void 0 : _a.locale;
|
|
}));
|
|
const zIndex2 = useZIndex(computed(() => {
|
|
var _a;
|
|
return ((_a = config.value) == null ? void 0 : _a.zIndex) || defaultInitialZIndex;
|
|
}));
|
|
const size3 = computed(() => {
|
|
var _a;
|
|
return unref(sizeFallback) || ((_a = config.value) == null ? void 0 : _a.size) || "";
|
|
});
|
|
provideGlobalConfig(computed(() => unref(config) || {}));
|
|
return {
|
|
ns,
|
|
locale,
|
|
zIndex: zIndex2,
|
|
size: size3
|
|
};
|
|
}
|
|
var provideGlobalConfig = (config, app, global2 = false) => {
|
|
var _a;
|
|
const inSetup = !!getCurrentInstance();
|
|
const oldConfig = inSetup ? useGlobalConfig() : void 0;
|
|
const provideFn = (_a = app == null ? void 0 : app.provide) != null ? _a : 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 = [.../* @__PURE__ */ 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/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) },
|
|
card: { type: definePropType(Object) },
|
|
dialog: { 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"
|
|
},
|
|
table: { type: definePropType(Object) },
|
|
...useEmptyValuesProps
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/config-provider/src/config-provider.mjs
|
|
var messageConfig = { placement: "top" };
|
|
var ConfigProvider = defineComponent({
|
|
name: "ElConfigProvider",
|
|
props: configProviderProps,
|
|
setup(props2, { slots }) {
|
|
const config = provideGlobalConfig(props2);
|
|
watch(() => props2.message, (val) => {
|
|
var _a, _b;
|
|
Object.assign(messageConfig, (_b = (_a = config == null ? void 0 : config.value) == null ? void 0 : _a.message) != null ? _b : {}, val != null ? val : {});
|
|
}, {
|
|
immediate: true,
|
|
deep: true
|
|
});
|
|
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/button/src/constants.mjs
|
|
var buttonGroupContextKey = Symbol("buttonGroupContextKey");
|
|
|
|
// 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 _a;
|
|
return props2.type || (buttonGroupContext == null ? void 0 : buttonGroupContext.type) || ((_a = globalConfig2.value) == null ? void 0 : _a.type) || "";
|
|
});
|
|
const autoInsertSpace = computed(() => {
|
|
var _a, _b, _c;
|
|
return (_c = (_b = props2.autoInsertSpace) != null ? _b : (_a = globalConfig2.value) == null ? void 0 : _a.autoInsertSpace) != null ? _c : false;
|
|
});
|
|
const _plain = computed(() => {
|
|
var _a, _b, _c;
|
|
return (_c = (_b = props2.plain) != null ? _b : (_a = globalConfig2.value) == null ? void 0 : _a.plain) != null ? _c : false;
|
|
});
|
|
const _round = computed(() => {
|
|
var _a, _b, _c;
|
|
return (_c = (_b = props2.round) != null ? _b : (_a = globalConfig2.value) == null ? void 0 : _a.round) != null ? _c : false;
|
|
});
|
|
const _text = computed(() => {
|
|
var _a, _b, _c;
|
|
return (_c = (_b = props2.text) != null ? _b : (_a = globalConfig2.value) == null ? void 0 : _a.text) != null ? _c : false;
|
|
});
|
|
const _dashed = computed(() => {
|
|
var _a, _b, _c;
|
|
return (_c = (_b = props2.dashed) != null ? _b : (_a = globalConfig2.value) == null ? void 0 : _a.dashed) != 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 _a;
|
|
const defaultSlot = (_a = slots.default) == null ? void 0 : _a.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,
|
|
_text,
|
|
_dashed,
|
|
shouldAddSpace,
|
|
handleClick
|
|
};
|
|
};
|
|
|
|
// node_modules/@ctrl/tinycolor/dist/module/util.js
|
|
function bound01(n, max4) {
|
|
if (isOnePointZero(n)) {
|
|
n = "100%";
|
|
}
|
|
const 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 (Number(n) <= 1) {
|
|
return `${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);
|
|
const max4 = Math.max(r, g, b2);
|
|
const min4 = Math.min(r, g, b2);
|
|
let h3 = 0;
|
|
let s2 = 0;
|
|
const l2 = (max4 + min4) / 2;
|
|
if (max4 === min4) {
|
|
s2 = 0;
|
|
h3 = 0;
|
|
} else {
|
|
const 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, q, t) {
|
|
if (t < 0) {
|
|
t += 1;
|
|
}
|
|
if (t > 1) {
|
|
t -= 1;
|
|
}
|
|
if (t < 1 / 6) {
|
|
return p2 + (q - p2) * (6 * t);
|
|
}
|
|
if (t < 1 / 2) {
|
|
return q;
|
|
}
|
|
if (t < 2 / 3) {
|
|
return p2 + (q - p2) * (2 / 3 - t) * 6;
|
|
}
|
|
return p2;
|
|
}
|
|
function hslToRgb(h3, s2, l2) {
|
|
let r;
|
|
let g;
|
|
let b2;
|
|
h3 = bound01(h3, 360);
|
|
s2 = bound01(s2, 100);
|
|
l2 = bound01(l2, 100);
|
|
if (s2 === 0) {
|
|
g = l2;
|
|
b2 = l2;
|
|
r = l2;
|
|
} else {
|
|
const q = l2 < 0.5 ? l2 * (1 + s2) : l2 + s2 - l2 * s2;
|
|
const p2 = 2 * l2 - q;
|
|
r = hue2rgb(p2, q, h3 + 1 / 3);
|
|
g = hue2rgb(p2, q, h3);
|
|
b2 = hue2rgb(p2, q, 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);
|
|
const max4 = Math.max(r, g, b2);
|
|
const min4 = Math.min(r, g, b2);
|
|
let h3 = 0;
|
|
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;
|
|
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);
|
|
const i = Math.floor(h3);
|
|
const f2 = h3 - i;
|
|
const p2 = v2 * (1 - s2);
|
|
const q = v2 * (1 - f2 * s2);
|
|
const t = v2 * (1 - (1 - f2) * s2);
|
|
const mod = i % 6;
|
|
const r = [v2, q, p2, p2, t, v2][mod];
|
|
const g = [t, v2, v2, q, p2, p2][mod];
|
|
const b2 = [p2, p2, t, v2, v2, q][mod];
|
|
return { r: r * 255, g: g * 255, b: b2 * 255 };
|
|
}
|
|
function rgbToHex(r, g, b2, allow3Char) {
|
|
const 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) {
|
|
const 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 cmykToRgb(c2, m2, y, k) {
|
|
const cConv = c2 / 100;
|
|
const mConv = m2 / 100;
|
|
const yConv = y / 100;
|
|
const kConv = k / 100;
|
|
const r = 255 * (1 - cConv) * (1 - kConv);
|
|
const g = 255 * (1 - mConv) * (1 - kConv);
|
|
const b2 = 255 * (1 - yConv) * (1 - kConv);
|
|
return { r, g, b: b2 };
|
|
}
|
|
function rgbToCmyk(r, g, b2) {
|
|
let c2 = 1 - r / 255;
|
|
let m2 = 1 - g / 255;
|
|
let y = 1 - b2 / 255;
|
|
let k = Math.min(c2, m2, y);
|
|
if (k === 1) {
|
|
c2 = 0;
|
|
m2 = 0;
|
|
y = 0;
|
|
} else {
|
|
c2 = (c2 - k) / (1 - k) * 100;
|
|
m2 = (m2 - k) / (1 - k) * 100;
|
|
y = (y - k) / (1 - k) * 100;
|
|
}
|
|
k *= 100;
|
|
return {
|
|
c: Math.round(c2),
|
|
m: Math.round(m2),
|
|
y: Math.round(y),
|
|
k: Math.round(k)
|
|
};
|
|
}
|
|
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) {
|
|
let rgb = { r: 0, g: 0, b: 0 };
|
|
let a2 = 1;
|
|
let s2 = null;
|
|
let v2 = null;
|
|
let l2 = null;
|
|
let ok = false;
|
|
let 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";
|
|
} else if (isValidCSSUnit(color.c) && isValidCSSUnit(color.m) && isValidCSSUnit(color.y) && isValidCSSUnit(color.k)) {
|
|
rgb = cmykToRgb(color.c, color.m, color.y, color.k);
|
|
ok = true;
|
|
format2 = "cmyk";
|
|
}
|
|
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 = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")";
|
|
var PERMISSIVE_MATCH3 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
|
|
var PERMISSIVE_MATCH4 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + 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),
|
|
cmyk: new RegExp("cmyk" + 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;
|
|
}
|
|
let 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" };
|
|
}
|
|
let 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.cmyk.exec(color);
|
|
if (match) {
|
|
return {
|
|
c: match[1],
|
|
m: match[2],
|
|
y: match[3],
|
|
k: 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) {
|
|
if (typeof color === "number") {
|
|
return !Number.isNaN(color);
|
|
}
|
|
return matchers.CSS_UNIT.test(color);
|
|
}
|
|
|
|
// node_modules/@ctrl/tinycolor/dist/module/index.js
|
|
var TinyColor = class {
|
|
constructor(color = "", opts = {}) {
|
|
var _a;
|
|
if (color instanceof TinyColor) {
|
|
return color;
|
|
}
|
|
if (typeof color === "number") {
|
|
color = numberInputToObject(color);
|
|
}
|
|
this.originalInput = color;
|
|
const 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 = (_a = opts.format) != null ? _a : 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;
|
|
}
|
|
isDark() {
|
|
return this.getBrightness() < 128;
|
|
}
|
|
isLight() {
|
|
return !this.isDark();
|
|
}
|
|
getBrightness() {
|
|
const rgb = this.toRgb();
|
|
return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1e3;
|
|
}
|
|
getLuminance() {
|
|
const rgb = this.toRgb();
|
|
let R2;
|
|
let G2;
|
|
let B2;
|
|
const RsRGB = rgb.r / 255;
|
|
const GsRGB = rgb.g / 255;
|
|
const 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;
|
|
}
|
|
getAlpha() {
|
|
return this.a;
|
|
}
|
|
setAlpha(alpha) {
|
|
this.a = boundAlpha(alpha);
|
|
this.roundA = Math.round(100 * this.a) / 100;
|
|
return this;
|
|
}
|
|
isMonochrome() {
|
|
const { s: s2 } = this.toHsl();
|
|
return s2 === 0;
|
|
}
|
|
toHsv() {
|
|
const hsv = rgbToHsv(this.r, this.g, this.b);
|
|
return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this.a };
|
|
}
|
|
toHsvString() {
|
|
const hsv = rgbToHsv(this.r, this.g, this.b);
|
|
const h3 = Math.round(hsv.h * 360);
|
|
const s2 = Math.round(hsv.s * 100);
|
|
const v2 = Math.round(hsv.v * 100);
|
|
return this.a === 1 ? `hsv(${h3}, ${s2}%, ${v2}%)` : `hsva(${h3}, ${s2}%, ${v2}%, ${this.roundA})`;
|
|
}
|
|
toHsl() {
|
|
const hsl = rgbToHsl(this.r, this.g, this.b);
|
|
return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this.a };
|
|
}
|
|
toHslString() {
|
|
const hsl = rgbToHsl(this.r, this.g, this.b);
|
|
const h3 = Math.round(hsl.h * 360);
|
|
const s2 = Math.round(hsl.s * 100);
|
|
const l2 = Math.round(hsl.l * 100);
|
|
return this.a === 1 ? `hsl(${h3}, ${s2}%, ${l2}%)` : `hsla(${h3}, ${s2}%, ${l2}%, ${this.roundA})`;
|
|
}
|
|
toHex(allow3Char = false) {
|
|
return rgbToHex(this.r, this.g, this.b, allow3Char);
|
|
}
|
|
toHexString(allow3Char = false) {
|
|
return "#" + this.toHex(allow3Char);
|
|
}
|
|
toHex8(allow4Char = false) {
|
|
return rgbaToHex(this.r, this.g, this.b, this.a, allow4Char);
|
|
}
|
|
toHex8String(allow4Char = false) {
|
|
return "#" + this.toHex8(allow4Char);
|
|
}
|
|
toHexShortString(allowShortChar = false) {
|
|
return this.a === 1 ? this.toHexString(allowShortChar) : this.toHex8String(allowShortChar);
|
|
}
|
|
toRgb() {
|
|
return {
|
|
r: Math.round(this.r),
|
|
g: Math.round(this.g),
|
|
b: Math.round(this.b),
|
|
a: this.a
|
|
};
|
|
}
|
|
toRgbString() {
|
|
const r = Math.round(this.r);
|
|
const g = Math.round(this.g);
|
|
const b2 = Math.round(this.b);
|
|
return this.a === 1 ? `rgb(${r}, ${g}, ${b2})` : `rgba(${r}, ${g}, ${b2}, ${this.roundA})`;
|
|
}
|
|
toPercentageRgb() {
|
|
const fmt = (x2) => `${Math.round(bound01(x2, 255) * 100)}%`;
|
|
return {
|
|
r: fmt(this.r),
|
|
g: fmt(this.g),
|
|
b: fmt(this.b),
|
|
a: this.a
|
|
};
|
|
}
|
|
toPercentageRgbString() {
|
|
const rnd = (x2) => Math.round(bound01(x2, 255) * 100);
|
|
return this.a === 1 ? `rgb(${rnd(this.r)}%, ${rnd(this.g)}%, ${rnd(this.b)}%)` : `rgba(${rnd(this.r)}%, ${rnd(this.g)}%, ${rnd(this.b)}%, ${this.roundA})`;
|
|
}
|
|
toCmyk() {
|
|
return {
|
|
...rgbToCmyk(this.r, this.g, this.b)
|
|
};
|
|
}
|
|
toCmykString() {
|
|
const { c: c2, m: m2, y, k } = rgbToCmyk(this.r, this.g, this.b);
|
|
return `cmyk(${c2}, ${m2}, ${y}, ${k})`;
|
|
}
|
|
toName() {
|
|
if (this.a === 0) {
|
|
return "transparent";
|
|
}
|
|
if (this.a < 1) {
|
|
return false;
|
|
}
|
|
const hex2 = "#" + rgbToHex(this.r, this.g, this.b, false);
|
|
for (const [key, value] of Object.entries(names)) {
|
|
if (hex2 === value) {
|
|
return key;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
toString(format2) {
|
|
const formatSet = Boolean(format2);
|
|
format2 = format2 != null ? format2 : this.format;
|
|
let formattedString = false;
|
|
const hasAlpha = this.a < 1 && this.a >= 0;
|
|
const 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();
|
|
}
|
|
if (format2 === "cmyk") {
|
|
formattedString = this.toCmykString();
|
|
}
|
|
return formattedString || this.toHexString();
|
|
}
|
|
toNumber() {
|
|
return (Math.round(this.r) << 16) + (Math.round(this.g) << 8) + Math.round(this.b);
|
|
}
|
|
clone() {
|
|
return new TinyColor(this.toString());
|
|
}
|
|
lighten(amount = 10) {
|
|
const hsl = this.toHsl();
|
|
hsl.l += amount / 100;
|
|
hsl.l = clamp01(hsl.l);
|
|
return new TinyColor(hsl);
|
|
}
|
|
brighten(amount = 10) {
|
|
const 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 TinyColor(rgb);
|
|
}
|
|
darken(amount = 10) {
|
|
const hsl = this.toHsl();
|
|
hsl.l -= amount / 100;
|
|
hsl.l = clamp01(hsl.l);
|
|
return new TinyColor(hsl);
|
|
}
|
|
tint(amount = 10) {
|
|
return this.mix("white", amount);
|
|
}
|
|
shade(amount = 10) {
|
|
return this.mix("black", amount);
|
|
}
|
|
desaturate(amount = 10) {
|
|
const hsl = this.toHsl();
|
|
hsl.s -= amount / 100;
|
|
hsl.s = clamp01(hsl.s);
|
|
return new TinyColor(hsl);
|
|
}
|
|
saturate(amount = 10) {
|
|
const hsl = this.toHsl();
|
|
hsl.s += amount / 100;
|
|
hsl.s = clamp01(hsl.s);
|
|
return new TinyColor(hsl);
|
|
}
|
|
greyscale() {
|
|
return this.desaturate(100);
|
|
}
|
|
spin(amount) {
|
|
const hsl = this.toHsl();
|
|
const hue = (hsl.h + amount) % 360;
|
|
hsl.h = hue < 0 ? 360 + hue : hue;
|
|
return new TinyColor(hsl);
|
|
}
|
|
mix(color, amount = 50) {
|
|
const rgb1 = this.toRgb();
|
|
const rgb2 = new TinyColor(color).toRgb();
|
|
const p2 = amount / 100;
|
|
const 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 TinyColor(rgba);
|
|
}
|
|
analogous(results = 6, slices = 30) {
|
|
const hsl = this.toHsl();
|
|
const part = 360 / slices;
|
|
const ret = [this];
|
|
for (hsl.h = (hsl.h - (part * results >> 1) + 720) % 360; --results; ) {
|
|
hsl.h = (hsl.h + part) % 360;
|
|
ret.push(new TinyColor(hsl));
|
|
}
|
|
return ret;
|
|
}
|
|
complement() {
|
|
const hsl = this.toHsl();
|
|
hsl.h = (hsl.h + 180) % 360;
|
|
return new TinyColor(hsl);
|
|
}
|
|
monochromatic(results = 6) {
|
|
const hsv = this.toHsv();
|
|
const { h: h3 } = hsv;
|
|
const { s: s2 } = hsv;
|
|
let { v: v2 } = hsv;
|
|
const res = [];
|
|
const modification = 1 / results;
|
|
while (results--) {
|
|
res.push(new TinyColor({ h: h3, s: s2, v: v2 }));
|
|
v2 = (v2 + modification) % 1;
|
|
}
|
|
return res;
|
|
}
|
|
splitcomplement() {
|
|
const hsl = this.toHsl();
|
|
const { h: h3 } = hsl;
|
|
return [
|
|
this,
|
|
new TinyColor({ h: (h3 + 72) % 360, s: hsl.s, l: hsl.l }),
|
|
new TinyColor({ h: (h3 + 216) % 360, s: hsl.s, l: hsl.l })
|
|
];
|
|
}
|
|
onBackground(background) {
|
|
const fg = this.toRgb();
|
|
const bg = new TinyColor(background).toRgb();
|
|
const alpha = fg.a + bg.a * (1 - fg.a);
|
|
return new TinyColor({
|
|
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
|
|
});
|
|
}
|
|
triad() {
|
|
return this.polyad(3);
|
|
}
|
|
tetrad() {
|
|
return this.polyad(4);
|
|
}
|
|
polyad(n) {
|
|
const hsl = this.toHsl();
|
|
const { h: h3 } = hsl;
|
|
const result2 = [this];
|
|
const increment = 360 / n;
|
|
for (let i = 1; i < n; i++) {
|
|
result2.push(new TinyColor({ h: (h3 + i * increment) % 360, s: hsl.s, l: hsl.l }));
|
|
}
|
|
return result2;
|
|
}
|
|
equals(color) {
|
|
const comparedColor = new TinyColor(color);
|
|
if (this.format === "cmyk" || comparedColor.format === "cmyk") {
|
|
return this.toCmykString() === comparedColor.toCmykString();
|
|
}
|
|
return this.toRgbString() === comparedColor.toRgbString();
|
|
}
|
|
};
|
|
|
|
// 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 if (props2.link || props2.text) {
|
|
const hoverColor = props2.dark ? darken(color, 30) : color.tint(30).toString();
|
|
styles = ns.cssVarBlock({
|
|
"text-color": buttonColor,
|
|
"hover-text-color": hoverColor,
|
|
"active-text-color": activeBgColor
|
|
});
|
|
if (props2.link) {
|
|
styles[ns.cssVarBlockName("hover-link-text-color")] = hoverColor;
|
|
styles[ns.cssVarBlockName("active-color")] = activeBgColor;
|
|
}
|
|
if (_disabled.value) {
|
|
const disabledColor = props2.dark ? darken(color, 50) : color.tint(50).toString();
|
|
styles[ns.cssVarBlockName("disabled-bg-color")] = "transparent";
|
|
styles[ns.cssVarBlockName("disabled-text-color")] = disabledColor;
|
|
styles[ns.cssVarBlockName("disabled-border-color")] = "transparent";
|
|
}
|
|
} 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/button.vue_vue_type_script_setup_true_lang.mjs
|
|
var button_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElButton",
|
|
__name: "button",
|
|
props: buttonProps,
|
|
emits: buttonEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const buttonStyle = useButtonCustomStyle(props2);
|
|
const ns = useNamespace("button");
|
|
const { _ref, _size, _type, _disabled, _props, _plain, _round, _text, _dashed, 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", _text.value),
|
|
ns.is("dashed", _dashed.value),
|
|
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(__props.tag), mergeProps({
|
|
ref_key: "_ref",
|
|
ref: _ref
|
|
}, unref(_props), {
|
|
class: buttonKls.value,
|
|
style: unref(buttonStyle),
|
|
onClick: unref(handleClick)
|
|
}), {
|
|
default: withCtx(() => [__props.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(__props.loadingIcon)))]),
|
|
_: 1
|
|
}, 8, ["class"]))], 64)) : __props.icon || _ctx.$slots.icon ? (openBlock(), createBlock(unref(ElIcon), { key: 1 }, {
|
|
default: withCtx(() => [__props.icon ? (openBlock(), createBlock(resolveDynamicComponent(__props.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"
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/button/src/button2.mjs
|
|
var button_default = button_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/button/src/button-group.mjs
|
|
var buttonGroupProps = {
|
|
size: buttonProps.size,
|
|
type: buttonProps.type,
|
|
direction: {
|
|
type: definePropType(String),
|
|
values: ["horizontal", "vertical"],
|
|
default: "horizontal"
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/button/src/button-group.vue_vue_type_script_setup_true_lang.mjs
|
|
var button_group_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElButtonGroup",
|
|
__name: "button-group",
|
|
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"), unref(ns).bm("group", props2.direction)]) }, [renderSlot(_ctx.$slots, "default")], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/button/src/button-group2.mjs
|
|
var button_group_default = button_group_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/button/index.mjs
|
|
var ElButton = withInstall(button_default, { ButtonGroup: button_group_default });
|
|
var ElButtonGroup = withNoopInstall(button_group_default);
|
|
|
|
// 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
|
|
},
|
|
controllerType: {
|
|
type: String,
|
|
values: ["button", "select"],
|
|
default: "button"
|
|
},
|
|
formatter: { type: definePropType(Function) }
|
|
});
|
|
var calendarEmits = {
|
|
[UPDATE_MODEL_EVENT]: (value) => isDate(value),
|
|
[INPUT_EVENT]: (value) => isDate(value)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/constants.mjs
|
|
var timeUnits = [
|
|
"hours",
|
|
"minutes",
|
|
"seconds"
|
|
];
|
|
var PICKER_BASE_INJECTION_KEY = "EP_PICKER_BASE";
|
|
var PICKER_POPPER_OPTIONS_INJECTION_KEY = "ElPopperOptions";
|
|
var ROOT_COMMON_PICKER_INJECTION_KEY = Symbol("commonPickerContextKey");
|
|
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/utils.mjs
|
|
var import_dayjs = __toESM(require_dayjs_min(), 1);
|
|
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 _a;
|
|
const arr = [];
|
|
const disabledArr = method5 == null ? void 0 : method5();
|
|
for (let i = 0; i < total2; i++)
|
|
arr.push((_a = disabledArr == null ? void 0 : disabledArr.includes(i)) != null ? _a : false);
|
|
return arr;
|
|
};
|
|
var dayOrDaysToDate = (dayOrDays) => {
|
|
return isArray(dayOrDays) ? dayOrDays.map((d2) => d2.toDate()) : dayOrDays.toDate();
|
|
};
|
|
|
|
// 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({
|
|
automaticDropdown: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
id: { type: definePropType([Array, String]) },
|
|
name: { type: definePropType([Array, String]) },
|
|
popperClass: useTooltipContentProps.popperClass,
|
|
popperStyle: useTooltipContentProps.popperStyle,
|
|
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
|
|
},
|
|
saveOnBlur: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
prefixIcon: {
|
|
type: definePropType([String, Object]),
|
|
default: ""
|
|
},
|
|
size: useSizeProp,
|
|
readonly: Boolean,
|
|
disabled: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
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
|
|
},
|
|
showConfirm: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
showFooter: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
showWeekNumber: Boolean
|
|
});
|
|
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/composables/use-common-picker.mjs
|
|
var useCommonPicker = (props2, emit) => {
|
|
const { lang } = useLocale();
|
|
const pickerVisible = ref(false);
|
|
const pickerActualVisible = ref(false);
|
|
const userInput = ref(null);
|
|
const valueIsEmpty = computed(() => {
|
|
const { modelValue } = props2;
|
|
return !modelValue || isArray(modelValue) && !modelValue.filter(Boolean).length;
|
|
});
|
|
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 parsedValue = computed(() => {
|
|
var _a;
|
|
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((_a = props2.modelValue) != null ? _a : "", 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 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 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);
|
|
};
|
|
return {
|
|
parsedValue,
|
|
pickerActualVisible,
|
|
pickerOptions,
|
|
pickerVisible,
|
|
userInput,
|
|
valueIsEmpty,
|
|
emitInput,
|
|
onCalendarChange,
|
|
onPanelChange,
|
|
onPick,
|
|
onSetPickerOption
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/common/picker-range-trigger.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_18 = [
|
|
"id",
|
|
"name",
|
|
"placeholder",
|
|
"value",
|
|
"disabled"
|
|
];
|
|
var _hoisted_24 = [
|
|
"id",
|
|
"name",
|
|
"placeholder",
|
|
"value",
|
|
"disabled"
|
|
];
|
|
var picker_range_trigger_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "PickerRangeTrigger",
|
|
inheritAttrs: false,
|
|
__name: "picker-range-trigger",
|
|
props: timePickerRangeTriggerProps,
|
|
emits: [
|
|
"mouseenter",
|
|
"mouseleave",
|
|
"click",
|
|
"touchstart",
|
|
"focus",
|
|
"blur",
|
|
"startInput",
|
|
"endInput",
|
|
"startChange",
|
|
"endChange"
|
|
],
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const { formItem } = useFormItem();
|
|
const { inputId } = useFormItemInputId(reactive({ id: computed(() => {
|
|
var _a;
|
|
return (_a = props2.id) == null ? void 0 : _a[0];
|
|
}) }), { formItemContext: formItem });
|
|
const attrs = useAttrs2();
|
|
const nsDate = useNamespace("date");
|
|
const nsRange = useNamespace("range");
|
|
const inputRef = ref();
|
|
const endInputRef = ref();
|
|
const { wrapperRef, isFocused } = useFocusController(inputRef, { disabled: computed(() => props2.disabled) });
|
|
const handleClick = (evt) => {
|
|
emit("click", evt);
|
|
};
|
|
const handleMouseEnter = (evt) => {
|
|
emit("mouseenter", evt);
|
|
};
|
|
const handleMouseLeave = (evt) => {
|
|
emit("mouseleave", evt);
|
|
};
|
|
const handleTouchStart = (evt) => {
|
|
emit("touchstart", 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 _a;
|
|
(_a = inputRef.value) == null ? void 0 : _a.focus();
|
|
};
|
|
const blur = () => {
|
|
var _a, _b;
|
|
(_a = inputRef.value) == null ? void 0 : _a.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: unref(inputId),
|
|
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, _hoisted_18),
|
|
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, _hoisted_24),
|
|
renderSlot(_ctx.$slots, "suffix")
|
|
], 38);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/common/picker-range-trigger.mjs
|
|
var picker_range_trigger_default = picker_range_trigger_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/common/picker.vue_vue_type_script_setup_true_lang.mjs
|
|
var picker_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "Picker",
|
|
__name: "picker",
|
|
props: timePickerDefaultProps,
|
|
emits: [
|
|
UPDATE_MODEL_EVENT,
|
|
CHANGE_EVENT,
|
|
"focus",
|
|
"blur",
|
|
"clear",
|
|
"calendar-change",
|
|
"panel-change",
|
|
"visible-change",
|
|
"keydown"
|
|
],
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const attrs = useAttrs();
|
|
const nsDate = useNamespace("date");
|
|
const nsInput = useNamespace("input");
|
|
const nsRange = useNamespace("range");
|
|
const { formItem } = useFormItem();
|
|
const elPopperOptions = inject(PICKER_POPPER_OPTIONS_INJECTION_KEY, {});
|
|
const emptyValues = useEmptyValues(props2, null);
|
|
const refPopper = ref();
|
|
const inputRef = ref();
|
|
const valueOnOpen = ref(null);
|
|
let hasJustTabExitedInput = false;
|
|
const pickerDisabled = useFormDisabled();
|
|
const commonPicker = useCommonPicker(props2, emit);
|
|
const { parsedValue, pickerActualVisible, userInput, pickerVisible, pickerOptions, valueIsEmpty, emitInput, onPick, onSetPickerOption, onCalendarChange, onPanelChange } = commonPicker;
|
|
const { isFocused, handleFocus, handleBlur } = useFocusController(inputRef, {
|
|
disabled: pickerDisabled,
|
|
beforeFocus() {
|
|
return props2.readonly;
|
|
},
|
|
afterFocus() {
|
|
if (!props2.automaticDropdown)
|
|
return;
|
|
pickerVisible.value = true;
|
|
},
|
|
beforeBlur(event) {
|
|
var _a;
|
|
return !hasJustTabExitedInput && ((_a = refPopper.value) == null ? void 0 : _a.isFocusInsideContent(event));
|
|
},
|
|
afterBlur() {
|
|
var _a, _b;
|
|
if (isTimePicker.value && !props2.saveOnBlur) {
|
|
if (!valueIsEmpty.value)
|
|
(_b = (_a = pickerOptions.value).handleCancel) == null ? void 0 : _b.call(_a);
|
|
} else
|
|
handleChange();
|
|
pickerVisible.value = false;
|
|
hasJustTabExitedInput = false;
|
|
props2.validateEvent && (formItem == null ? void 0 : formItem.validate("blur").catch((err) => debugWarn(err)));
|
|
}
|
|
});
|
|
const hovering = ref(false);
|
|
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"),
|
|
!showClearBtn.value ? nsRange.em("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 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 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 displayValue = computed(() => {
|
|
var _a, _b, _c, _d;
|
|
const formattedValue = formatToString(parsedValue.value);
|
|
if (isArray(userInput.value))
|
|
return [(_b = (_a = userInput.value[0]) != null ? _a : formattedValue && formattedValue[0]) != null ? _b : "", (_d = (_c = userInput.value[1]) != null ? _c : formattedValue && formattedValue[1]) != null ? _d : ""];
|
|
else if (userInput.value !== null)
|
|
return userInput.value;
|
|
if (isTimePicker.value && valueIsEmpty.value && !props2.saveOnBlur)
|
|
return "";
|
|
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 showClearBtn = computed(() => props2.clearable && !pickerDisabled.value && !props2.readonly && !valueIsEmpty.value && (hovering.value || isFocused.value));
|
|
const onClear = (event) => {
|
|
if (props2.readonly || pickerDisabled.value)
|
|
return;
|
|
if (showClearBtn.value) {
|
|
event == null ? void 0 : event.stopPropagation();
|
|
if (pickerOptions.value.handleClear)
|
|
pickerOptions.value.handleClear();
|
|
else
|
|
emitInput(emptyValues.valueOnClear.value);
|
|
emitChange(emptyValues.valueOnClear.value, true);
|
|
onHide();
|
|
}
|
|
emit("clear");
|
|
};
|
|
const onMouseDownInput = async (event) => {
|
|
var _a;
|
|
if (props2.readonly || pickerDisabled.value)
|
|
return;
|
|
if (((_a = event.target) == null ? void 0 : _a.tagName) !== "INPUT" || isFocused.value || !props2.automaticDropdown)
|
|
pickerVisible.value = true;
|
|
};
|
|
const onMouseEnter = () => {
|
|
if (props2.readonly || pickerDisabled.value)
|
|
return;
|
|
if (!valueIsEmpty.value && props2.clearable)
|
|
hovering.value = true;
|
|
};
|
|
const onMouseLeave = () => {
|
|
hovering.value = false;
|
|
};
|
|
const onTouchStartInput = (event) => {
|
|
var _a;
|
|
if (props2.readonly || pickerDisabled.value)
|
|
return;
|
|
if (((_a = event.touches[0].target) == null ? void 0 : _a.tagName) !== "INPUT" || isFocused.value || !props2.automaticDropdown)
|
|
pickerVisible.value = true;
|
|
};
|
|
const isRangeInput = computed(() => {
|
|
return props2.type.includes("range");
|
|
});
|
|
const pickerSize = useFormSize();
|
|
const popperEl = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = unref(refPopper)) == null ? void 0 : _a.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 handleChange = () => {
|
|
if (isTimePicker.value && !props2.saveOnBlur)
|
|
return;
|
|
const isRangeEmpty = isArray(userInput.value) && userInput.value.every((v2) => v2 === "");
|
|
if (userInput.value && !isRangeEmpty) {
|
|
const value = parseUserInputToDayjs(displayValue.value);
|
|
if (value) {
|
|
if (isValidValue3(value))
|
|
emitInput(dayOrDaysToDate(value));
|
|
userInput.value = null;
|
|
}
|
|
}
|
|
if (userInput.value === "" || isRangeEmpty) {
|
|
emitInput(emptyValues.valueOnClear.value);
|
|
emitChange(emptyValues.valueOnClear.value, true);
|
|
userInput.value = null;
|
|
}
|
|
};
|
|
const parseUserInputToDayjs = (value) => {
|
|
if (!value)
|
|
return null;
|
|
return pickerOptions.value.parseUserInput(value);
|
|
};
|
|
const formatToString = (value) => {
|
|
if (!value)
|
|
return null;
|
|
return isArray(value) ? value.map((_2) => _2.format(props2.format)) : value.format(props2.format);
|
|
};
|
|
const isValidValue3 = (value) => {
|
|
return pickerOptions.value.isValidValue(value);
|
|
};
|
|
const handleKeydownInput = async (event) => {
|
|
if (props2.readonly || pickerDisabled.value)
|
|
return;
|
|
const code = getEventCode(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 (!pickerVisible.value)
|
|
pickerVisible.value = true;
|
|
else if (userInput.value === null || userInput.value === "" || isValidValue3(parseUserInputToDayjs(displayValue.value))) {
|
|
handleChange();
|
|
pickerVisible.value = false;
|
|
}
|
|
event.preventDefault();
|
|
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 _a;
|
|
const values2 = userInput.value;
|
|
const value = parseUserInputToDayjs(values2 && values2[0]);
|
|
const parsedVal = unref(parsedValue);
|
|
if (value && value.isValid()) {
|
|
userInput.value = [formatToString(value), ((_a = displayValue.value) == null ? void 0 : _a[1]) || null];
|
|
const newValue = [value, parsedVal && (parsedVal[1] || null)];
|
|
if (isValidValue3(newValue)) {
|
|
emitInput(dayOrDaysToDate(newValue));
|
|
userInput.value = null;
|
|
}
|
|
}
|
|
};
|
|
const handleEndChange = () => {
|
|
var _a;
|
|
const values2 = unref(userInput);
|
|
const value = parseUserInputToDayjs(values2 && values2[1]);
|
|
const parsedVal = unref(parsedValue);
|
|
if (value && value.isValid()) {
|
|
userInput.value = [((_a = unref(displayValue)) == null ? void 0 : _a[0]) || null, formatToString(value)];
|
|
const newValue = [parsedVal && parsedVal[0], value];
|
|
if (isValidValue3(newValue)) {
|
|
emitInput(dayOrDaysToDate(newValue));
|
|
userInput.value = null;
|
|
}
|
|
}
|
|
};
|
|
const focus = () => {
|
|
var _a;
|
|
(_a = inputRef.value) == null ? void 0 : _a.focus();
|
|
};
|
|
const blur = () => {
|
|
var _a;
|
|
(_a = inputRef.value) == null ? void 0 : _a.blur();
|
|
};
|
|
provide(PICKER_BASE_INJECTION_KEY, {
|
|
props: props2,
|
|
emptyValues
|
|
});
|
|
provide(ROOT_COMMON_PICKER_INJECTION_KEY, commonPicker);
|
|
__expose({
|
|
focus,
|
|
blur,
|
|
handleOpen,
|
|
handleClose,
|
|
onPick
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElTooltip), mergeProps({
|
|
ref_key: "refPopper",
|
|
ref: refPopper,
|
|
visible: unref(pickerVisible),
|
|
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-style": _ctx.popperStyle,
|
|
"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(() => [!isRangeInput.value ? (openBlock(), createBlock(unref(ElInput), {
|
|
key: 0,
|
|
id: _ctx.id,
|
|
ref_key: "inputRef",
|
|
ref: inputRef,
|
|
"container-role": "combobox",
|
|
"model-value": displayValue.value,
|
|
name: _ctx.name,
|
|
size: unref(pickerSize),
|
|
disabled: unref(pickerDisabled),
|
|
placeholder: _ctx.placeholder,
|
|
class: normalizeClass([
|
|
unref(nsDate).b("editor"),
|
|
unref(nsDate).bm("editor", _ctx.type),
|
|
unref(nsDate).is("focus", unref(pickerVisible)),
|
|
_ctx.$attrs.class
|
|
]),
|
|
style: normalizeStyle(_ctx.$attrs.style),
|
|
readonly: !_ctx.editable || _ctx.readonly || isDatesPicker.value || isMonthsPicker.value || isYearsPicker.value || _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: _cache[0] || (_cache[0] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}, {
|
|
prefix: withCtx(() => [triggerIcon.value ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(nsInput).e("icon")),
|
|
onMousedown: withModifiers(onMouseDownInput, ["prevent"]),
|
|
onTouchstartPassive: onTouchStartInput
|
|
}, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(triggerIcon.value)))]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true)]),
|
|
suffix: withCtx(() => [showClearBtn.value && _ctx.clearIcon ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(`${unref(nsInput).e("icon")} clear-icon`),
|
|
onMousedown: withModifiers(unref(NOOP), ["prevent"]),
|
|
onClick: onClear
|
|
}, {
|
|
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"
|
|
])) : (openBlock(), createBlock(picker_range_trigger_default, {
|
|
key: 1,
|
|
id: _ctx.id,
|
|
ref_key: "inputRef",
|
|
ref: inputRef,
|
|
"model-value": displayValue.value,
|
|
name: _ctx.name,
|
|
disabled: unref(pickerDisabled),
|
|
readonly: !_ctx.editable || _ctx.readonly,
|
|
"start-placeholder": _ctx.startPlaceholder,
|
|
"end-placeholder": _ctx.endPlaceholder,
|
|
class: normalizeClass(rangeInputKls.value),
|
|
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(() => [triggerIcon.value ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass([unref(nsInput).e("icon"), unref(nsRange).e("icon")])
|
|
}, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(triggerIcon.value)))]),
|
|
_: 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(clearIconKls.value),
|
|
onMousedown: withModifiers(unref(NOOP), ["prevent"]),
|
|
onClick: onClear
|
|
}, {
|
|
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: unref(pickerVisible),
|
|
actualVisible: unref(pickerActualVisible),
|
|
parsedValue: unref(parsedValue),
|
|
format: _ctx.format,
|
|
dateFormat: _ctx.dateFormat,
|
|
timeFormat: _ctx.timeFormat,
|
|
unlinkPanels: _ctx.unlinkPanels,
|
|
type: _ctx.type,
|
|
defaultValue: _ctx.defaultValue,
|
|
showNow: _ctx.showNow,
|
|
showConfirm: _ctx.showConfirm,
|
|
showFooter: _ctx.showFooter,
|
|
showWeekNumber: _ctx.showWeekNumber,
|
|
onPick: _cache[1] || (_cache[1] = (...args) => unref(onPick) && unref(onPick)(...args)),
|
|
onSelectRange: setSelectionRange,
|
|
onSetPickerOption: _cache[2] || (_cache[2] = (...args) => unref(onSetPickerOption) && unref(onSetPickerOption)(...args)),
|
|
onCalendarChange: _cache[3] || (_cache[3] = (...args) => unref(onCalendarChange) && unref(onCalendarChange)(...args)),
|
|
onClear,
|
|
onPanelChange: _cache[4] || (_cache[4] = (...args) => unref(onPanelChange) && unref(onPanelChange)(...args)),
|
|
onMousedown: _cache[5] || (_cache[5] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
})]),
|
|
_: 3
|
|
}, 16, [
|
|
"visible",
|
|
"transition",
|
|
"popper-class",
|
|
"popper-style",
|
|
"popper-options",
|
|
"fallback-placements",
|
|
"placement"
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/common/picker.mjs
|
|
var picker_default = picker_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// 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, options) => {
|
|
const oldValue = ref(props2.parsedValue);
|
|
watch(() => props2.visible, (val) => {
|
|
const modelValue = toValue(options.modelValue);
|
|
const valueOnClear = toValue(options.valueOnClear);
|
|
if (val && modelValue === valueOnClear) {
|
|
oldValue.value = valueOnClear;
|
|
return;
|
|
}
|
|
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.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_19 = ["onClick"];
|
|
var _hoisted_25 = ["onMouseenter"];
|
|
var basic_time_spinner_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
__name: "basic-time-spinner",
|
|
props: basicTimeSpinnerProps,
|
|
emits: [
|
|
CHANGE_EVENT,
|
|
"select-range",
|
|
"set-option"
|
|
],
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const { isRange, format: format2, saveOnBlur } = inject(PICKER_BASE_INJECTION_KEY).props;
|
|
const emit = __emit;
|
|
const ns = useNamespace("time");
|
|
const { getHoursList, getMinutesList, getSecondsList } = getTimeLists(props2.disabledHours, props2.disabledMinutes, props2.disabledSeconds);
|
|
let isScrolling = false;
|
|
const ignoreScroll = {
|
|
hours: false,
|
|
minutes: false,
|
|
seconds: false
|
|
};
|
|
const currentScrollbar = ref();
|
|
const listRefsMap = {
|
|
hours: ref(),
|
|
minutes: ref(),
|
|
seconds: ref()
|
|
};
|
|
const spinnerItems = computed(() => {
|
|
return props2.showSeconds ? timeUnits : timeUnits.slice(0, 2);
|
|
});
|
|
const timePartials = computed(() => {
|
|
const { spinnerDate } = props2;
|
|
return {
|
|
hours: spinnerDate.hour(),
|
|
minutes: spinnerDate.minute(),
|
|
seconds: spinnerDate.second()
|
|
};
|
|
});
|
|
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) => {
|
|
if (!!!props2.amPmMode)
|
|
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];
|
|
const actualFormat = format2 || DEFAULT_FORMATS_TIME;
|
|
const hourIndex = actualFormat.indexOf("HH");
|
|
const minuteIndex = actualFormat.indexOf("mm");
|
|
const secondIndex = actualFormat.indexOf("ss");
|
|
switch (type4) {
|
|
case "hours":
|
|
if (hourIndex !== -1)
|
|
range4 = [hourIndex, hourIndex + 2];
|
|
break;
|
|
case "minutes":
|
|
if (minuteIndex !== -1)
|
|
range4 = [minuteIndex, minuteIndex + 2];
|
|
break;
|
|
case "seconds":
|
|
if (secondIndex !== -1)
|
|
range4 = [secondIndex, secondIndex + 2];
|
|
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) {
|
|
if (!saveOnBlur) {
|
|
ignoreScroll[type4] = true;
|
|
rAF(() => {
|
|
ignoreScroll[type4] = false;
|
|
});
|
|
}
|
|
getScrollbarElement(scrollbar.$el).scrollTop = Math.max(0, value * typeItemHeight(type4));
|
|
}
|
|
};
|
|
const typeItemHeight = (type4) => {
|
|
var _a;
|
|
const listItem = (_a = unref(listRefsMap[type4])) == null ? void 0 : _a.$el.querySelector("li");
|
|
if (listItem)
|
|
return Number.parseFloat(getStyle(listItem, "height")) || 0;
|
|
return 0;
|
|
};
|
|
const onIncrement = () => {
|
|
scrollDown(1);
|
|
};
|
|
const onDecrement = () => {
|
|
scrollDown(-1);
|
|
};
|
|
const scrollDown = (step2) => {
|
|
if (!currentScrollbar.value)
|
|
emitSelectRange("hours");
|
|
const label = currentScrollbar.value;
|
|
const now2 = unref(timePartials)[label];
|
|
const next = findNextUnDisabled(label, now2, step2, currentScrollbar.value === "hours" ? 24 : 60);
|
|
modifyDateField(label, next);
|
|
adjustSpinner(label, next);
|
|
nextTick(() => emitSelectRange(label));
|
|
};
|
|
const findNextUnDisabled = (type4, now2, step2, total2) => {
|
|
let next = (now2 + step2 + total2) % total2;
|
|
const list = unref(timeList)[type4];
|
|
while (list[next] && next !== now2)
|
|
next = (next + step2 + total2) % total2;
|
|
return next;
|
|
};
|
|
const modifyDateField = (type4, value) => {
|
|
if (unref(timeList)[type4][value])
|
|
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) => {
|
|
if (!saveOnBlur && ignoreScroll[type4])
|
|
return;
|
|
const scrollbar = unref(listRefsMap[type4]);
|
|
if (!scrollbar)
|
|
return;
|
|
isScrolling = true;
|
|
debouncedResetScroll(type4);
|
|
modifyDateField(type4, Math.min(Math.round((getScrollbarElement(scrollbar.$el).scrollTop - (scrollBarHeight(type4) * 0.5 - 10) / typeItemHeight(type4) + 3) / typeItemHeight(type4)), type4 === "hours" ? 23 : 59));
|
|
};
|
|
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(spinnerItems.value, (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(timeList.value[item], (disabled, key) => {
|
|
return openBlock(), createElementBlock("li", {
|
|
key,
|
|
class: normalizeClass([
|
|
unref(ns).be("spinner", "item"),
|
|
unref(ns).is("active", key === timePartials.value[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, _hoisted_19);
|
|
}), 128))]),
|
|
_: 2
|
|
}, 1032, [
|
|
"class",
|
|
"view-class",
|
|
"onMouseenter",
|
|
"onMousemove"
|
|
]);
|
|
}), 128)) : createCommentVNode("v-if", true), _ctx.arrowControl ? (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(spinnerItems.value, (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(arrowControlTimeList.value[item], (time, key) => {
|
|
return openBlock(), createElementBlock("li", {
|
|
key,
|
|
class: normalizeClass([
|
|
unref(ns).be("spinner", "item"),
|
|
unref(ns).is("active", time === timePartials.value[item]),
|
|
unref(ns).is("disabled", timeList.value[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, _hoisted_25);
|
|
}), 128)) : createCommentVNode("v-if", true)], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/time-picker-com/basic-time-spinner.mjs
|
|
var basic_time_spinner_default = basic_time_spinner_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/time-picker-com/panel-time-pick.vue_vue_type_script_setup_true_lang.mjs
|
|
var import_dayjs2 = __toESM(require_dayjs_min(), 1);
|
|
var panel_time_pick_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
__name: "panel-time-pick",
|
|
props: panelTimePickerProps,
|
|
emits: [
|
|
"pick",
|
|
"select-range",
|
|
"set-picker-option"
|
|
],
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const pickerBase = inject(PICKER_BASE_INJECTION_KEY);
|
|
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, {
|
|
modelValue: computed(() => pickerBase.props.modelValue),
|
|
valueOnClear: computed(() => (pickerBase == null ? void 0 : pickerBase.emptyValues) ? pickerBase.emptyValues.valueOnClear.value : null)
|
|
});
|
|
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_dayjs2.default)(_date).locale(lang.value);
|
|
const result2 = getRangeAvailableTime(parsedDate);
|
|
return parsedDate.isSame(result2);
|
|
};
|
|
const handleCancel = () => {
|
|
const old = oldValue.value;
|
|
emit("pick", old, false);
|
|
nextTick(() => {
|
|
oldValue.value = old;
|
|
});
|
|
};
|
|
const handleConfirm = (visible = false, first = false) => {
|
|
if (first)
|
|
return;
|
|
emit("pick", props2.parsedValue, visible);
|
|
};
|
|
const handleChange = (_date) => {
|
|
if (!props2.visible)
|
|
return;
|
|
emit("pick", getRangeAvailableTime(_date).millisecond(0), true);
|
|
};
|
|
const setSelectionRange = (start, end) => {
|
|
emit("select-range", start, end);
|
|
selectionRange.value = [start, end];
|
|
};
|
|
const changeSelectionRange = (step2) => {
|
|
const actualFormat = props2.format;
|
|
const hourIndex = actualFormat.indexOf("HH");
|
|
const minuteIndex = actualFormat.indexOf("mm");
|
|
const secondIndex = actualFormat.indexOf("ss");
|
|
const list = [];
|
|
const mapping = [];
|
|
if (hourIndex !== -1) {
|
|
list.push(hourIndex);
|
|
mapping.push("hours");
|
|
}
|
|
if (minuteIndex !== -1) {
|
|
list.push(minuteIndex);
|
|
mapping.push("minutes");
|
|
}
|
|
if (secondIndex !== -1 && showSeconds.value) {
|
|
list.push(secondIndex);
|
|
mapping.push("seconds");
|
|
}
|
|
const next = (list.indexOf(selectionRange.value[0]) + step2 + list.length) % list.length;
|
|
timePickerOptions["start_emitSelectRange"](mapping[next]);
|
|
};
|
|
const handleKeydown = (event) => {
|
|
const code = getEventCode(event);
|
|
const { left, right, up, down } = EVENT_CODE;
|
|
if ([left, right].includes(code)) {
|
|
changeSelectionRange(code === left ? -1 : 1);
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
if ([up, down].includes(code)) {
|
|
const step2 = code === up ? -1 : 1;
|
|
timePickerOptions["start_scrollDown"](step2);
|
|
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_dayjs2.default)(value, props2.format).locale(lang.value);
|
|
};
|
|
const getDefaultValue2 = () => {
|
|
return (0, import_dayjs2.default)(defaultValue).locale(lang.value);
|
|
};
|
|
emit("set-picker-option", ["isValidValue", isValidValue3]);
|
|
emit("set-picker-option", ["parseUserInput", parseUserInput]);
|
|
emit("set-picker-option", ["handleKeydownInput", handleKeydown]);
|
|
emit("set-picker-option", ["getRangeAvailableTime", getRangeAvailableTime]);
|
|
emit("set-picker-option", ["getDefaultValue", getDefaultValue2]);
|
|
emit("set-picker-option", ["handleCancel", handleCancel]);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(Transition, { name: transitionName.value }, {
|
|
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": showSeconds.value }]) }, [createVNode(basic_time_spinner_default, {
|
|
ref: "spinner",
|
|
role: _ctx.datetimeRole || "start",
|
|
"arrow-control": unref(arrowControl),
|
|
"show-seconds": showSeconds.value,
|
|
"am-pm-mode": amPmMode.value,
|
|
"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: _cache[0] || (_cache[0] = ($event) => handleConfirm())
|
|
}, toDisplayString(unref(t)("el.datepicker.confirm")), 3)], 2)], 2)) : createCommentVNode("v-if", true)]),
|
|
_: 1
|
|
}, 8, ["name"]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/time-picker-com/panel-time-pick.mjs
|
|
var panel_time_pick_default = panel_time_pick_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// 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.vue_vue_type_script_setup_true_lang.mjs
|
|
var import_dayjs3 = __toESM(require_dayjs_min(), 1);
|
|
var _hoisted_110 = ["disabled"];
|
|
var panel_time_range_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
__name: "panel-time-range",
|
|
props: panelTimeRangeProps,
|
|
emits: [
|
|
"pick",
|
|
"select-range",
|
|
"set-picker-option"
|
|
],
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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(PICKER_BASE_INJECTION_KEY);
|
|
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, {
|
|
modelValue: computed(() => pickerBase.props.modelValue),
|
|
valueOnClear: computed(() => (pickerBase == null ? void 0 : pickerBase.emptyValues) ? pickerBase.emptyValues.valueOnClear.value : null)
|
|
});
|
|
const handleCancel = () => {
|
|
const old = oldValue.value;
|
|
emit("pick", old, false);
|
|
nextTick(() => {
|
|
oldValue.value = old;
|
|
});
|
|
};
|
|
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_dayjs3.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 = (step2) => {
|
|
const list = showSeconds.value ? [
|
|
0,
|
|
3,
|
|
6,
|
|
11,
|
|
14,
|
|
17
|
|
] : [
|
|
0,
|
|
3,
|
|
8,
|
|
11
|
|
];
|
|
const mapping = ["hours", "minutes"].concat(showSeconds.value ? ["seconds"] : []);
|
|
const next = (list.indexOf(selectionRange.value[0]) + step2 + 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 = getEventCode(event);
|
|
const { left, right, up, down } = EVENT_CODE;
|
|
if ([left, right].includes(code)) {
|
|
changeSelectionRange(code === left ? -1 : 1);
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
if ([up, down].includes(code)) {
|
|
const step2 = code === up ? -1 : 1;
|
|
timePickerOptions[`${selectionRange.value[0] < offset3.value ? "start" : "end"}_scrollDown`](step2);
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
};
|
|
const disabledHours_ = (role, compare) => {
|
|
const defaultDisable = disabledHours ? disabledHours(role) : [];
|
|
const isStart = role === "start";
|
|
const compareHour = (compare || (isStart ? endTime.value : startTime.value)).hour();
|
|
return union_default(defaultDisable, isStart ? makeSelectRange(compareHour + 1, 23) : makeSelectRange(0, compareHour - 1));
|
|
};
|
|
const disabledMinutes_ = (hour, role, compare) => {
|
|
const defaultDisable = disabledMinutes ? disabledMinutes(hour, role) : [];
|
|
const isStart = role === "start";
|
|
const compareDate = compare || (isStart ? endTime.value : startTime.value);
|
|
if (hour !== compareDate.hour())
|
|
return defaultDisable;
|
|
const compareMinute = compareDate.minute();
|
|
return union_default(defaultDisable, isStart ? makeSelectRange(compareMinute + 1, 59) : makeSelectRange(0, compareMinute - 1));
|
|
};
|
|
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();
|
|
return union_default(defaultDisable, isStart ? makeSelectRange(compareSecond + 1, 59) : makeSelectRange(0, compareSecond - 1));
|
|
};
|
|
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_dayjs3.default)(d2, props2.format).locale(lang.value));
|
|
return (0, import_dayjs3.default)(days, props2.format).locale(lang.value);
|
|
};
|
|
const getDefaultValue2 = () => {
|
|
if (isArray(defaultValue))
|
|
return defaultValue.map((d2) => (0, import_dayjs3.default)(d2).locale(lang.value));
|
|
const defaultDay = (0, import_dayjs3.default)(defaultValue).locale(lang.value);
|
|
return [defaultDay, defaultDay.add(60, "m")];
|
|
};
|
|
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]);
|
|
emit("set-picker-option", ["handleCancel", handleCancel]);
|
|
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(startContainerKls.value) }, [createVNode(basic_time_spinner_default, {
|
|
ref: "minSpinner",
|
|
role: "start",
|
|
"show-seconds": showSeconds.value,
|
|
"am-pm-mode": amPmMode.value,
|
|
"arrow-control": unref(arrowControl),
|
|
"spinner-date": startTime.value,
|
|
"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(endContainerKls.value) }, [createVNode(basic_time_spinner_default, {
|
|
ref: "maxSpinner",
|
|
role: "end",
|
|
"show-seconds": showSeconds.value,
|
|
"am-pm-mode": amPmMode.value,
|
|
"arrow-control": unref(arrowControl),
|
|
"spinner-date": endTime.value,
|
|
"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: _cache[0] || (_cache[0] = ($event) => handleCancel())
|
|
}, toDisplayString(unref(t)("el.datepicker.cancel")), 3), createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass([unref(nsTime).be("panel", "btn"), "confirm"]),
|
|
disabled: btnConfirmDisabled.value,
|
|
onClick: _cache[1] || (_cache[1] = ($event) => handleConfirm())
|
|
}, toDisplayString(unref(t)("el.datepicker.confirm")), 11, _hoisted_110)], 2)], 2)) : createCommentVNode("v-if", true);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/time-picker-com/panel-time-range.mjs
|
|
var panel_time_range_default = panel_time_range_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/time-picker/src/time-picker.mjs
|
|
var import_dayjs4 = __toESM(require_dayjs_min(), 1);
|
|
var import_customParseFormat = __toESM(require_customParseFormat(), 1);
|
|
import_dayjs4.default.extend(import_customParseFormat.default);
|
|
var time_picker_default = defineComponent({
|
|
name: "ElTimePicker",
|
|
install: null,
|
|
props: {
|
|
...timePickerDefaultProps,
|
|
isRange: Boolean
|
|
},
|
|
emits: [UPDATE_MODEL_EVENT],
|
|
setup(props2, ctx) {
|
|
const commonPicker = ref();
|
|
const [type4, Panel] = props2.isRange ? ["timerange", panel_time_range_default] : ["time", panel_time_pick_default];
|
|
const modelUpdater = (value) => ctx.emit(UPDATE_MODEL_EVENT, value);
|
|
provide(PICKER_POPPER_OPTIONS_INJECTION_KEY, props2.popperOptions);
|
|
ctx.expose({
|
|
focus: () => {
|
|
var _a;
|
|
(_a = commonPicker.value) == null ? void 0 : _a.focus();
|
|
},
|
|
blur: () => {
|
|
var _a;
|
|
(_a = commonPicker.value) == null ? void 0 : _a.blur();
|
|
},
|
|
handleOpen: () => {
|
|
var _a;
|
|
(_a = commonPicker.value) == null ? void 0 : _a.handleOpen();
|
|
},
|
|
handleClose: () => {
|
|
var _a;
|
|
(_a = commonPicker.value) == null ? void 0 : _a.handleClose();
|
|
}
|
|
});
|
|
return () => {
|
|
var _a;
|
|
const format2 = (_a = props2.format) != null ? _a : DEFAULT_FORMATS_TIME;
|
|
return createVNode(picker_default, mergeProps(props2, {
|
|
"ref": commonPicker,
|
|
"type": type4,
|
|
"format": format2,
|
|
"onUpdate:modelValue": modelUpdater
|
|
}), { default: (props3) => createVNode(Panel, props3, null) });
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/time-picker/index.mjs
|
|
var ElTimePicker = withInstall(time_picker_default);
|
|
|
|
// node_modules/element-plus/es/components/tag/src/tag.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.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_111 = ["aria-label"];
|
|
var _hoisted_26 = ["aria-label"];
|
|
var tag_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElTag",
|
|
__name: "tag",
|
|
props: tagProps,
|
|
emits: tagEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const tagSize = useFormSize();
|
|
const { t } = useLocale();
|
|
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 _a, _b, _c;
|
|
if ((_c = (_b = (_a = vnode == null ? void 0 : vnode.component) == null ? void 0 : _a.subTree) == null ? void 0 : _b.component) == null ? void 0 : _c.bum)
|
|
vnode.component.subTree.component.bum = null;
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return __props.disableTransitions ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
class: normalizeClass(containerKls.value),
|
|
style: normalizeStyle({ backgroundColor: __props.color }),
|
|
onClick: handleClick
|
|
}, [createBaseVNode("span", { class: normalizeClass(unref(ns).e("content")) }, [renderSlot(_ctx.$slots, "default")], 2), __props.closable ? (openBlock(), createElementBlock("button", {
|
|
key: 0,
|
|
"aria-label": unref(t)("el.tag.close"),
|
|
class: normalizeClass(unref(ns).e("close")),
|
|
type: "button",
|
|
onClick: withModifiers(handleClose, ["stop"])
|
|
}, [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(close_default))]),
|
|
_: 1
|
|
})], 10, _hoisted_111)) : 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(containerKls.value),
|
|
style: normalizeStyle({ backgroundColor: __props.color }),
|
|
onClick: handleClick
|
|
}, [createBaseVNode("span", { class: normalizeClass(unref(ns).e("content")) }, [renderSlot(_ctx.$slots, "default")], 2), __props.closable ? (openBlock(), createElementBlock("button", {
|
|
key: 0,
|
|
"aria-label": unref(t)("el.tag.close"),
|
|
class: normalizeClass(unref(ns).e("close")),
|
|
type: "button",
|
|
onClick: withModifiers(handleClose, ["stop"])
|
|
}, [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(close_default))]),
|
|
_: 1
|
|
})], 10, _hoisted_26)) : createCommentVNode("v-if", true)], 6)]),
|
|
_: 3
|
|
}, 8, ["name"]));
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tag/src/tag2.mjs
|
|
var tag_default = tag_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/tag/index.mjs
|
|
var ElTag = withInstall(tag_default);
|
|
|
|
// 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-v2/src/useProps.mjs
|
|
var defaultProps = {
|
|
label: "label",
|
|
value: "value",
|
|
disabled: "disabled",
|
|
options: "options"
|
|
};
|
|
function useProps(props2) {
|
|
const aliasProps = ref({
|
|
...defaultProps,
|
|
...props2.props
|
|
});
|
|
let cache2 = { ...props2.props };
|
|
watch(() => props2.props, (val) => {
|
|
if (!isEqual_default(val, cache2)) {
|
|
aliasProps.value = {
|
|
...defaultProps,
|
|
...val
|
|
};
|
|
cache2 = { ...val };
|
|
}
|
|
}, { deep: true });
|
|
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/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: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
clearable: Boolean,
|
|
filterable: Boolean,
|
|
allowCreate: Boolean,
|
|
loading: Boolean,
|
|
popperClass: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
popperStyle: { type: definePropType([String, Object]) },
|
|
popperOptions: {
|
|
type: definePropType(Object),
|
|
default: () => ({})
|
|
},
|
|
remote: Boolean,
|
|
debounce: {
|
|
type: Number,
|
|
default: 300
|
|
},
|
|
loadingText: String,
|
|
noMatchText: String,
|
|
noDataText: String,
|
|
remoteMethod: { type: definePropType(Function) },
|
|
filterMethod: { type: definePropType(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,
|
|
tagTooltip: {
|
|
type: definePropType(Object),
|
|
default: () => ({})
|
|
},
|
|
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,
|
|
options: { type: definePropType(Array) },
|
|
props: {
|
|
type: definePropType(Object),
|
|
default: () => defaultProps
|
|
},
|
|
...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_NAME9 = "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_NAME9, "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 _a;
|
|
if (select.props.multiple) {
|
|
const modelValue = castArray_default((_a = select.props.modelValue) != null ? _a : []);
|
|
return !itemSelected.value && modelValue.length >= select.props.multipleLimit && select.props.multipleLimit > 0;
|
|
} else
|
|
return false;
|
|
});
|
|
const currentLabel = computed(() => {
|
|
var _a;
|
|
return (_a = props2.label) != null ? _a : 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 (!isDisabled.value)
|
|
select.states.hoveringIndex = select.optionsArray.indexOf(instance.proxy);
|
|
};
|
|
const updateOption = (query) => {
|
|
states.visible = new RegExp(escapeStringRegexp(query), "i").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;
|
|
if (remote ? val !== oldVal : !isEqual_default(val, oldVal)) {
|
|
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/option.vue_vue_type_script_lang.mjs
|
|
var option_vue_vue_type_script_lang_default = defineComponent({
|
|
name: COMPONENT_NAME9,
|
|
componentName: COMPONENT_NAME9,
|
|
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;
|
|
nextTick(() => {
|
|
const { selected: selectedOptions } = select.states;
|
|
const doesSelected = selectedOptions.some((item) => {
|
|
return item.value === vm.value;
|
|
});
|
|
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);
|
|
}
|
|
const handleMousedown = (event) => {
|
|
let target2 = event.target;
|
|
const currentTarget = event.currentTarget;
|
|
while (target2 && target2 !== currentTarget) {
|
|
if (isFocusable(target2))
|
|
return;
|
|
target2 = target2.parentElement;
|
|
}
|
|
event.preventDefault();
|
|
};
|
|
return {
|
|
ns,
|
|
id,
|
|
containerKls,
|
|
currentLabel,
|
|
itemSelected,
|
|
isDisabled,
|
|
select,
|
|
visible,
|
|
hover,
|
|
states,
|
|
hoverItem,
|
|
handleMousedown,
|
|
updateOption,
|
|
selectOptionClick
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/select/src/option2.mjs
|
|
var _hoisted_112 = [
|
|
"id",
|
|
"aria-disabled",
|
|
"aria-selected"
|
|
];
|
|
function _sfc_render2(_ctx, _cache, $props, $setup, $data, $options) {
|
|
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: _cache[0] || (_cache[0] = (...args) => _ctx.hoverItem && _ctx.hoverItem(...args)),
|
|
onMousedown: _cache[1] || (_cache[1] = (...args) => _ctx.handleMousedown && _ctx.handleMousedown(...args)),
|
|
onClick: _cache[2] || (_cache[2] = withModifiers((...args) => _ctx.selectOptionClick && _ctx.selectOptionClick(...args), ["stop"]))
|
|
}, [renderSlot(_ctx.$slots, "default", {}, () => [createBaseVNode("span", null, toDisplayString(_ctx.currentLabel), 1)])], 42, _hoisted_112)), [[vShow, _ctx.visible]]);
|
|
}
|
|
var option_default = _plugin_vue_export_helper_default(option_vue_vue_type_script_lang_default, [["render", _sfc_render2]]);
|
|
|
|
// node_modules/element-plus/es/components/select/src/option-group.vue_vue_type_script_lang.mjs
|
|
var option_group_vue_vue_type_script_lang_default = 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 _a;
|
|
return node.type.name === "ElOption" && !!((_a = node.component) == null ? void 0 : _a.proxy);
|
|
};
|
|
const flattedChildren2 = (node) => {
|
|
const nodes = castArray_default(node);
|
|
const children2 = [];
|
|
nodes.forEach((child) => {
|
|
var _a;
|
|
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 ((_a = child.component) == null ? void 0 : _a.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
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/select/src/option-group.mjs
|
|
function _sfc_render3(_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 option_group_default = _plugin_vue_export_helper_default(option_group_vue_vue_type_script_lang_default, [["render", _sfc_render3]]);
|
|
|
|
// node_modules/element-plus/es/components/select/src/select-dropdown.vue_vue_type_script_lang.mjs
|
|
var select_dropdown_vue_vue_type_script_lang_default = 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 _a;
|
|
const offsetWidth = (_a = select.selectRef) == null ? void 0 : _a.offsetWidth;
|
|
if (offsetWidth)
|
|
minWidth.value = `${offsetWidth - BORDER_HORIZONTAL_WIDTH}px`;
|
|
else
|
|
minWidth.value = "";
|
|
}
|
|
onMounted(() => {
|
|
updateMinWidth();
|
|
useResizeObserver(select.selectRef, updateMinWidth);
|
|
});
|
|
return {
|
|
ns,
|
|
minWidth,
|
|
popperClass,
|
|
isMultiple,
|
|
isFitInputWidth
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/select/src/select-dropdown.mjs
|
|
function _sfc_render4(_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 select_dropdown_default = _plugin_vue_export_helper_default(select_dropdown_vue_vue_type_script_lang_default, [["render", _sfc_render4]]);
|
|
|
|
// node_modules/element-plus/es/components/select/src/useSelect.mjs
|
|
var useSelect = (props2, emit) => {
|
|
const { t } = useLocale();
|
|
const slots = useSlots();
|
|
const contentId = useId();
|
|
const nsSelect = useNamespace("select");
|
|
const nsInput = useNamespace("input");
|
|
const states = reactive({
|
|
inputValue: "",
|
|
options: /* @__PURE__ */ new Map(),
|
|
cachedOptions: /* @__PURE__ */ 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 expanded = ref(false);
|
|
const hoverOption = ref();
|
|
const debouncing = ref(false);
|
|
const { form, formItem } = useFormItem();
|
|
const { inputId } = useFormItemInputId(props2, { formItemContext: formItem });
|
|
const { valueOnClear, isEmptyValue: isEmptyValue2 } = useEmptyValues(props2);
|
|
const { isComposing, handleCompositionStart, handleCompositionUpdate, handleCompositionEnd } = useComposition({ afterComposition: (e) => onInput(e) });
|
|
const selectDisabled = useFormDisabled();
|
|
const { wrapperRef, isFocused, handleBlur } = useFocusController(inputRef, {
|
|
disabled: selectDisabled,
|
|
afterFocus() {
|
|
if (props2.automaticDropdown && !expanded.value) {
|
|
expanded.value = true;
|
|
states.menuVisibleOnFocus = true;
|
|
}
|
|
},
|
|
beforeBlur(event) {
|
|
var _a, _b;
|
|
return ((_a = tooltipRef.value) == null ? void 0 : _a.isFocusInsideContent(event)) || ((_b = tagTooltipRef.value) == null ? void 0 : _b.isFocusInsideContent(event));
|
|
},
|
|
afterBlur() {
|
|
var _a;
|
|
expanded.value = false;
|
|
states.menuVisibleOnFocus = false;
|
|
if (props2.validateEvent)
|
|
(_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "blur").catch((err) => debugWarn(err));
|
|
}
|
|
});
|
|
const hasModelValue = computed(() => {
|
|
return isArray(props2.modelValue) ? props2.modelValue.length > 0 : !isEmptyValue2(props2.modelValue);
|
|
});
|
|
const needStatusIcon = computed(() => {
|
|
var _a;
|
|
return (_a = form == null ? void 0 : form.statusIcon) != null ? _a : false;
|
|
});
|
|
const showClearBtn = computed(() => {
|
|
return props2.clearable && !selectDisabled.value && hasModelValue.value && (isFocused.value || states.inputHovering);
|
|
});
|
|
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 debounce2 = computed(() => props2.remote ? props2.debounce : 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 _a;
|
|
(_a = option.updateOption) == null ? void 0 : _a.call(option, states.inputValue);
|
|
});
|
|
};
|
|
const selectSize = useFormSize();
|
|
const collapseTagSize = computed(() => ["small"].includes(selectSize.value) ? "small" : "default");
|
|
const dropdownMenuVisible = computed({
|
|
get() {
|
|
return expanded.value && (props2.loading || !isRemoteSearchEmpty.value || props2.remote && !!slots.empty) && (!debouncing.value || !isEmpty2(states.previousQuery) || states.options.size > 0);
|
|
},
|
|
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 _a;
|
|
const _placeholder = (_a = props2.placeholder) != null ? _a : 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;
|
|
states.menuVisibleOnFocus = false;
|
|
}
|
|
});
|
|
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];
|
|
states.hoveringIndex = getValueIndex(optionsArray.value.map((item) => item.value), userCreatedOption || firstOriginOption);
|
|
};
|
|
const setSelected = () => {
|
|
if (!props2.multiple) {
|
|
const option = getOption(isArray(props2.modelValue) ? props2.modelValue[0] : props2.modelValue);
|
|
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];
|
|
if (isObjectValue ? get_default(cachedOption.value, props2.valueKey) === get_default(value, props2.valueKey) : cachedOption.value === value) {
|
|
option = {
|
|
index: optionsArray.value.filter((opt) => !opt.created).indexOf(cachedOption),
|
|
value,
|
|
currentLabel: cachedOption.currentLabel,
|
|
get isDisabled() {
|
|
return cachedOption.isDisabled;
|
|
}
|
|
};
|
|
break;
|
|
}
|
|
}
|
|
if (option)
|
|
return option;
|
|
return {
|
|
index: -1,
|
|
value,
|
|
currentLabel: isObjectValue ? value.label : value != null ? value : ""
|
|
};
|
|
};
|
|
const updateHoveringIndex = () => {
|
|
const length = states.selected.length;
|
|
if (length > 0) {
|
|
const lastOption = states.selected[length - 1];
|
|
states.hoveringIndex = optionsArray.value.findIndex((item) => getValueKey(lastOption) === getValueKey(item));
|
|
} else
|
|
states.hoveringIndex = -1;
|
|
};
|
|
const resetSelectionWidth = () => {
|
|
states.selectionWidth = Number.parseFloat(window.getComputedStyle(selectionRef.value).width);
|
|
};
|
|
const resetCollapseItemWidth = () => {
|
|
states.collapseItemWidth = collapseItemRef.value.getBoundingClientRect().width;
|
|
};
|
|
const updateTooltip = () => {
|
|
var _a, _b;
|
|
(_b = (_a = tooltipRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
|
|
};
|
|
const updateTagTooltip = () => {
|
|
var _a, _b;
|
|
(_b = (_a = tagTooltipRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
|
|
};
|
|
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) {
|
|
debouncing.value = true;
|
|
debouncedOnInputChange();
|
|
} else
|
|
return onInputChange();
|
|
};
|
|
const debouncedOnInputChange = useDebounceFn(() => {
|
|
onInputChange();
|
|
debouncing.value = false;
|
|
}, debounce2);
|
|
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 == null ? void 0 : option.disabled) && !(option == null ? void 0 : option.states.groupDisabled);
|
|
});
|
|
const deletePrevTag = (e) => {
|
|
const code = getEventCode(e);
|
|
if (!props2.multiple)
|
|
return;
|
|
if (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 _a;
|
|
if (props2.multiple) {
|
|
const value = castArray_default((_a = props2.modelValue) != null ? _a : []).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 && (option.created || !props2.reserveKeyword))
|
|
states.inputValue = "";
|
|
} else {
|
|
!isEqual_default(props2.modelValue, option.value) && 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 _a, _b, _c, _d, _e;
|
|
const targetOption = isArray(option) ? option[option.length - 1] : option;
|
|
let target2 = null;
|
|
if (!isNil_default(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 = (_a = tooltipRef.value) == null ? void 0 : _a.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 _a, _b;
|
|
return (_b = (_a = tooltipRef.value) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.contentRef;
|
|
});
|
|
const handleMenuEnter = () => {
|
|
states.isBeforeHide = false;
|
|
nextTick(() => {
|
|
var _a;
|
|
(_a = scrollbarRef.value) == null ? void 0 : _a.update();
|
|
scrollToOption(states.selected);
|
|
});
|
|
};
|
|
const focus = () => {
|
|
var _a;
|
|
(_a = inputRef.value) == null ? void 0 : _a.focus();
|
|
};
|
|
const blur = () => {
|
|
var _a;
|
|
if (expanded.value) {
|
|
expanded.value = false;
|
|
nextTick(() => {
|
|
var _a2;
|
|
return (_a2 = inputRef.value) == null ? void 0 : _a2.blur();
|
|
});
|
|
return;
|
|
}
|
|
(_a = inputRef.value) == null ? void 0 : _a.blur();
|
|
};
|
|
const handleClearClick = (event) => {
|
|
deleteSelected(event);
|
|
};
|
|
const handleClickOutside = (event) => {
|
|
expanded.value = false;
|
|
if (isFocused.value) {
|
|
const _event2 = new FocusEvent("blur", event);
|
|
nextTick(() => handleBlur(_event2));
|
|
}
|
|
};
|
|
const handleEsc = () => {
|
|
if (states.inputValue.length > 0)
|
|
states.inputValue = "";
|
|
else
|
|
expanded.value = false;
|
|
};
|
|
const toggleMenu = (event) => {
|
|
var _a;
|
|
if (selectDisabled.value || props2.filterable && expanded.value && event && !((_a = suffixRef.value) == null ? void 0 : _a.contains(event.target)))
|
|
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 findFocusableIndex = (arr, start, step2, len) => {
|
|
for (let i = start; i >= 0 && i < len; i += step2) {
|
|
const obj = arr[i];
|
|
if (!(obj == null ? void 0 : obj.isDisabled) && (obj == null ? void 0 : obj.visible))
|
|
return i;
|
|
}
|
|
return null;
|
|
};
|
|
const focusOption = (targetIndex, mode) => {
|
|
var _a;
|
|
const len = states.options.size;
|
|
if (len === 0)
|
|
return;
|
|
const start = clamp_default(targetIndex, 0, len - 1);
|
|
const options = optionsArray.value;
|
|
const direction2 = mode === "up" ? -1 : 1;
|
|
const newIndex = (_a = findFocusableIndex(options, start, direction2, len)) != null ? _a : findFocusableIndex(options, start - direction2, -direction2, len);
|
|
if (newIndex != null) {
|
|
states.hoveringIndex = newIndex;
|
|
nextTick(() => scrollToOption(hoverOption.value));
|
|
}
|
|
};
|
|
const handleKeydown = (e) => {
|
|
const code = getEventCode(e);
|
|
let isPreventDefault = true;
|
|
switch (code) {
|
|
case EVENT_CODE.up:
|
|
navigateOptions("prev");
|
|
break;
|
|
case EVENT_CODE.down:
|
|
navigateOptions("next");
|
|
break;
|
|
case EVENT_CODE.enter:
|
|
case EVENT_CODE.numpadEnter:
|
|
if (!isComposing.value)
|
|
selectOption();
|
|
break;
|
|
case EVENT_CODE.esc:
|
|
handleEsc();
|
|
break;
|
|
case EVENT_CODE.backspace:
|
|
isPreventDefault = false;
|
|
deletePrevTag(e);
|
|
return;
|
|
case EVENT_CODE.home:
|
|
if (!expanded.value)
|
|
return;
|
|
focusOption(0, "down");
|
|
break;
|
|
case EVENT_CODE.end:
|
|
if (!expanded.value)
|
|
return;
|
|
focusOption(states.options.size - 1, "up");
|
|
break;
|
|
case EVENT_CODE.pageUp:
|
|
if (!expanded.value)
|
|
return;
|
|
focusOption(states.hoveringIndex - 10, "up");
|
|
break;
|
|
case EVENT_CODE.pageDown:
|
|
if (!expanded.value)
|
|
return;
|
|
focusOption(states.hoveringIndex + 10, "down");
|
|
break;
|
|
default:
|
|
isPreventDefault = false;
|
|
break;
|
|
}
|
|
if (isPreventDefault) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
}
|
|
};
|
|
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 inputSlotWidth = props2.filterable ? gapWidth + MINIMUM_INPUT_WIDTH : 0;
|
|
return { maxWidth: `${collapseItemRef.value && props2.maxCollapseTags === 1 ? states.selectionWidth - states.collapseItemWidth - gapWidth - inputSlotWidth : states.selectionWidth - inputSlotWidth}px` };
|
|
});
|
|
const collapseTagStyle = computed(() => {
|
|
return { maxWidth: `${states.selectionWidth}px` };
|
|
});
|
|
const popupScroll = (data) => {
|
|
emit("popup-scroll", data);
|
|
};
|
|
useResizeObserver(selectionRef, resetSelectionWidth);
|
|
useResizeObserver(wrapperRef, updateTooltip);
|
|
useResizeObserver(tagMenuRef, updateTagTooltip);
|
|
useResizeObserver(collapseItemRef, resetCollapseItemWidth);
|
|
let stop;
|
|
watch(() => dropdownMenuVisible.value, (newVal) => {
|
|
if (newVal)
|
|
stop = useResizeObserver(menuRef, updateTooltip).stop;
|
|
else {
|
|
stop == null ? void 0 : stop();
|
|
stop = void 0;
|
|
}
|
|
emit("visible-change", newVal);
|
|
});
|
|
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,
|
|
showClearBtn,
|
|
iconComponent,
|
|
iconReverse,
|
|
validateState,
|
|
validateIcon,
|
|
showNewOption,
|
|
updateOptions: updateOptions2,
|
|
collapseTagSize,
|
|
setSelected,
|
|
selectDisabled,
|
|
emptyText,
|
|
handleCompositionStart,
|
|
handleCompositionUpdate,
|
|
handleCompositionEnd,
|
|
handleKeydown,
|
|
onOptionCreate,
|
|
onOptionDestroy,
|
|
handleMenuEnter,
|
|
focus,
|
|
blur,
|
|
handleClearClick,
|
|
handleClickOutside,
|
|
handleEsc,
|
|
toggleMenu,
|
|
selectOption,
|
|
getValueKey,
|
|
navigateOptions,
|
|
dropdownMenuVisible,
|
|
showTagList,
|
|
collapseTagList,
|
|
popupScroll,
|
|
getOption,
|
|
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 options_default = defineComponent({
|
|
name: "ElOptions",
|
|
setup(_2, { slots }) {
|
|
const select = inject(selectKey);
|
|
let cachedValueList = [];
|
|
return () => {
|
|
var _a, _b;
|
|
const children = (_a = slots.default) == null ? void 0 : _a.call(slots);
|
|
const valueList = [];
|
|
function filterOptions(children2) {
|
|
if (!isArray(children2))
|
|
return;
|
|
children2.forEach((item) => {
|
|
var _a2, _b2, _c, _d;
|
|
const name = (_a2 = (item == null ? void 0 : item.type) || {}) == null ? void 0 : _a2.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/select.vue_vue_type_script_lang.mjs
|
|
var COMPONENT_NAME10 = "ElSelect";
|
|
var warnHandlerMap = /* @__PURE__ */ new WeakMap();
|
|
var createSelectWarnHandler = (appContext) => {
|
|
return (...args) => {
|
|
var _a, _b;
|
|
const message2 = args[0];
|
|
if (!message2 || message2.includes('Slot "default" invoked outside of the render function') && ((_a = args[2]) == null ? void 0 : _a.includes("ElTreeSelect")))
|
|
return;
|
|
const original = (_b = warnHandlerMap.get(appContext)) == null ? void 0 : _b.originalWarnHandler;
|
|
if (original) {
|
|
original(...args);
|
|
return;
|
|
}
|
|
console.warn(...args);
|
|
};
|
|
};
|
|
var getWarnHandlerRecord = (appContext) => {
|
|
let record = warnHandlerMap.get(appContext);
|
|
if (!record) {
|
|
record = {
|
|
originalWarnHandler: appContext.config.warnHandler,
|
|
handler: createSelectWarnHandler(appContext),
|
|
count: 0
|
|
};
|
|
warnHandlerMap.set(appContext, record);
|
|
}
|
|
return record;
|
|
};
|
|
var select_vue_vue_type_script_lang_default = defineComponent({
|
|
name: COMPONENT_NAME10,
|
|
componentName: COMPONENT_NAME10,
|
|
components: {
|
|
ElSelectMenu: select_dropdown_default,
|
|
ElOption: option_default,
|
|
ElOptions: options_default,
|
|
ElOptionGroup: option_group_default,
|
|
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 instance = getCurrentInstance();
|
|
const warnRecord = getWarnHandlerRecord(instance.appContext);
|
|
warnRecord.count += 1;
|
|
instance.appContext.config.warnHandler = warnRecord.handler;
|
|
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 { getLabel, getValue: getValue3, getOptions, getDisabled } = useProps(props2);
|
|
const getOptionProps = (option) => ({
|
|
label: getLabel(option),
|
|
value: getValue3(option),
|
|
disabled: getDisabled(option)
|
|
});
|
|
const flatTreeSelectData = (data) => {
|
|
return data.reduce((acc, item) => {
|
|
acc.push(item);
|
|
if (item.children && item.children.length > 0)
|
|
acc.push(...flatTreeSelectData(item.children));
|
|
return acc;
|
|
}, []);
|
|
};
|
|
const manuallyRenderSlots = (vnodes) => {
|
|
flattedChildren(vnodes || []).forEach((item) => {
|
|
var _a, _b;
|
|
if (isObject(item) && (item.type.name === "ElOption" || item.type.name === "ElTree")) {
|
|
const _name = item.type.name;
|
|
if (_name === "ElTree")
|
|
flatTreeSelectData(((_a = item.props) == null ? void 0 : _a.data) || []).forEach((treeItem) => {
|
|
var _a2;
|
|
treeItem.currentLabel = (_a2 = treeItem.label) != null ? _a2 : isObject(treeItem.value) ? "" : treeItem.value;
|
|
API.onOptionCreate(treeItem);
|
|
});
|
|
else if (_name === "ElOption") {
|
|
const obj = { ...item.props };
|
|
obj.currentLabel = (_b = obj.label) != null ? _b : isObject(obj.value) ? "" : obj.value;
|
|
API.onOptionCreate(obj);
|
|
}
|
|
}
|
|
});
|
|
};
|
|
watch(() => {
|
|
var _a;
|
|
return [props2.persistent || API.expanded.value || !slots.default ? void 0 : (_a = slots.default) == null ? void 0 : _a.call(slots), modelValue.value];
|
|
}, () => {
|
|
var _a;
|
|
if (props2.persistent || API.expanded.value)
|
|
return;
|
|
if (!slots.default)
|
|
return;
|
|
API.states.options.clear();
|
|
manuallyRenderSlots((_a = slots.default) == null ? void 0 : _a.call(slots));
|
|
}, { 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);
|
|
});
|
|
onBeforeUnmount(() => {
|
|
const record = warnHandlerMap.get(instance.appContext);
|
|
if (!record)
|
|
return;
|
|
record.count -= 1;
|
|
if (record.count <= 0) {
|
|
instance.appContext.config.warnHandler = record.originalWarnHandler;
|
|
warnHandlerMap.delete(instance.appContext);
|
|
}
|
|
});
|
|
return {
|
|
...API,
|
|
modelValue,
|
|
selectedLabel,
|
|
calculatorRef,
|
|
inputStyle,
|
|
getLabel,
|
|
getValue: getValue3,
|
|
getOptions,
|
|
getDisabled,
|
|
getOptionProps
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/select/src/select2.mjs
|
|
var _hoisted_113 = [
|
|
"id",
|
|
"value",
|
|
"name",
|
|
"disabled",
|
|
"autocomplete",
|
|
"tabindex",
|
|
"readonly",
|
|
"aria-activedescendant",
|
|
"aria-controls",
|
|
"aria-expanded",
|
|
"aria-label"
|
|
];
|
|
var _hoisted_27 = ["textContent"];
|
|
var _hoisted_32 = { key: 1 };
|
|
function _sfc_render5(_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_option = resolveComponent("el-option");
|
|
const _component_el_option_group = resolveComponent("el-option-group");
|
|
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", mergeProps({
|
|
ref: "selectRef",
|
|
class: [_ctx.nsSelect.b(), _ctx.nsSelect.m(_ctx.selectSize)]
|
|
}, { [toHandlerKey(_ctx.mouseEnterEventName)]: _cache[11] || (_cache[11] = ($event) => _ctx.states.inputHovering = true) }, { onMouseleave: _cache[12] || (_cache[12] = ($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-style": _ctx.popperStyle,
|
|
"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: _cache[10] || (_cache[10] = ($event) => _ctx.states.isBeforeHide = false)
|
|
}, {
|
|
default: withCtx(() => {
|
|
var _a;
|
|
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: _cache[7] || (_cache[7] = withModifiers((...args) => _ctx.toggleMenu && _ctx.toggleMenu(...args), ["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,
|
|
data: _ctx.states.selected,
|
|
deleteTag: _ctx.deleteTag,
|
|
selectDisabled: _ctx.selectDisabled
|
|
}, () => {
|
|
var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t2, _u;
|
|
return [(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", {
|
|
index: item.index,
|
|
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": (_b = (_a2 = _ctx.tagTooltip) == null ? void 0 : _a2.fallbackPlacements) != null ? _b : [
|
|
"bottom",
|
|
"top",
|
|
"right",
|
|
"left"
|
|
],
|
|
effect: (_d = (_c = _ctx.tagTooltip) == null ? void 0 : _c.effect) != null ? _d : _ctx.effect,
|
|
placement: (_f = (_e = _ctx.tagTooltip) == null ? void 0 : _e.placement) != null ? _f : "bottom",
|
|
"popper-class": (_h = (_g = _ctx.tagTooltip) == null ? void 0 : _g.popperClass) != null ? _h : _ctx.popperClass,
|
|
"popper-style": (_j = (_i = _ctx.tagTooltip) == null ? void 0 : _i.popperStyle) != null ? _j : _ctx.popperStyle,
|
|
teleported: (_l = (_k = _ctx.tagTooltip) == null ? void 0 : _k.teleported) != null ? _l : _ctx.teleported,
|
|
"append-to": (_n = (_m = _ctx.tagTooltip) == null ? void 0 : _m.appendTo) != null ? _n : _ctx.appendTo,
|
|
"popper-options": (_p = (_o = _ctx.tagTooltip) == null ? void 0 : _o.popperOptions) != null ? _p : _ctx.popperOptions,
|
|
transition: (_q = _ctx.tagTooltip) == null ? void 0 : _q.transition,
|
|
"show-after": (_r = _ctx.tagTooltip) == null ? void 0 : _r.showAfter,
|
|
"hide-after": (_s = _ctx.tagTooltip) == null ? void 0 : _s.hideAfter,
|
|
"auto-close": (_t2 = _ctx.tagTooltip) == null ? void 0 : _t2.autoClose,
|
|
offset: (_u = _ctx.tagTooltip) == null ? void 0 : _u.offset
|
|
}, {
|
|
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", {
|
|
index: item.index,
|
|
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",
|
|
"fallback-placements",
|
|
"effect",
|
|
"placement",
|
|
"popper-class",
|
|
"popper-style",
|
|
"teleported",
|
|
"append-to",
|
|
"popper-options",
|
|
"transition",
|
|
"show-after",
|
|
"hide-after",
|
|
"auto-close",
|
|
"offset"
|
|
])) : 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 || _ctx.selectDisabled || !_ctx.states.inputValue && !_ctx.isFocused)
|
|
]) }, [createBaseVNode("input", {
|
|
id: _ctx.inputId,
|
|
ref: "inputRef",
|
|
value: _ctx.states.inputValue,
|
|
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": ((_a = _ctx.hoverOption) == null ? void 0 : _a.id) || "",
|
|
"aria-controls": _ctx.contentId,
|
|
"aria-expanded": _ctx.dropdownMenuVisible,
|
|
"aria-label": _ctx.ariaLabel,
|
|
"aria-autocomplete": "none",
|
|
"aria-haspopup": "listbox",
|
|
onKeydown: _cache[0] || (_cache[0] = (...args) => _ctx.handleKeydown && _ctx.handleKeydown(...args)),
|
|
onCompositionstart: _cache[1] || (_cache[1] = (...args) => _ctx.handleCompositionStart && _ctx.handleCompositionStart(...args)),
|
|
onCompositionupdate: _cache[2] || (_cache[2] = (...args) => _ctx.handleCompositionUpdate && _ctx.handleCompositionUpdate(...args)),
|
|
onCompositionend: _cache[3] || (_cache[3] = (...args) => _ctx.handleCompositionEnd && _ctx.handleCompositionEnd(...args)),
|
|
onInput: _cache[4] || (_cache[4] = (...args) => _ctx.onInput && _ctx.onInput(...args)),
|
|
onChange: _cache[5] || (_cache[5] = withModifiers(() => {
|
|
}, ["stop"])),
|
|
onClick: _cache[6] || (_cache[6] = withModifiers((...args) => _ctx.toggleMenu && _ctx.toggleMenu(...args), ["stop"]))
|
|
}, null, 46, _hoisted_113), _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, _hoisted_27)) : 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,
|
|
index: _ctx.getOption(_ctx.modelValue).index,
|
|
label: _ctx.currentPlaceholder,
|
|
value: _ctx.modelValue
|
|
}, () => [createBaseVNode("span", null, toDisplayString(_ctx.currentPlaceholder), 1)]) : (openBlock(), createElementBlock("span", _hoisted_32, toDisplayString(_ctx.currentPlaceholder), 1))], 2)) : createCommentVNode("v-if", true)
|
|
], 2),
|
|
createBaseVNode("div", {
|
|
ref: "suffixRef",
|
|
class: normalizeClass(_ctx.nsSelect.e("suffix"))
|
|
}, [
|
|
_ctx.iconComponent && !_ctx.showClearBtn ? (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.showClearBtn && _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)
|
|
], 2)];
|
|
}),
|
|
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: _cache[8] || (_cache[8] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}, [renderSlot(_ctx.$slots, "header")], 2)) : 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", {}, () => [(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.options, (option, index) => {
|
|
var _a;
|
|
return openBlock(), createElementBlock(Fragment, { key: index }, [((_a = _ctx.getOptions(option)) == null ? void 0 : _a.length) ? (openBlock(), createBlock(_component_el_option_group, {
|
|
key: 0,
|
|
label: _ctx.getLabel(option),
|
|
disabled: _ctx.getDisabled(option)
|
|
}, {
|
|
default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.getOptions(option), (item) => {
|
|
return openBlock(), createBlock(_component_el_option, mergeProps({ key: _ctx.getValue(item) }, { ref_for: true }, _ctx.getOptionProps(item)), null, 16);
|
|
}), 128))]),
|
|
_: 2
|
|
}, 1032, ["label", "disabled"])) : (openBlock(), createBlock(_component_el_option, mergeProps({
|
|
key: 1,
|
|
ref_for: true
|
|
}, _ctx.getOptionProps(option)), null, 16))], 64);
|
|
}), 128))])]),
|
|
_: 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: _cache[9] || (_cache[9] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}, [renderSlot(_ctx.$slots, "footer")], 2)) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 512)]),
|
|
_: 3
|
|
}, 8, [
|
|
"visible",
|
|
"placement",
|
|
"teleported",
|
|
"popper-class",
|
|
"popper-style",
|
|
"popper-options",
|
|
"fallback-placements",
|
|
"effect",
|
|
"transition",
|
|
"persistent",
|
|
"append-to",
|
|
"show-arrow",
|
|
"offset",
|
|
"onBeforeShow"
|
|
])], 16)), [[
|
|
_directive_click_outside,
|
|
_ctx.handleClickOutside,
|
|
_ctx.popperRef
|
|
]]);
|
|
}
|
|
var select_default = _plugin_vue_export_helper_default(select_vue_vue_type_script_lang_default, [["render", _sfc_render5]]);
|
|
|
|
// node_modules/element-plus/es/components/select/index.mjs
|
|
var ElSelect = withInstall(select_default, {
|
|
Option: option_default,
|
|
OptionGroup: option_group_default
|
|
});
|
|
var ElOption = withNoopInstall(option_default);
|
|
var ElOptionGroup = withNoopInstall(option_group_default);
|
|
|
|
// 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) => {
|
|
return rangeArr(date4.daysInMonth()).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_dayjs5 = __toESM(require_dayjs_min(), 1);
|
|
var import_localeData = __toESM(require_localeData(), 1);
|
|
var useDateTable = (props2, emit) => {
|
|
import_dayjs5.default.extend(import_localeData.default);
|
|
const firstDayOfWeek = import_dayjs5.default.localeData().firstDayOfWeek();
|
|
const { t, lang } = useLocale();
|
|
const now2 = (0, import_dayjs5.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 nextMonthDays = rangeArr(7 - (days.length % 7 || 7)).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 }) => {
|
|
emit("pick", getFormattedDate(text, type4));
|
|
};
|
|
const getSlotData = ({ text, type: type4 }) => {
|
|
const day = getFormattedDate(text, type4);
|
|
return {
|
|
isSelected: day.isSame(props2.selectedDay),
|
|
type: `${type4}-month`,
|
|
day: day.format(DEFAULT_FORMATS_DATE),
|
|
date: day.toDate()
|
|
};
|
|
};
|
|
return {
|
|
now: now2,
|
|
isInRange,
|
|
rows,
|
|
weekDays,
|
|
getFormattedDate,
|
|
handlePickDay,
|
|
getSlotData
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/calendar/src/date-table.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_114 = { key: 0 };
|
|
var _hoisted_28 = ["onClick"];
|
|
var date_table_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "DateTable",
|
|
__name: "date-table",
|
|
props: dateTableProps,
|
|
emits: dateTableEmits,
|
|
setup(__props, { expose: __expose, emit: __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"
|
|
}, [!__props.hideHeader ? (openBlock(), createElementBlock("thead", _hoisted_114, [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 && __props.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, _hoisted_28);
|
|
}), 128))], 2);
|
|
}), 128))])], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/calendar/src/date-table2.mjs
|
|
var date_table_default = date_table_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/calendar/src/use-calendar.mjs
|
|
var import_dayjs6 = __toESM(require_dayjs_min(), 1);
|
|
var adjacentMonth = (start, end) => {
|
|
const firstMonthLastDay = start.endOf("month");
|
|
const lastMonthFirstDay = end.startOf("month");
|
|
const lastMonthStartDay = firstMonthLastDay.isSame(lastMonthFirstDay, "week") ? 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_dayjs6.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 [startDayjs, endDayjs] = props2.range.map((_2) => (0, import_dayjs6.default)(_2).locale(lang.value));
|
|
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_dayjs6.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 day = {
|
|
"prev-month": prevMonthDayjs.value,
|
|
"next-month": nextMonthDayjs.value,
|
|
"prev-year": prevYearDayjs.value,
|
|
"next-year": nextYearDayjs.value,
|
|
today: now2
|
|
}[type4];
|
|
if (!day.isSame(date4.value, "day"))
|
|
pickDay(day);
|
|
};
|
|
const handleDateChange = (date5) => {
|
|
if (date5 === "today")
|
|
selectDate("today");
|
|
else
|
|
pickDay(date5);
|
|
};
|
|
return {
|
|
calculateValidatedDateRange,
|
|
date: date4,
|
|
realSelectedDay,
|
|
pickDay,
|
|
selectDate,
|
|
validatedRange,
|
|
handleDateChange
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/calendar/src/select-controller.mjs
|
|
var selectControllerProps = buildProps({
|
|
date: {
|
|
type: definePropType(Object),
|
|
required: true
|
|
},
|
|
formatter: { type: definePropType(Function) }
|
|
});
|
|
var selectControllerEmits = { "date-change": (date4) => isObject(date4) || isString(date4) };
|
|
|
|
// node_modules/element-plus/es/components/calendar/src/select-controller.vue_vue_type_script_setup_true_lang.mjs
|
|
var import_dayjs7 = __toESM(require_dayjs_min(), 1);
|
|
var select_controller_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "SelectController",
|
|
__name: "select-controller",
|
|
props: selectControllerProps,
|
|
emits: selectControllerEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const nsSelect = useNamespace("calendar-select");
|
|
const { t, lang } = useLocale();
|
|
const monthOptions = Array.from({ length: 12 }, (_2, index) => {
|
|
const actualMonth = index + 1;
|
|
return {
|
|
value: actualMonth,
|
|
label: isFunction(props2.formatter) ? props2.formatter(actualMonth, "month") : actualMonth
|
|
};
|
|
});
|
|
const yearValue = computed(() => props2.date.year());
|
|
const monthValue = computed(() => props2.date.month() + 1);
|
|
const yearOptions = computed(() => {
|
|
const years = [];
|
|
for (let i = -10; i < 10; i++) {
|
|
const year = yearValue.value + i;
|
|
if (year > 0) {
|
|
const label = isFunction(props2.formatter) ? props2.formatter(year, "year") : year;
|
|
years.push({
|
|
value: year,
|
|
label
|
|
});
|
|
}
|
|
}
|
|
return years;
|
|
});
|
|
const handleYearChange = (year) => {
|
|
emit("date-change", (0, import_dayjs7.default)(new Date(year, monthValue.value - 1, 1)).locale(lang.value));
|
|
};
|
|
const handleMonthChange = (month) => {
|
|
emit("date-change", (0, import_dayjs7.default)(new Date(yearValue.value, month - 1, 1)).locale(lang.value));
|
|
};
|
|
const selectToday = () => {
|
|
emit("date-change", "today");
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock(Fragment, null, [
|
|
createVNode(unref(ElSelect), {
|
|
"model-value": yearValue.value,
|
|
size: "small",
|
|
class: normalizeClass(unref(nsSelect).e("year")),
|
|
"validate-event": false,
|
|
options: yearOptions.value,
|
|
onChange: handleYearChange
|
|
}, null, 8, [
|
|
"model-value",
|
|
"class",
|
|
"options"
|
|
]),
|
|
createVNode(unref(ElSelect), {
|
|
"model-value": monthValue.value,
|
|
size: "small",
|
|
class: normalizeClass(unref(nsSelect).e("month")),
|
|
"validate-event": false,
|
|
options: unref(monthOptions),
|
|
onChange: handleMonthChange
|
|
}, null, 8, [
|
|
"model-value",
|
|
"class",
|
|
"options"
|
|
]),
|
|
createVNode(unref(ElButton), {
|
|
size: "small",
|
|
onClick: selectToday
|
|
}, {
|
|
default: withCtx(() => [createTextVNode(toDisplayString(unref(t)("el.datepicker.today")), 1)]),
|
|
_: 1
|
|
})
|
|
], 64);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/calendar/src/select-controller2.mjs
|
|
var select_controller_default = select_controller_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/calendar/src/calendar.vue_vue_type_script_setup_true_lang.mjs
|
|
var COMPONENT_NAME11 = "ElCalendar";
|
|
var calendar_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: COMPONENT_NAME11,
|
|
__name: "calendar",
|
|
props: calendarProps,
|
|
emits: calendarEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const ns = useNamespace("calendar");
|
|
const { calculateValidatedDateRange, date: date4, pickDay, realSelectedDay, selectDate, validatedRange, handleDateChange } = useCalendar(__props, __emit, COMPONENT_NAME11);
|
|
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: i18nDate.value }, () => [createBaseVNode("div", { class: normalizeClass(unref(ns).e("title")) }, toDisplayString(i18nDate.value), 3), unref(validatedRange).length === 0 && __props.controllerType === "button" ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("button-group"))
|
|
}, [createVNode(unref(ElButtonGroup), null, {
|
|
default: withCtx(() => [
|
|
createVNode(unref(ElButton), {
|
|
size: "small",
|
|
onClick: _cache[0] || (_cache[0] = ($event) => unref(selectDate)("prev-month"))
|
|
}, {
|
|
default: withCtx(() => [createTextVNode(toDisplayString(unref(t)("el.datepicker.prevMonth")), 1)]),
|
|
_: 1
|
|
}),
|
|
createVNode(unref(ElButton), {
|
|
size: "small",
|
|
onClick: _cache[1] || (_cache[1] = ($event) => unref(selectDate)("today"))
|
|
}, {
|
|
default: withCtx(() => [createTextVNode(toDisplayString(unref(t)("el.datepicker.today")), 1)]),
|
|
_: 1
|
|
}),
|
|
createVNode(unref(ElButton), {
|
|
size: "small",
|
|
onClick: _cache[2] || (_cache[2] = ($event) => unref(selectDate)("next-month"))
|
|
}, {
|
|
default: withCtx(() => [createTextVNode(toDisplayString(unref(t)("el.datepicker.nextMonth")), 1)]),
|
|
_: 1
|
|
})
|
|
]),
|
|
_: 1
|
|
})], 2)) : unref(validatedRange).length === 0 && __props.controllerType === "select" ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("select-controller"))
|
|
}, [createVNode(select_controller_default, {
|
|
date: unref(date4),
|
|
formatter: __props.formatter,
|
|
onDateChange: unref(handleDateChange)
|
|
}, null, 8, [
|
|
"date",
|
|
"formatter",
|
|
"onDateChange"
|
|
])], 2)) : createCommentVNode("v-if", true)])], 2), unref(validatedRange).length === 0 ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("body"))
|
|
}, [createVNode(date_table_default, {
|
|
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)))]),
|
|
key: "0"
|
|
} : 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(date_table_default, {
|
|
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", mergeProps({ ref_for: true }, data))]),
|
|
key: "0"
|
|
} : void 0]), 1032, [
|
|
"date",
|
|
"selected-day",
|
|
"range",
|
|
"hide-header",
|
|
"onPick"
|
|
]);
|
|
}), 128))], 2))], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/calendar/src/calendar2.mjs
|
|
var calendar_default2 = calendar_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/calendar/index.mjs
|
|
var ElCalendar = withInstall(calendar_default2);
|
|
|
|
// 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: void 0
|
|
}
|
|
});
|
|
var cardContextKey = Symbol("cardContextKey");
|
|
|
|
// node_modules/element-plus/es/components/card/src/card.vue_vue_type_script_setup_true_lang.mjs
|
|
var card_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElCard",
|
|
__name: "card",
|
|
props: cardProps,
|
|
setup(__props) {
|
|
const globalConfig2 = useGlobalConfig("card");
|
|
const ns = useNamespace("card");
|
|
return (_ctx, _cache) => {
|
|
var _a;
|
|
return openBlock(), createElementBlock("div", { class: normalizeClass([unref(ns).b(), unref(ns).is(`${__props.shadow || ((_a = unref(globalConfig2)) == null ? void 0 : _a.shadow) || "always"}-shadow`)]) }, [
|
|
_ctx.$slots.header || __props.header ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("header"), __props.headerClass])
|
|
}, [renderSlot(_ctx.$slots, "header", {}, () => [createTextVNode(toDisplayString(__props.header), 1)])], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([unref(ns).e("body"), __props.bodyClass]),
|
|
style: normalizeStyle(__props.bodyStyle)
|
|
}, [renderSlot(_ctx.$slots, "default")], 6),
|
|
_ctx.$slots.footer || __props.footer ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass([unref(ns).e("footer"), __props.footerClass])
|
|
}, [renderSlot(_ctx.$slots, "footer", {}, () => [createTextVNode(toDisplayString(__props.footer), 1)])], 2)) : createCommentVNode("v-if", true)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/card/src/card2.mjs
|
|
var card_default = card_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/card/index.mjs
|
|
var ElCard = withInstall(card_default);
|
|
|
|
// 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/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, ChildrenSorter: ItemsSorter } = 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 _a, _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 = (_a = _items[nextItemIndex]) == null ? void 0 : _a.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 || !hover.value)
|
|
startTimer();
|
|
}
|
|
function setContainerHeight(height) {
|
|
if (props2.height !== "auto")
|
|
return;
|
|
containerHeight.value = height;
|
|
}
|
|
function PlaceholderItem() {
|
|
var _a;
|
|
const defaultSlots = (_a = slots.default) == null ? void 0 : _a.call(slots);
|
|
if (!defaultSlots)
|
|
return null;
|
|
const normalizeSlots = flattedChildren(defaultSlots).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);
|
|
});
|
|
const exposeActiveIndex = computed({
|
|
get: () => {
|
|
return isItemsTwoLength.value ? activeIndex.value % 2 : activeIndex.value;
|
|
},
|
|
set: (value) => activeIndex.value = value
|
|
});
|
|
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,
|
|
exposeActiveIndex,
|
|
arrowDisplay,
|
|
hasLabel,
|
|
hover,
|
|
isCardType,
|
|
items,
|
|
isVertical,
|
|
containerStyle,
|
|
isItemsTwoLength,
|
|
handleButtonEnter,
|
|
handleButtonLeave,
|
|
handleIndicatorClick,
|
|
handleMouseEnter,
|
|
handleMouseLeave,
|
|
setActiveItem,
|
|
prev,
|
|
next,
|
|
PlaceholderItem,
|
|
isTwoLengthShow,
|
|
ItemsSorter,
|
|
throttledArrowClick,
|
|
throttledIndicatorHover
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/carousel/src/carousel.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_115 = ["aria-label"];
|
|
var _hoisted_29 = ["aria-label"];
|
|
var _hoisted_33 = ["onMouseenter", "onClick"];
|
|
var _hoisted_4 = ["aria-label"];
|
|
var _hoisted_5 = { key: 0 };
|
|
var _hoisted_6 = {
|
|
key: 2,
|
|
xmlns: "http://www.w3.org/2000/svg",
|
|
version: "1.1",
|
|
style: { "display": "none" }
|
|
};
|
|
var COMPONENT_NAME12 = "ElCarousel";
|
|
var carousel_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: COMPONENT_NAME12,
|
|
__name: "carousel",
|
|
props: carouselProps,
|
|
emits: carouselEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const { root: root2, activeIndex, exposeActiveIndex, arrowDisplay, hasLabel, hover, isCardType, items, isVertical, containerStyle, handleButtonEnter, handleButtonLeave, handleIndicatorClick, handleMouseEnter, handleMouseLeave, setActiveItem, prev, next, PlaceholderItem, isTwoLengthShow, ItemsSorter, throttledArrowClick, throttledIndicatorHover } = useCarousel(props2, __emit, COMPONENT_NAME12);
|
|
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"));
|
|
classes.push(ns.is("vertical-outside", unref(isVertical) && props2.indicatorPosition === "outside"));
|
|
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: exposeActiveIndex,
|
|
setActiveItem,
|
|
prev,
|
|
next
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "root",
|
|
ref: root2,
|
|
class: normalizeClass(carouselClasses.value),
|
|
onMouseenter: _cache[6] || (_cache[6] = withModifiers((...args) => unref(handleMouseEnter) && unref(handleMouseEnter)(...args), ["stop"])),
|
|
onMouseleave: _cache[7] || (_cache[7] = withModifiers((...args) => unref(handleMouseLeave) && unref(handleMouseLeave)(...args), ["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: _cache[0] || (_cache[0] = ($event) => unref(handleButtonEnter)("left")),
|
|
onMouseleave: _cache[1] || (_cache[1] = (...args) => unref(handleButtonLeave) && unref(handleButtonLeave)(...args)),
|
|
onClick: _cache[2] || (_cache[2] = withModifiers(($event) => unref(throttledArrowClick)(unref(activeIndex) - 1), ["stop"]))
|
|
}, [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(arrow_left_default))]),
|
|
_: 1
|
|
})], 42, _hoisted_115), [[vShow, (__props.arrow === "always" || unref(hover)) && (__props.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: _cache[3] || (_cache[3] = ($event) => unref(handleButtonEnter)("right")),
|
|
onMouseleave: _cache[4] || (_cache[4] = (...args) => unref(handleButtonLeave) && unref(handleButtonLeave)(...args)),
|
|
onClick: _cache[5] || (_cache[5] = withModifiers(($event) => unref(throttledArrowClick)(unref(activeIndex) + 1), ["stop"]))
|
|
}, [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(arrow_right_default))]),
|
|
_: 1
|
|
})], 42, _hoisted_29), [[vShow, (__props.arrow === "always" || unref(hover)) && (__props.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),
|
|
createVNode(unref(ItemsSorter), null, {
|
|
default: withCtx(() => [__props.indicatorPosition !== "none" ? (openBlock(), createElementBlock("ul", {
|
|
key: 0,
|
|
class: normalizeClass(indicatorsClasses.value)
|
|
}, [(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", __props.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", _hoisted_5, toDisplayString(item.props.label), 1)) : createCommentVNode("v-if", true)], 10, _hoisted_4)], 42, _hoisted_33)), [[vShow, unref(isTwoLengthShow)(index)]]);
|
|
}), 128))], 2)) : createCommentVNode("v-if", true)]),
|
|
_: 1
|
|
}),
|
|
__props.motionBlur ? (openBlock(), createElementBlock("svg", _hoisted_6, [..._cache[8] || (_cache[8] = [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"
|
|
})])], -1)])])) : createCommentVNode("v-if", true)
|
|
], 34);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/carousel/src/carousel2.mjs
|
|
var carousel_default = carousel_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// 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 _a, _b;
|
|
const parentWidth = unref(isVertical) ? ((_a = carouselContext.root.value) == null ? void 0 : _a.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;
|
|
return ((isVertical2 ? rootEl.offsetHeight : rootEl.offsetWidth) || 0) * (index - activeIndex);
|
|
}
|
|
const translateItem = (index, activeIndex, oldIndex) => {
|
|
var _a;
|
|
const _isCardType = unref(isCardType);
|
|
const carouselItemLength = (_a = carouselContext.items.value.length) != null ? _a : 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);
|
|
}
|
|
}
|
|
const carouselItemContext = {
|
|
props: props2,
|
|
states: reactive({
|
|
hover,
|
|
translate: translate2,
|
|
scale,
|
|
active,
|
|
ready,
|
|
inStage,
|
|
animating
|
|
}),
|
|
uid: instance.uid,
|
|
getVnode: () => instance.vnode,
|
|
translateItem
|
|
};
|
|
carouselContext.addItem(carouselItemContext);
|
|
onBeforeUnmount(() => {
|
|
carouselContext.removeItem(carouselItemContext);
|
|
});
|
|
return {
|
|
carouselItemRef,
|
|
active,
|
|
animating,
|
|
hover,
|
|
inStage,
|
|
isVertical,
|
|
translate: translate2,
|
|
isCardType,
|
|
scale,
|
|
ready,
|
|
handleItemClick
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/carousel/src/carousel-item.vue_vue_type_script_setup_true_lang.mjs
|
|
var carousel_item_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: CAROUSEL_ITEM_NAME,
|
|
__name: "carousel-item",
|
|
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(() => {
|
|
return { transform: [`${`translate${unref(isVertical) ? "Y" : "X"}`}(${unref(translate2)}px)`, `scale(${unref(scale)})`].join(" ") };
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return withDirectives((openBlock(), createElementBlock("div", {
|
|
ref_key: "carouselItemRef",
|
|
ref: carouselItemRef,
|
|
class: normalizeClass(itemKls.value),
|
|
style: normalizeStyle(itemStyle.value),
|
|
onClick: _cache[0] || (_cache[0] = (...args) => unref(handleItemClick) && unref(handleItemClick)(...args))
|
|
}, [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")], 6)), [[vShow, unref(ready)]]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/carousel/src/carousel-item2.mjs
|
|
var carousel_item_default = carousel_item_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/carousel/index.mjs
|
|
var ElCarousel = withInstall(carousel_default, { CarouselItem: carousel_item_default });
|
|
var ElCarouselItem = withNoopInstall(carousel_item_default);
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/src/config.mjs
|
|
var CommonProps = buildProps({
|
|
modelValue: { type: definePropType([
|
|
Number,
|
|
String,
|
|
Array,
|
|
Object
|
|
]) },
|
|
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,
|
|
checkOnClickNode: false,
|
|
checkOnClickLeaf: true,
|
|
showPrefix: true
|
|
};
|
|
var cascaderPanelProps = buildProps({
|
|
...CommonProps,
|
|
border: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
renderLabel: { type: Function }
|
|
});
|
|
var emitChangeFn = (value) => true;
|
|
var cascaderPanelEmits = {
|
|
[UPDATE_MODEL_EVENT]: emitChangeFn,
|
|
[CHANGE_EVENT]: emitChangeFn,
|
|
close: () => true,
|
|
"expand-change": (value) => value
|
|
};
|
|
var useCascaderConfig = (props2) => {
|
|
return computed(() => ({
|
|
...DefaultProps,
|
|
...props2.props
|
|
}));
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/checkbox.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: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
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
|
|
},
|
|
ariaLabel: String,
|
|
...useAriaProps(["ariaControls"])
|
|
};
|
|
var checkboxEmits = {
|
|
[UPDATE_MODEL_EVENT]: (val) => isString(val) || isNumber2(val) || isBoolean2(val),
|
|
change: (val) => isString(val) || isNumber2(val) || isBoolean2(val)
|
|
};
|
|
var checkboxPropsDefaults = {
|
|
modelValue: void 0,
|
|
label: void 0,
|
|
value: void 0,
|
|
disabled: void 0,
|
|
name: void 0,
|
|
trueValue: void 0,
|
|
falseValue: void 0,
|
|
trueLabel: void 0,
|
|
falseLabel: void 0,
|
|
id: void 0,
|
|
validateEvent: true
|
|
};
|
|
|
|
// 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: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
min: Number,
|
|
max: Number,
|
|
size: useSizeProp,
|
|
fill: String,
|
|
textColor: String,
|
|
tag: {
|
|
type: String,
|
|
default: "div"
|
|
},
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
options: { type: definePropType(Array) },
|
|
props: {
|
|
type: definePropType(Object),
|
|
default: () => checkboxDefaultProps
|
|
},
|
|
type: {
|
|
type: String,
|
|
values: ["checkbox", "button"],
|
|
default: "checkbox"
|
|
},
|
|
...useAriaProps(["ariaLabel"])
|
|
});
|
|
var checkboxGroupEmits = {
|
|
[UPDATE_MODEL_EVENT]: (val) => isArray(val),
|
|
change: (val) => isArray(val)
|
|
};
|
|
var checkboxDefaultProps = {
|
|
label: "label",
|
|
value: "value",
|
|
disabled: "disabled"
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/composables/use-checkbox-disabled.mjs
|
|
var useCheckboxDisabled = ({ model, isChecked }) => {
|
|
const checkboxGroup = inject(checkboxGroupContextKey, void 0);
|
|
const formContext = inject(formContextKey, void 0);
|
|
const isLimitDisabled = computed(() => {
|
|
var _a, _b;
|
|
const max4 = (_a = checkboxGroup == null ? void 0 : checkboxGroup.max) == null ? void 0 : _a.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;
|
|
});
|
|
return {
|
|
isDisabled: useFormDisabled(computed(() => {
|
|
var _a, _b;
|
|
if (checkboxGroup === void 0)
|
|
return (_a = formContext == null ? void 0 : formContext.disabled) != null ? _a : isLimitDisabled.value;
|
|
else
|
|
return ((_b = checkboxGroup.disabled) == null ? void 0 : _b.value) || isLimitDisabled.value;
|
|
})),
|
|
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 _a, _b, _c, _d;
|
|
return [
|
|
true,
|
|
props2.trueValue,
|
|
props2.trueLabel
|
|
].includes(value) ? (_b = (_a = props2.trueValue) != null ? _a : 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) {
|
|
if (!e.composedPath().some((item) => item.tagName === "LABEL")) {
|
|
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, vnode } = getCurrentInstance();
|
|
const checkboxGroup = inject(checkboxGroupContextKey, void 0);
|
|
const isGroup = computed(() => isUndefined2(checkboxGroup) === false);
|
|
const isLimitExceeded = ref(false);
|
|
const isControlled = computed(() => {
|
|
var _a;
|
|
const rawProps = (_a = vnode.props) != null ? _a : {};
|
|
return "modelValue" in rawProps || "model-value" in rawProps;
|
|
});
|
|
const model = computed({
|
|
get() {
|
|
var _a;
|
|
return isGroup.value ? (_a = checkboxGroup == null ? void 0 : checkboxGroup.modelValue) == null ? void 0 : _a.value : !isControlled.value ? selfModel.value : props2.modelValue;
|
|
},
|
|
set(val) {
|
|
var _a, _b;
|
|
if (isGroup.value && isArray(val)) {
|
|
isLimitExceeded.value = ((_a = checkboxGroup == null ? void 0 : checkboxGroup.max) == null ? void 0 : _a.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;
|
|
});
|
|
return {
|
|
checkboxButtonSize: useFormSize(computed(() => {
|
|
var _a;
|
|
return (_a = checkboxGroup == null ? void 0 : checkboxGroup.size) == null ? void 0 : _a.value;
|
|
}), { prop: true }),
|
|
isChecked,
|
|
isFocused,
|
|
checkboxSize: useFormSize(computed(() => {
|
|
var _a;
|
|
return (_a = checkboxGroup == null ? void 0 : checkboxGroup.size) == null ? void 0 : _a.value;
|
|
})),
|
|
hasOwnLabel: computed(() => {
|
|
return !!slots.default || !isPropAbsent(actualValue.value);
|
|
}),
|
|
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 _a, _b;
|
|
if (isArray(model.value) && !model.value.includes(actualValue.value))
|
|
model.value.push(actualValue.value);
|
|
else
|
|
model.value = (_b = (_a = props2.trueValue) != null ? _a : 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.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_116 = [
|
|
"id",
|
|
"indeterminate",
|
|
"name",
|
|
"tabindex",
|
|
"disabled"
|
|
];
|
|
var checkbox_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElCheckbox",
|
|
__name: "checkbox",
|
|
props: checkboxProps,
|
|
emits: checkboxEmits,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const { inputId, isLabeledByFormItem, isChecked, isDisabled, isFocused, checkboxSize, hasOwnLabel, model, actualValue, handleChange, onClickRoot } = useCheckbox(props2, useSlots());
|
|
const inputBindings = computed(() => {
|
|
var _a, _b, _c, _d;
|
|
if (props2.trueValue || props2.falseValue || props2.trueLabel || props2.falseLabel)
|
|
return {
|
|
"true-value": (_b = (_a = props2.trueValue) != null ? _a : props2.trueLabel) != null ? _b : true,
|
|
"false-value": (_d = (_c = props2.falseValue) != null ? _c : props2.falseLabel) != null ? _d : false
|
|
};
|
|
return { value: actualValue.value };
|
|
});
|
|
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"), {
|
|
for: !unref(hasOwnLabel) && unref(isLabeledByFormItem) ? null : unref(inputId),
|
|
class: normalizeClass(compKls.value),
|
|
"aria-controls": __props.indeterminate ? __props.ariaControls : null,
|
|
"aria-checked": __props.indeterminate ? "mixed" : void 0,
|
|
"aria-label": __props.ariaLabel,
|
|
onClick: unref(onClickRoot)
|
|
}, {
|
|
default: withCtx(() => [createBaseVNode("span", { class: normalizeClass(spanKls.value) }, [withDirectives(createBaseVNode("input", mergeProps({
|
|
id: unref(inputId),
|
|
"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(model) ? model.value = $event : null),
|
|
class: unref(ns).e("original"),
|
|
type: "checkbox",
|
|
indeterminate: __props.indeterminate,
|
|
name: __props.name,
|
|
tabindex: __props.tabindex,
|
|
disabled: unref(isDisabled)
|
|
}, inputBindings.value, {
|
|
onChange: _cache[1] || (_cache[1] = (...args) => unref(handleChange) && unref(handleChange)(...args)),
|
|
onFocus: _cache[2] || (_cache[2] = ($event) => isFocused.value = true),
|
|
onBlur: _cache[3] || (_cache[3] = ($event) => isFocused.value = false),
|
|
onClick: _cache[4] || (_cache[4] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}), null, 16, _hoisted_116), [[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(__props.label), 1)], 64)) : createCommentVNode("v-if", true)], 2)) : createCommentVNode("v-if", true)]),
|
|
_: 3
|
|
}, 8, [
|
|
"for",
|
|
"class",
|
|
"aria-controls",
|
|
"aria-checked",
|
|
"aria-label",
|
|
"onClick"
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/checkbox2.mjs
|
|
var checkbox_default = checkbox_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/checkbox-button.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_117 = [
|
|
"name",
|
|
"tabindex",
|
|
"disabled"
|
|
];
|
|
var checkbox_button_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElCheckboxButton",
|
|
__name: "checkbox-button",
|
|
props: checkboxProps,
|
|
emits: checkboxEmits,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const { isFocused, isChecked, isDisabled, checkboxButtonSize, model, actualValue, handleChange } = useCheckbox(props2, useSlots());
|
|
const inputBindings = computed(() => {
|
|
var _a, _b, _c, _d;
|
|
if (props2.trueValue || props2.falseValue || props2.trueLabel || props2.falseLabel)
|
|
return {
|
|
"true-value": (_b = (_a = props2.trueValue) != null ? _a : props2.trueLabel) != null ? _b : true,
|
|
"false-value": (_d = (_c = props2.falseValue) != null ? _c : props2.falseLabel) != null ? _d : false
|
|
};
|
|
return { value: actualValue.value };
|
|
});
|
|
const checkboxGroup = inject(checkboxGroupContextKey, void 0);
|
|
const ns = useNamespace("checkbox");
|
|
const activeStyle = computed(() => {
|
|
var _a, _b, _c, _d;
|
|
const fillValue = (_b = (_a = checkboxGroup == null ? void 0 : checkboxGroup.fill) == null ? void 0 : _a.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) => {
|
|
return openBlock(), createElementBlock("label", { class: normalizeClass(labelKls.value) }, [withDirectives(createBaseVNode("input", mergeProps({
|
|
"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(model) ? model.value = $event : null),
|
|
class: unref(ns).be("button", "original"),
|
|
type: "checkbox",
|
|
name: __props.name,
|
|
tabindex: __props.tabindex,
|
|
disabled: unref(isDisabled)
|
|
}, inputBindings.value, {
|
|
onChange: _cache[1] || (_cache[1] = (...args) => unref(handleChange) && unref(handleChange)(...args)),
|
|
onFocus: _cache[2] || (_cache[2] = ($event) => isFocused.value = true),
|
|
onBlur: _cache[3] || (_cache[3] = ($event) => isFocused.value = false),
|
|
onClick: _cache[4] || (_cache[4] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}), null, 16, _hoisted_117), [[vModelCheckbox, unref(model)]]), _ctx.$slots.default || __props.label ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).be("button", "inner")),
|
|
style: normalizeStyle(unref(isChecked) ? activeStyle.value : void 0)
|
|
}, [renderSlot(_ctx.$slots, "default", {}, () => [createTextVNode(toDisplayString(__props.label), 1)])], 6)) : createCommentVNode("v-if", true)], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/checkbox-button.mjs
|
|
var checkbox_button_default = checkbox_button_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/checkbox-group.vue_vue_type_script_setup_true_lang.mjs
|
|
var checkbox_group_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElCheckboxGroup",
|
|
__name: "checkbox-group",
|
|
props: checkboxGroupProps,
|
|
emits: checkboxGroupEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const ns = useNamespace("checkbox");
|
|
const checkboxDisabled = useFormDisabled();
|
|
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);
|
|
}
|
|
});
|
|
const aliasProps = computed(() => ({
|
|
...checkboxDefaultProps,
|
|
...props2.props
|
|
}));
|
|
const getOptionProps = (option) => {
|
|
const { label, value, disabled } = aliasProps.value;
|
|
const base = {
|
|
label: option[label],
|
|
value: option[value],
|
|
disabled: option[disabled]
|
|
};
|
|
return {
|
|
...omit_default(option, [
|
|
label,
|
|
value,
|
|
disabled
|
|
]),
|
|
...base
|
|
};
|
|
};
|
|
const optionComponent = computed(() => props2.type === "button" ? checkbox_button_default : checkbox_default);
|
|
provide(checkboxGroupContextKey, {
|
|
...pick_default(toRefs(props2), [
|
|
"size",
|
|
"min",
|
|
"max",
|
|
"validateEvent",
|
|
"fill",
|
|
"textColor"
|
|
]),
|
|
disabled: checkboxDisabled,
|
|
modelValue,
|
|
changeEvent
|
|
});
|
|
watch(() => props2.modelValue, (newVal, oldValue) => {
|
|
if (props2.validateEvent && !isEqual_default(newVal, oldValue))
|
|
formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
|
|
});
|
|
return (_ctx, _cache) => {
|
|
var _a;
|
|
return openBlock(), createBlock(resolveDynamicComponent(__props.tag), {
|
|
id: unref(groupId),
|
|
class: normalizeClass(unref(ns).b("group")),
|
|
role: "group",
|
|
"aria-label": !unref(isLabeledByFormItem) ? __props.ariaLabel || "checkbox-group" : void 0,
|
|
"aria-labelledby": unref(isLabeledByFormItem) ? (_a = unref(formItem)) == null ? void 0 : _a.labelId : void 0
|
|
}, {
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "default", {}, () => [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.options, (item, index) => {
|
|
return openBlock(), createBlock(resolveDynamicComponent(optionComponent.value), mergeProps({ key: index }, { ref_for: true }, getOptionProps(item)), null, 16);
|
|
}), 128))])]),
|
|
_: 3
|
|
}, 8, [
|
|
"id",
|
|
"class",
|
|
"aria-label",
|
|
"aria-labelledby"
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/checkbox/src/checkbox-group2.mjs
|
|
var checkbox_group_default = checkbox_group_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/checkbox/index.mjs
|
|
var ElCheckbox = withInstall(checkbox_default, {
|
|
CheckboxButton: checkbox_button_default,
|
|
CheckboxGroup: checkbox_group_default
|
|
});
|
|
var ElCheckboxButton = withNoopInstall(checkbox_button_default);
|
|
var ElCheckboxGroup = withNoopInstall(checkbox_group_default);
|
|
|
|
// node_modules/element-plus/es/components/radio/src/radio.mjs
|
|
var radioPropsBase = buildProps({
|
|
modelValue: {
|
|
type: [
|
|
String,
|
|
Number,
|
|
Boolean
|
|
],
|
|
default: void 0
|
|
},
|
|
size: useSizeProp,
|
|
disabled: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
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)
|
|
};
|
|
var radioPropsDefaults = {
|
|
modelValue: void 0,
|
|
disabled: void 0,
|
|
label: void 0,
|
|
value: void 0,
|
|
name: void 0,
|
|
border: false
|
|
};
|
|
|
|
// 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 });
|
|
var radioButtonPropsDefaults = {
|
|
modelValue: void 0,
|
|
disabled: void 0,
|
|
label: void 0,
|
|
value: void 0,
|
|
name: void 0
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/radio/src/radio-group.mjs
|
|
var radioDefaultProps = {
|
|
label: "label",
|
|
value: "value",
|
|
disabled: "disabled"
|
|
};
|
|
var radioGroupProps = buildProps({
|
|
id: {
|
|
type: String,
|
|
default: void 0
|
|
},
|
|
size: useSizeProp,
|
|
disabled: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
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
|
|
},
|
|
options: { type: definePropType(Array) },
|
|
props: {
|
|
type: definePropType(Object),
|
|
default: () => radioDefaultProps
|
|
},
|
|
type: {
|
|
type: String,
|
|
values: ["radio", "button"],
|
|
default: "radio"
|
|
},
|
|
...useAriaProps(["ariaLabel"])
|
|
});
|
|
var radioGroupEmits = radioEmits;
|
|
var radioGroupPropsDefaults = {
|
|
id: void 0,
|
|
disabled: void 0,
|
|
modelValue: void 0,
|
|
fill: "",
|
|
textColor: "",
|
|
name: void 0,
|
|
validateEvent: true,
|
|
props: () => radioDefaultProps,
|
|
type: "radio"
|
|
};
|
|
|
|
// 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/radio.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_118 = [
|
|
"value",
|
|
"name",
|
|
"disabled",
|
|
"checked"
|
|
];
|
|
var radio_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElRadio",
|
|
__name: "radio",
|
|
props: radioProps,
|
|
emits: radioEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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 _a;
|
|
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", __props.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": _cache[0] || (_cache[0] = ($event) => isRef(modelValue) ? modelValue.value = $event : null),
|
|
class: normalizeClass(unref(ns).e("original")),
|
|
value: unref(actualValue),
|
|
name: __props.name || ((_a = unref(radioGroup)) == null ? void 0 : _a.name),
|
|
disabled: unref(disabled),
|
|
checked: unref(modelValue) === unref(actualValue),
|
|
type: "radio",
|
|
onFocus: _cache[1] || (_cache[1] = ($event) => focus.value = true),
|
|
onBlur: _cache[2] || (_cache[2] = ($event) => focus.value = false),
|
|
onChange: handleChange,
|
|
onClick: _cache[3] || (_cache[3] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}, null, 42, _hoisted_118), [[vModelRadio, unref(modelValue)]]), createBaseVNode("span", { class: normalizeClass(unref(ns).e("inner")) }, null, 2)], 2), createBaseVNode("span", {
|
|
class: normalizeClass(unref(ns).e("label")),
|
|
onKeydown: _cache[4] || (_cache[4] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}, [renderSlot(_ctx.$slots, "default", {}, () => [createTextVNode(toDisplayString(__props.label), 1)])], 34)], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/radio/src/radio2.mjs
|
|
var radio_default = radio_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/radio/src/radio-button.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_119 = [
|
|
"value",
|
|
"name",
|
|
"disabled"
|
|
];
|
|
var radio_button_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElRadioButton",
|
|
__name: "radio-button",
|
|
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 _a;
|
|
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": _cache[0] || (_cache[0] = ($event) => isRef(modelValue) ? modelValue.value = $event : null),
|
|
class: normalizeClass(unref(ns).be("button", "original-radio")),
|
|
value: unref(actualValue),
|
|
type: "radio",
|
|
name: __props.name || ((_a = unref(radioGroup)) == null ? void 0 : _a.name),
|
|
disabled: unref(disabled),
|
|
onFocus: _cache[1] || (_cache[1] = ($event) => focus.value = true),
|
|
onBlur: _cache[2] || (_cache[2] = ($event) => focus.value = false),
|
|
onClick: _cache[3] || (_cache[3] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}, null, 42, _hoisted_119), [[vModelRadio, unref(modelValue)]]), createBaseVNode("span", {
|
|
class: normalizeClass(unref(ns).be("button", "inner")),
|
|
style: normalizeStyle(unref(modelValue) === unref(actualValue) ? activeStyle.value : {}),
|
|
onKeydown: _cache[4] || (_cache[4] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}, [renderSlot(_ctx.$slots, "default", {}, () => [createTextVNode(toDisplayString(__props.label), 1)])], 38)], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/radio/src/radio-button2.mjs
|
|
var radio_button_default = radio_button_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/radio/src/radio-group.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_120 = [
|
|
"id",
|
|
"aria-label",
|
|
"aria-labelledby"
|
|
];
|
|
var radio_group_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElRadioGroup",
|
|
__name: "radio-group",
|
|
props: radioGroupProps,
|
|
emits: radioGroupEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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;
|
|
});
|
|
const aliasProps = computed(() => ({
|
|
...radioDefaultProps,
|
|
...props2.props
|
|
}));
|
|
const getOptionProps = (option) => {
|
|
const { label, value, disabled } = aliasProps.value;
|
|
const base = {
|
|
label: option[label],
|
|
value: option[value],
|
|
disabled: option[disabled]
|
|
};
|
|
return {
|
|
...omit_default(option, [
|
|
label,
|
|
value,
|
|
disabled
|
|
]),
|
|
...base
|
|
};
|
|
};
|
|
const optionComponent = computed(() => props2.type === "button" ? radio_button_default : radio_default);
|
|
provide(radioGroupKey, reactive({
|
|
...toRefs(props2),
|
|
changeEvent,
|
|
name
|
|
}));
|
|
watch(() => props2.modelValue, (newVal, oldValue) => {
|
|
if (props2.validateEvent && !isEqual_default(newVal, oldValue))
|
|
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) ? __props.ariaLabel || "radio-group" : void 0,
|
|
"aria-labelledby": unref(isLabeledByFormItem) ? unref(formItem).labelId : void 0
|
|
}, [renderSlot(_ctx.$slots, "default", {}, () => [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.options, (item, index) => {
|
|
return openBlock(), createBlock(resolveDynamicComponent(optionComponent.value), mergeProps({ key: index }, { ref_for: true }, getOptionProps(item)), null, 16);
|
|
}), 128))])], 10, _hoisted_120);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/radio/src/radio-group2.mjs
|
|
var radio_group_default = radio_group_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/radio/index.mjs
|
|
var ElRadio = withInstall(radio_default, {
|
|
RadioButton: radio_button_default,
|
|
RadioGroup: radio_group_default
|
|
});
|
|
var ElRadioGroup = withNoopInstall(radio_group_default);
|
|
var ElRadioButton = withNoopInstall(radio_button_default);
|
|
|
|
// 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/node-content.mjs
|
|
function isVNodeEmpty(vnodes) {
|
|
return !!(isArray(vnodes) ? vnodes.every(({ type: type4 }) => type4 === Comment) : (vnodes == null ? void 0 : vnodes.type) === Comment);
|
|
}
|
|
var node_content_default = defineComponent({
|
|
name: "NodeContent",
|
|
props: { node: {
|
|
type: Object,
|
|
required: true
|
|
} },
|
|
setup(props2) {
|
|
const ns = useNamespace("cascader-node");
|
|
const { renderLabelFn } = inject(CASCADER_PANEL_INJECTION_KEY);
|
|
const { node } = props2;
|
|
const { data, label: nodeLabel } = node;
|
|
const label = () => {
|
|
const renderLabel = renderLabelFn == null ? void 0 : renderLabelFn({
|
|
node,
|
|
data
|
|
});
|
|
return isVNodeEmpty(renderLabel) ? nodeLabel : renderLabel != null ? renderLabel : nodeLabel;
|
|
};
|
|
return () => createVNode("span", { "class": ns.e("label") }, [label()]);
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/src/node.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_121 = [
|
|
"id",
|
|
"aria-haspopup",
|
|
"aria-owns",
|
|
"aria-expanded",
|
|
"tabindex"
|
|
];
|
|
var node_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElCascaderNode",
|
|
__name: "node",
|
|
props: {
|
|
node: {
|
|
type: Object,
|
|
required: true
|
|
},
|
|
menuId: String
|
|
},
|
|
emits: ["expand"],
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __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 showPrefix = computed(() => panel.config.showPrefix);
|
|
const checkedNodeId = computed(() => {
|
|
var _a;
|
|
return (_a = panel.checkedNodes[0]) == null ? void 0 : _a.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 _a;
|
|
const { level, uid: uid2 } = props2.node;
|
|
return ((_a = node == null ? void 0 : node.pathNodes[level - 1]) == null ? void 0 : _a.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 (isLeaf2.value && !isDisabled.value && !checkStrictly.value && !multiple.value)
|
|
handleCheck(true);
|
|
else if ((panel.config.checkOnClickNode && (multiple.value || checkStrictly.value) || isLeaf2.value && panel.config.checkOnClickLeaf) && !isDisabled.value)
|
|
handleSelectCheck(!props2.node.checked);
|
|
else if (!isHoverMenu.value)
|
|
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 (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("li", {
|
|
id: `${__props.menuId}-${__props.node.uid}`,
|
|
role: "menuitem",
|
|
"aria-haspopup": !isLeaf2.value,
|
|
"aria-owns": isLeaf2.value ? void 0 : __props.menuId,
|
|
"aria-expanded": inExpandingPath.value,
|
|
tabindex: expandable.value ? -1 : void 0,
|
|
class: normalizeClass([
|
|
unref(ns).b(),
|
|
unref(ns).is("selectable", checkStrictly.value),
|
|
unref(ns).is("active", __props.node.checked),
|
|
unref(ns).is("disabled", !expandable.value),
|
|
inExpandingPath.value && "in-active-path",
|
|
inCheckedPath.value && "in-checked-path"
|
|
]),
|
|
onMouseenter: handleHoverExpand,
|
|
onFocus: handleHoverExpand,
|
|
onClick: handleClick
|
|
}, [
|
|
createCommentVNode(" prefix "),
|
|
multiple.value && showPrefix.value ? (openBlock(), createBlock(unref(ElCheckbox), {
|
|
key: 0,
|
|
"model-value": __props.node.checked,
|
|
indeterminate: __props.node.indeterminate,
|
|
disabled: isDisabled.value,
|
|
onClick: _cache[0] || (_cache[0] = withModifiers(() => {
|
|
}, ["stop"])),
|
|
"onUpdate:modelValue": handleSelectCheck
|
|
}, null, 8, [
|
|
"model-value",
|
|
"indeterminate",
|
|
"disabled"
|
|
])) : checkStrictly.value && showPrefix.value ? (openBlock(), createBlock(unref(ElRadio), {
|
|
key: 1,
|
|
"model-value": checkedNodeId.value,
|
|
label: __props.node.uid,
|
|
disabled: isDisabled.value,
|
|
"onUpdate:modelValue": handleSelectCheck,
|
|
onClick: _cache[1] || (_cache[1] = 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 "), _cache[2] || (_cache[2] = createBaseVNode("span", null, null, -1))]),
|
|
_: 1
|
|
}, 8, [
|
|
"model-value",
|
|
"label",
|
|
"disabled"
|
|
])) : isLeaf2.value && __props.node.checked ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 2,
|
|
class: normalizeClass(unref(ns).e("prefix"))
|
|
}, {
|
|
default: withCtx(() => [createVNode(unref(check_default))]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true),
|
|
createCommentVNode(" content "),
|
|
createVNode(unref(node_content_default), { node: __props.node }, null, 8, ["node"]),
|
|
createCommentVNode(" postfix "),
|
|
!isLeaf2.value ? (openBlock(), createElementBlock(Fragment, { key: 3 }, [__props.node.loading ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).is("loading"), unref(ns).e("postfix")])
|
|
}, {
|
|
default: withCtx(() => [createVNode(unref(loading_default))]),
|
|
_: 1
|
|
}, 8, ["class"])) : (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 1,
|
|
class: normalizeClass(["arrow-right", unref(ns).e("postfix")])
|
|
}, {
|
|
default: withCtx(() => [createVNode(unref(arrow_right_default))]),
|
|
_: 1
|
|
}, 8, ["class"]))], 64)) : createCommentVNode("v-if", true)
|
|
], 42, _hoisted_121);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/src/node2.mjs
|
|
var node_default = node_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/src/menu.vue_vue_type_script_setup_true_lang.mjs
|
|
var menu_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElCascaderMenu",
|
|
__name: "menu",
|
|
props: {
|
|
nodes: {
|
|
type: Array,
|
|
required: true
|
|
},
|
|
index: {
|
|
type: Number,
|
|
required: true
|
|
}
|
|
},
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const instance = getCurrentInstance();
|
|
const ns = useNamespace("cascader-menu");
|
|
const { t } = useLocale();
|
|
const id = useId();
|
|
let activeNode;
|
|
let hoverTimer;
|
|
const panel = inject(CASCADER_PANEL_INJECTION_KEY);
|
|
const hoverZone = ref();
|
|
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) => {
|
|
var _a;
|
|
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;
|
|
const scrollTop = ((_a = el.querySelector(`.${ns.e("wrap")}`)) == null ? void 0 : _a.scrollTop) || 0;
|
|
hoverZone.value.innerHTML = `
|
|
<path style="pointer-events: auto;" fill="transparent" d="M${startX} ${top} L${offsetWidth} ${scrollTop} V${top} Z" />
|
|
<path style="pointer-events: auto;" fill="transparent" d="M${startX} ${bottom} L${offsetWidth} ${offsetHeight + scrollTop} V${bottom} Z" />
|
|
`;
|
|
} else if (!hoverTimer)
|
|
hoverTimer = window.setTimeout(clearHoverZone, panel.config.hoverThreshold);
|
|
};
|
|
const clearHoverTimer = () => {
|
|
if (!hoverTimer)
|
|
return;
|
|
clearTimeout(hoverTimer);
|
|
hoverTimer = void 0;
|
|
};
|
|
const clearHoverZone = () => {
|
|
if (!hoverZone.value)
|
|
return;
|
|
hoverZone.value.innerHTML = "";
|
|
clearHoverTimer();
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElScrollbar), {
|
|
key: menuId.value,
|
|
tag: "ul",
|
|
role: "menu",
|
|
class: normalizeClass(unref(ns).b()),
|
|
"wrap-class": unref(ns).e("wrap"),
|
|
"view-class": [unref(ns).e("list"), unref(ns).is("empty", isEmpty3.value)],
|
|
onMousemove: handleMouseMove,
|
|
onMouseleave: clearHoverZone
|
|
}, {
|
|
default: withCtx(() => {
|
|
var _a;
|
|
return [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(__props.nodes, (node) => {
|
|
return openBlock(), createBlock(node_default, {
|
|
key: node.uid,
|
|
node,
|
|
"menu-id": menuId.value,
|
|
onExpand: handleExpand
|
|
}, null, 8, ["node", "menu-id"]);
|
|
}), 128)),
|
|
isLoading.value ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("empty-text"))
|
|
}, [createVNode(unref(ElIcon), {
|
|
size: "14",
|
|
class: normalizeClass(unref(ns).is("loading"))
|
|
}, {
|
|
default: withCtx(() => [createVNode(unref(loading_default))]),
|
|
_: 1
|
|
}, 8, ["class"]), createTextVNode(" " + toDisplayString(unref(t)("el.cascader.loading")), 1)], 2)) : isEmpty3.value ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("empty-text"))
|
|
}, [renderSlot(_ctx.$slots, "empty", {}, () => [createTextVNode(toDisplayString(unref(t)("el.cascader.noData")), 1)])], 2)) : ((_a = unref(panel)) == null ? void 0 : _a.isHoverMenu) ? (openBlock(), createElementBlock(Fragment, { key: 2 }, [createCommentVNode(" eslint-disable vue/html-self-closing "), (openBlock(), createElementBlock("svg", {
|
|
ref_key: "hoverZone",
|
|
ref: hoverZone,
|
|
class: normalizeClass(unref(ns).e("hover-zone"))
|
|
}, null, 2))], 2112)) : createCommentVNode("v-if", true),
|
|
createCommentVNode(" eslint-enable vue/html-self-closing ")
|
|
];
|
|
}),
|
|
_: 3
|
|
}, 8, [
|
|
"class",
|
|
"wrap-class",
|
|
"view-class"
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/src/menu.mjs
|
|
var menu_default = menu_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/src/node.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 Node3 {
|
|
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 Node3(child, config, this));
|
|
this.loaded = !config.lazy || this.isLeaf || !isEmpty2(childrenData);
|
|
this.text = "";
|
|
}
|
|
get isDisabled() {
|
|
const { data, parent: parent2, config } = this;
|
|
const { disabled, checkStrictly } = config;
|
|
return (isFunction(disabled) ? disabled(data, this) : !!data[disabled]) || !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 Node3(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(checked) {
|
|
this.children.forEach((child) => {
|
|
var _a;
|
|
if (child) {
|
|
child.broadcast(checked);
|
|
(_a = child.onParentCheck) == null ? void 0 : _a.call(child, checked);
|
|
}
|
|
});
|
|
}
|
|
emit() {
|
|
var _a;
|
|
const { parent: parent2 } = this;
|
|
if (parent2) {
|
|
(_a = parent2.onChildCheck) == null ? void 0 : _a.call(parent2);
|
|
parent2.emit();
|
|
}
|
|
}
|
|
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) => {
|
|
return c2 + (p2.checked ? 1 : p2.indeterminate ? 0.5 : 0);
|
|
}, 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(checked);
|
|
this.setCheckState(checked);
|
|
this.emit();
|
|
}
|
|
}
|
|
};
|
|
|
|
// 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) {
|
|
if (nodeDataList.length > 0)
|
|
nodeDataList.forEach((nodeData) => this.appendNode(nodeData, parentNode));
|
|
else
|
|
parentNode && parentNode.isLeaf && this.leafNodes.push(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;
|
|
return this.getFlattedNodes(leafOnly).find((node) => isEqual_default(node.value, value) || isEqual_default(node.pathValues, value)) || null;
|
|
}
|
|
getSameNode(node) {
|
|
if (!node)
|
|
return null;
|
|
return this.getFlattedNodes(false).find(({ value, level }) => isEqual_default(node.value, value) && node.level === level) || 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/components/cascader-panel/src/index.vue_vue_type_script_setup_true_lang.mjs
|
|
var index_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElCascaderPanel",
|
|
__name: "index",
|
|
props: cascaderPanelProps,
|
|
emits: cascaderPanelEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
let manualChecked = false;
|
|
const ns = useNamespace("cascader");
|
|
const config = useCascaderConfig(props2);
|
|
const slots = useSlots();
|
|
let store;
|
|
const initialLoaded = ref(true);
|
|
const initialLoadedOnce = ref(false);
|
|
const menuList = ref([]);
|
|
const checkedValue = ref();
|
|
const menus = ref([]);
|
|
const expandingNode = ref();
|
|
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;
|
|
_node.loading = false;
|
|
_node.loaded = true;
|
|
_node.childrenData = _node.childrenData || [];
|
|
dataList && (store == null ? void 0 : store.appendNodes(dataList, parent2));
|
|
dataList && (cb == null ? void 0 : cb(dataList));
|
|
if (node.level === 0)
|
|
initialLoadedOnce.value = true;
|
|
};
|
|
const reject2 = () => {
|
|
node.loading = false;
|
|
node.loaded = false;
|
|
if (node.level === 0)
|
|
initialLoaded.value = true;
|
|
};
|
|
cfg.lazyLoad(node, resolve, reject2);
|
|
};
|
|
const expandNode = (node, silent) => {
|
|
var _a;
|
|
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 (((_a = expandingNode.value) == null ? void 0 : _a.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 && expandParentNode(node);
|
|
};
|
|
const expandParentNode = (node) => {
|
|
if (!node)
|
|
return;
|
|
node = node.parent;
|
|
expandParentNode(node);
|
|
node && expandNode(node);
|
|
};
|
|
const getFlattedNodes = (leafOnly) => store == null ? void 0 : store.getFlattedNodes(leafOnly);
|
|
const getCheckedNodes = (leafOnly) => {
|
|
var _a;
|
|
return (_a = getFlattedNodes(leafOnly)) == null ? void 0 : _a.filter(({ checked }) => checked !== false);
|
|
};
|
|
const clearCheckedNodes = () => {
|
|
checkedNodes.value.forEach((node) => node.doCheck(false));
|
|
calculateCheckedValue();
|
|
menus.value = menus.value.slice(0, 1);
|
|
expandingNode.value = void 0;
|
|
emit("expand-change", []);
|
|
};
|
|
const calculateCheckedValue = () => {
|
|
var _a;
|
|
const { checkStrictly, multiple } = config.value;
|
|
const oldNodes = checkedNodes.value;
|
|
const nodes = sortByOriginalOrder(oldNodes, getCheckedNodes(!checkStrictly));
|
|
const values2 = nodes.map((node) => node.valueByOption);
|
|
checkedNodes.value = nodes;
|
|
checkedValue.value = multiple ? values2 : (_a = values2[0]) != null ? _a : 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 nodes = unique(flattenDeep_default(castArray2(modelValue))).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 {
|
|
syncMenuState(unique((multiple ? castArray2(modelValue) : [modelValue]).map((val) => store == null ? void 0 : store.getNodeByValue(val, leafOnly))), forced);
|
|
checkedValue.value = cloneDeep_default(modelValue != null ? modelValue : void 0);
|
|
}
|
|
};
|
|
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 = void 0;
|
|
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`);
|
|
let activeNode = menuElement.querySelector(`.${ns.b("node")}.in-active-path`);
|
|
if (!activeNode) {
|
|
const activeElements = menuElement.querySelectorAll(`.${ns.b("node")}.${ns.is("active")}`);
|
|
activeNode = activeElements[activeElements.length - 1];
|
|
}
|
|
scrollIntoView(container, activeNode);
|
|
}
|
|
});
|
|
};
|
|
const handleKeyDown = (e) => {
|
|
var _a, _b;
|
|
const target2 = e.target;
|
|
const code = getEventCode(e);
|
|
switch (code) {
|
|
case EVENT_CODE.up:
|
|
case EVENT_CODE.down:
|
|
e.preventDefault();
|
|
focusNode(getSibling(target2, code === EVENT_CODE.up ? -1 : 1, `.${ns.b("node")}[tabindex="-1"]`));
|
|
break;
|
|
case EVENT_CODE.left: {
|
|
e.preventDefault();
|
|
const expandedNode = (_a = menuList.value[getMenuIndex(target2) - 1]) == null ? void 0 : _a.$el.querySelector(`.${ns.b("node")}[aria-expanded="true"]`);
|
|
focusNode(expandedNode);
|
|
break;
|
|
}
|
|
case EVENT_CODE.right: {
|
|
e.preventDefault();
|
|
const firstNode = (_b = menuList.value[getMenuIndex(target2) + 1]) == null ? void 0 : _b.$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, (newVal, oldVal) => {
|
|
if (isEqual_default(newVal, oldVal))
|
|
return;
|
|
initStore();
|
|
}, { immediate: true });
|
|
watch(() => props2.options, initStore, { deep: 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);
|
|
}
|
|
});
|
|
const loadLazyRootNodes = () => {
|
|
if (initialLoadedOnce.value)
|
|
return;
|
|
initStore();
|
|
};
|
|
onBeforeUpdate(() => menuList.value = []);
|
|
onMounted(() => !isEmpty2(props2.modelValue) && syncCheckedValue());
|
|
__expose({
|
|
menuList,
|
|
menus,
|
|
checkedNodes,
|
|
handleKeyDown,
|
|
handleCheckChange,
|
|
getFlattedNodes,
|
|
getCheckedNodes,
|
|
clearCheckedNodes,
|
|
calculateCheckedValue,
|
|
scrollToExpandingNode,
|
|
loadLazyRootNodes
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([unref(ns).b("panel"), unref(ns).is("bordered", __props.border)]),
|
|
onKeydown: handleKeyDown
|
|
}, [(openBlock(true), createElementBlock(Fragment, null, renderList(menus.value, (menu, index) => {
|
|
return openBlock(), createBlock(menu_default, {
|
|
key: index,
|
|
ref_for: true,
|
|
ref: (item) => menuList.value[index] = item,
|
|
index,
|
|
nodes: [...menu]
|
|
}, {
|
|
empty: withCtx(() => [renderSlot(_ctx.$slots, "empty")]),
|
|
_: 3
|
|
}, 8, ["index", "nodes"]);
|
|
}), 128))], 34);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/src/index.mjs
|
|
var src_default = index_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/cascader-panel/index.mjs
|
|
var ElCascaderPanel = withInstall(src_default);
|
|
|
|
// node_modules/element-plus/es/components/cascader/src/cascader.mjs
|
|
var cascaderProps = buildProps({
|
|
...CommonProps,
|
|
size: useSizeProp,
|
|
placeholder: String,
|
|
disabled: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
clearable: Boolean,
|
|
clearIcon: {
|
|
type: iconPropType,
|
|
default: circle_close_default
|
|
},
|
|
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: Boolean,
|
|
maxCollapseTagsTooltipHeight: { type: [String, Number] },
|
|
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: useTooltipContentProps.popperClass,
|
|
popperStyle: useTooltipContentProps.popperStyle,
|
|
teleported: useTooltipContentProps.teleported,
|
|
effect: {
|
|
type: definePropType(String),
|
|
default: "light"
|
|
},
|
|
tagType: {
|
|
...tagProps.type,
|
|
default: "info"
|
|
},
|
|
tagEffect: {
|
|
...tagProps.effect,
|
|
default: "light"
|
|
},
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
persistent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
showCheckedStrategy: {
|
|
type: String,
|
|
values: ["parent", "child"],
|
|
default: "child"
|
|
},
|
|
checkOnClickNode: Boolean,
|
|
showPrefix: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
...useEmptyValuesProps
|
|
});
|
|
var emitChangeFn2 = (value) => true;
|
|
var cascaderEmits = {
|
|
[UPDATE_MODEL_EVENT]: emitChangeFn2,
|
|
[CHANGE_EVENT]: emitChangeFn2,
|
|
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/components/cascader/src/cascader.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_122 = ["placeholder"];
|
|
var _hoisted_210 = ["onClick"];
|
|
var cascader_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElCascader",
|
|
__name: "cascader",
|
|
props: cascaderProps,
|
|
emits: cascaderEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
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 props2 = __props;
|
|
const emit = __emit;
|
|
const attrs = useAttrs();
|
|
const slots = useSlots();
|
|
let inputInitialHeight = 0;
|
|
let pressDeleteCount = 0;
|
|
const nsCascader = useNamespace("cascader");
|
|
const nsInput = useNamespace("input");
|
|
const sizeMapPadding = {
|
|
small: 7,
|
|
default: 11,
|
|
large: 15
|
|
};
|
|
const { t } = useLocale();
|
|
const { formItem } = useFormItem();
|
|
const isDisabled = useFormDisabled();
|
|
const { valueOnClear } = useEmptyValues(props2);
|
|
const { isComposing, handleComposition } = useComposition({ afterComposition(event) {
|
|
var _a;
|
|
const text = (_a = event.target) == null ? void 0 : _a.value;
|
|
handleInput(text);
|
|
} });
|
|
const tooltipRef = ref();
|
|
const tagTooltipRef = ref();
|
|
const inputRef = ref();
|
|
const tagWrapper = ref();
|
|
const cascaderPanelRef = ref();
|
|
const suggestionPanel = ref();
|
|
const popperVisible = ref(false);
|
|
const inputHover = ref(false);
|
|
const filtering = ref(false);
|
|
const inputValue = ref("");
|
|
const searchInputValue = ref("");
|
|
const tags = ref([]);
|
|
const suggestions = ref([]);
|
|
const showTagList = computed(() => {
|
|
if (!props2.props.multiple)
|
|
return [];
|
|
return props2.collapseTags ? tags.value.slice(0, props2.maxCollapseTags) : tags.value;
|
|
});
|
|
const collapseTagList = computed(() => {
|
|
if (!props2.props.multiple)
|
|
return [];
|
|
return props2.collapseTags ? tags.value.slice(props2.maxCollapseTags) : [];
|
|
});
|
|
const cascaderStyle = computed(() => {
|
|
return attrs.style;
|
|
});
|
|
const inputPlaceholder = computed(() => {
|
|
var _a;
|
|
return (_a = props2.placeholder) != null ? _a : t("el.cascader.placeholder");
|
|
});
|
|
const currentPlaceholder = computed(() => searchInputValue.value || tags.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 _a;
|
|
return ((_a = cascaderPanelRef.value) == null ? void 0 : _a.checkedNodes) || [];
|
|
});
|
|
const { wrapperRef, isFocused, handleBlur } = useFocusController(inputRef, {
|
|
disabled: isDisabled,
|
|
beforeBlur(event) {
|
|
var _a, _b;
|
|
return ((_a = tooltipRef.value) == null ? void 0 : _a.isFocusInsideContent(event)) || ((_b = tagTooltipRef.value) == null ? void 0 : _b.isFocusInsideContent(event));
|
|
},
|
|
afterBlur() {
|
|
var _a;
|
|
if (props2.validateEvent)
|
|
(_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "blur").catch((err) => debugWarn(err));
|
|
}
|
|
});
|
|
const clearBtnVisible = computed(() => {
|
|
if (!props2.clearable || isDisabled.value || filtering.value || !inputHover.value && !isFocused.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(() => nsCascader.is("focus", isFocused.value));
|
|
const contentRef = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = tooltipRef.value) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.contentRef;
|
|
});
|
|
const handleClickOutside = (event) => {
|
|
if (isFocused.value)
|
|
handleBlur(new FocusEvent("blur", event));
|
|
togglePopperVisible(false);
|
|
};
|
|
const togglePopperVisible = (visible) => {
|
|
var _a, _b;
|
|
if (isDisabled.value)
|
|
return;
|
|
visible = visible != null ? visible : !popperVisible.value;
|
|
if (visible !== popperVisible.value) {
|
|
popperVisible.value = visible;
|
|
(_b = (_a = inputRef.value) == null ? void 0 : _a.input) == null ? void 0 : _b.setAttribute("aria-expanded", `${visible}`);
|
|
if (visible) {
|
|
updatePopperPosition();
|
|
cascaderPanelRef.value && nextTick(cascaderPanelRef.value.scrollToExpandingNode);
|
|
} else if (props2.filterable)
|
|
syncPresentTextValue();
|
|
emit("visibleChange", visible);
|
|
}
|
|
};
|
|
const updatePopperPosition = () => {
|
|
nextTick(() => {
|
|
var _a;
|
|
(_a = tooltipRef.value) == null ? void 0 : _a.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
|
|
};
|
|
};
|
|
const deleteTag = (tag) => {
|
|
var _a;
|
|
const node = tag.node;
|
|
node.doCheck(false);
|
|
(_a = cascaderPanelRef.value) == null ? void 0 : _a.calculateCheckedValue();
|
|
emit("removeTag", node.valueByOption);
|
|
};
|
|
const getStrategyCheckedNodes = () => {
|
|
switch (props2.showCheckedStrategy) {
|
|
case "child":
|
|
return checkedNodes.value;
|
|
case "parent": {
|
|
const clickedNodes = getCheckedNodes(false);
|
|
const clickedNodesValue = clickedNodes.map((o2) => o2.value);
|
|
return clickedNodes.filter((o2) => !o2.parent || !clickedNodesValue.includes(o2.parent.value));
|
|
}
|
|
default:
|
|
return [];
|
|
}
|
|
};
|
|
const calculatePresentTags = () => {
|
|
if (!multiple.value)
|
|
return;
|
|
const nodes = getStrategyCheckedNodes();
|
|
const allTags = [];
|
|
nodes.forEach((node) => allTags.push(genTag3(node)));
|
|
tags.value = allTags;
|
|
};
|
|
const calculateSuggestions = () => {
|
|
var _a, _b;
|
|
const { filterMethod, showAllLevels, separator } = props2;
|
|
const res = (_b = (_a = cascaderPanelRef.value) == null ? void 0 : _a.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)
|
|
tags.value.forEach((tag) => {
|
|
tag.hitState = false;
|
|
});
|
|
filtering.value = true;
|
|
suggestions.value = res;
|
|
updatePopperPosition();
|
|
};
|
|
const focusFirstNode = () => {
|
|
var _a;
|
|
let firstNode;
|
|
if (filtering.value && suggestionPanel.value)
|
|
firstNode = suggestionPanel.value.$el.querySelector(`.${nsCascader.e("suggestion-item")}`);
|
|
else
|
|
firstNode = (_a = cascaderPanelRef.value) == null ? void 0 : _a.$el.querySelector(`.${nsCascader.b("node")}[tabindex="-1"]`);
|
|
if (firstNode) {
|
|
firstNode.focus();
|
|
if (!filtering.value && firstNode.getAttribute("aria-haspopup") === "true")
|
|
firstNode.click();
|
|
}
|
|
};
|
|
const updateStyle = () => {
|
|
var _a, _b, _c;
|
|
const inputInner = (_a = inputRef.value) == null ? void 0 : _a.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 = tags.value.length > 0 ? `${Math.max(offsetHeight, inputInitialHeight) - 2}px` : `${inputInitialHeight}px`;
|
|
inputInner.style.height = height;
|
|
if (slots.prefix) {
|
|
const prefix = (_c = inputRef.value) == null ? void 0 : _c.$el.querySelector(`.${nsInput.e("prefix")}`);
|
|
let left = 0;
|
|
if (prefix) {
|
|
left = prefix.offsetWidth;
|
|
if (left > 0)
|
|
left += sizeMapPadding[realSize.value || "default"];
|
|
}
|
|
tagWrapperEl.style.left = `${left}px`;
|
|
} else
|
|
tagWrapperEl.style.left = `0`;
|
|
updatePopperPosition();
|
|
}
|
|
};
|
|
const getCheckedNodes = (leafOnly) => {
|
|
var _a;
|
|
return (_a = cascaderPanelRef.value) == null ? void 0 : _a.getCheckedNodes(leafOnly);
|
|
};
|
|
const handleExpandChange = (value) => {
|
|
updatePopperPosition();
|
|
emit("expandChange", value);
|
|
};
|
|
const handleKeyDown = (e) => {
|
|
if (isComposing.value)
|
|
return;
|
|
switch (getEventCode(e)) {
|
|
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 _a;
|
|
(_a = cascaderPanelRef.value) == null ? void 0 : _a.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 _a, _b;
|
|
const { checked } = node;
|
|
if (multiple.value)
|
|
(_a = cascaderPanelRef.value) == null ? void 0 : _a.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 = getEventCode(e);
|
|
switch (code) {
|
|
case EVENT_CODE.up:
|
|
case EVENT_CODE.down:
|
|
e.preventDefault();
|
|
focusNode(getSibling(target2, code === EVENT_CODE.up ? -1 : 1, `.${nsCascader.e("suggestion-item")}[tabindex="-1"]`));
|
|
break;
|
|
case EVENT_CODE.enter:
|
|
case EVENT_CODE.numpadEnter:
|
|
target2.click();
|
|
break;
|
|
}
|
|
};
|
|
const handleDelete = () => {
|
|
const lastTag = tags.value[tags.value.length - 1];
|
|
pressDeleteCount = searchInputValue.value ? 0 : pressDeleteCount + 1;
|
|
if (!lastTag || !pressDeleteCount || props2.collapseTags && tags.value.length > 1)
|
|
return;
|
|
if (lastTag.hitState)
|
|
deleteTag(lastTag);
|
|
else
|
|
lastTag.hitState = true;
|
|
};
|
|
const handleFilter = useDebounceFn(() => {
|
|
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();
|
|
}, computed(() => props2.debounce));
|
|
const handleInput = (val, e) => {
|
|
!popperVisible.value && togglePopperVisible(true);
|
|
if (e == null ? void 0 : e.isComposing)
|
|
return;
|
|
if (val)
|
|
handleFilter();
|
|
else {
|
|
const passed = props2.beforeFilter("");
|
|
if (isPromise(passed))
|
|
passed.catch(() => {
|
|
});
|
|
hideSuggestionPanel();
|
|
}
|
|
};
|
|
const getInputInnerHeight = (inputInner) => Number.parseFloat(useCssVar(nsInput.cssVarName("input-height"), inputInner).value) - 2;
|
|
const focus = () => {
|
|
var _a;
|
|
(_a = inputRef.value) == null ? void 0 : _a.focus();
|
|
};
|
|
const blur = () => {
|
|
var _a;
|
|
(_a = inputRef.value) == null ? void 0 : _a.blur();
|
|
};
|
|
watch(filtering, updatePopperPosition);
|
|
watch([
|
|
checkedNodes,
|
|
isDisabled,
|
|
() => props2.collapseTags,
|
|
() => props2.maxCollapseTags
|
|
], calculatePresentTags);
|
|
watch(tags, () => {
|
|
nextTick(() => updateStyle());
|
|
});
|
|
watch(realSize, async () => {
|
|
await nextTick();
|
|
const inputInner = inputRef.value.input;
|
|
inputInitialHeight = getInputInnerHeight(inputInner) || inputInitialHeight;
|
|
updateStyle();
|
|
});
|
|
watch(presentText, syncPresentTextValue, { immediate: true });
|
|
watch(() => popperVisible.value, (val) => {
|
|
var _a;
|
|
if (val && props2.props.lazy && props2.props.lazyLoad)
|
|
(_a = cascaderPanelRef.value) == null ? void 0 : _a.loadLazyRootNodes();
|
|
});
|
|
onMounted(() => {
|
|
const inputInner = inputRef.value.input;
|
|
const inputInnerHeight = getInputInnerHeight(inputInner);
|
|
inputInitialHeight = inputInner.offsetHeight || inputInnerHeight;
|
|
useResizeObserver(inputInner, updateStyle);
|
|
});
|
|
__expose({
|
|
getCheckedNodes,
|
|
cascaderPanelRef,
|
|
togglePopperVisible,
|
|
contentRef,
|
|
presentText,
|
|
focus,
|
|
blur
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElTooltip), {
|
|
ref_key: "tooltipRef",
|
|
ref: tooltipRef,
|
|
visible: popperVisible.value,
|
|
teleported: __props.teleported,
|
|
"popper-class": [unref(nsCascader).e("dropdown"), __props.popperClass],
|
|
"popper-style": __props.popperStyle,
|
|
"popper-options": popperOptions,
|
|
"fallback-placements": __props.fallbackPlacements,
|
|
"stop-popper-mouse-event": false,
|
|
"gpu-acceleration": false,
|
|
placement: __props.placement,
|
|
transition: `${unref(nsCascader).namespace.value}-zoom-in-top`,
|
|
effect: __props.effect,
|
|
pure: "",
|
|
persistent: __props.persistent,
|
|
onHide: hideSuggestionPanel
|
|
}, {
|
|
default: withCtx(() => [withDirectives((openBlock(), createElementBlock("div", {
|
|
ref_key: "wrapperRef",
|
|
ref: wrapperRef,
|
|
class: normalizeClass(cascaderKls.value),
|
|
style: normalizeStyle(cascaderStyle.value),
|
|
onClick: _cache[8] || (_cache[8] = () => togglePopperVisible(readonly2.value ? void 0 : true)),
|
|
onKeydown: handleKeyDown,
|
|
onMouseenter: _cache[9] || (_cache[9] = ($event) => inputHover.value = true),
|
|
onMouseleave: _cache[10] || (_cache[10] = ($event) => inputHover.value = false)
|
|
}, [createVNode(unref(ElInput), {
|
|
ref_key: "inputRef",
|
|
ref: inputRef,
|
|
modelValue: inputValue.value,
|
|
"onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => inputValue.value = $event),
|
|
placeholder: currentPlaceholder.value,
|
|
readonly: readonly2.value,
|
|
disabled: unref(isDisabled),
|
|
"validate-event": false,
|
|
size: unref(realSize),
|
|
class: normalizeClass(inputClass.value),
|
|
tabindex: multiple.value && __props.filterable && !unref(isDisabled) ? -1 : void 0,
|
|
onCompositionstart: unref(handleComposition),
|
|
onCompositionupdate: unref(handleComposition),
|
|
onCompositionend: unref(handleComposition),
|
|
onInput: handleInput
|
|
}, createSlots({
|
|
suffix: withCtx(() => [clearBtnVisible.value ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: "clear",
|
|
class: normalizeClass([unref(nsInput).e("icon"), "icon-circle-close"]),
|
|
onClick: withModifiers(handleClear, ["stop"])
|
|
}, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.clearIcon)))]),
|
|
_: 1
|
|
}, 8, ["class"])) : (openBlock(), createBlock(unref(ElIcon), {
|
|
key: "arrow-down",
|
|
class: normalizeClass(cascaderIconKls.value),
|
|
onClick: _cache[0] || (_cache[0] = withModifiers(($event) => togglePopperVisible(), ["stop"]))
|
|
}, {
|
|
default: withCtx(() => [createVNode(unref(arrow_down_default))]),
|
|
_: 1
|
|
}, 8, ["class"]))]),
|
|
_: 2
|
|
}, [_ctx.$slots.prefix ? {
|
|
name: "prefix",
|
|
fn: withCtx(() => [renderSlot(_ctx.$slots, "prefix")]),
|
|
key: "0"
|
|
} : void 0]), 1032, [
|
|
"modelValue",
|
|
"placeholder",
|
|
"readonly",
|
|
"disabled",
|
|
"size",
|
|
"class",
|
|
"tabindex",
|
|
"onCompositionstart",
|
|
"onCompositionupdate",
|
|
"onCompositionend"
|
|
]), multiple.value ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
ref_key: "tagWrapper",
|
|
ref: tagWrapper,
|
|
class: normalizeClass([unref(nsCascader).e("tags"), unref(nsCascader).is("validate", Boolean(validateState.value))])
|
|
}, [
|
|
renderSlot(_ctx.$slots, "tag", {
|
|
data: tags.value,
|
|
deleteTag
|
|
}, () => [(openBlock(true), createElementBlock(Fragment, null, renderList(showTagList.value, (tag) => {
|
|
return openBlock(), createBlock(unref(ElTag), {
|
|
key: tag.key,
|
|
type: __props.tagType,
|
|
size: tagSize.value,
|
|
effect: __props.tagEffect,
|
|
hit: tag.hitState,
|
|
closable: tag.closable,
|
|
"disable-transitions": "",
|
|
onClose: ($event) => deleteTag(tag)
|
|
}, {
|
|
default: withCtx(() => [createBaseVNode("span", null, toDisplayString(tag.text), 1)]),
|
|
_: 2
|
|
}, 1032, [
|
|
"type",
|
|
"size",
|
|
"effect",
|
|
"hit",
|
|
"closable",
|
|
"onClose"
|
|
]);
|
|
}), 128))]),
|
|
__props.collapseTags && tags.value.length > __props.maxCollapseTags ? (openBlock(), createBlock(unref(ElTooltip), {
|
|
key: 0,
|
|
ref_key: "tagTooltipRef",
|
|
ref: tagTooltipRef,
|
|
disabled: popperVisible.value || !__props.collapseTagsTooltip,
|
|
"fallback-placements": [
|
|
"bottom",
|
|
"top",
|
|
"right",
|
|
"left"
|
|
],
|
|
placement: "bottom",
|
|
"popper-class": __props.popperClass,
|
|
"popper-style": __props.popperStyle,
|
|
effect: __props.effect,
|
|
persistent: __props.persistent
|
|
}, {
|
|
default: withCtx(() => [createVNode(unref(ElTag), {
|
|
closable: false,
|
|
size: tagSize.value,
|
|
type: __props.tagType,
|
|
effect: __props.tagEffect,
|
|
"disable-transitions": ""
|
|
}, {
|
|
default: withCtx(() => [createBaseVNode("span", { class: normalizeClass(unref(nsCascader).e("tags-text")) }, " + " + toDisplayString(tags.value.length - __props.maxCollapseTags), 3)]),
|
|
_: 1
|
|
}, 8, [
|
|
"size",
|
|
"type",
|
|
"effect"
|
|
])]),
|
|
content: withCtx(() => [createVNode(unref(ElScrollbar), { "max-height": __props.maxCollapseTagsTooltipHeight }, {
|
|
default: withCtx(() => [createBaseVNode("div", { class: normalizeClass(unref(nsCascader).e("collapse-tags")) }, [(openBlock(true), createElementBlock(Fragment, null, renderList(collapseTagList.value, (tag, idx) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
key: idx,
|
|
class: normalizeClass(unref(nsCascader).e("collapse-tag"))
|
|
}, [(openBlock(), createBlock(unref(ElTag), {
|
|
key: tag.key,
|
|
class: "in-tooltip",
|
|
type: __props.tagType,
|
|
size: tagSize.value,
|
|
effect: __props.tagEffect,
|
|
hit: tag.hitState,
|
|
closable: tag.closable,
|
|
"disable-transitions": "",
|
|
onClose: ($event) => deleteTag(tag)
|
|
}, {
|
|
default: withCtx(() => [createBaseVNode("span", null, toDisplayString(tag.text), 1)]),
|
|
_: 2
|
|
}, 1032, [
|
|
"type",
|
|
"size",
|
|
"effect",
|
|
"hit",
|
|
"closable",
|
|
"onClose"
|
|
]))], 2);
|
|
}), 128))], 2)]),
|
|
_: 1
|
|
}, 8, ["max-height"])]),
|
|
_: 1
|
|
}, 8, [
|
|
"disabled",
|
|
"popper-class",
|
|
"popper-style",
|
|
"effect",
|
|
"persistent"
|
|
])) : createCommentVNode("v-if", true),
|
|
__props.filterable && !unref(isDisabled) ? withDirectives((openBlock(), createElementBlock("input", {
|
|
key: 1,
|
|
"onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => searchInputValue.value = $event),
|
|
type: "text",
|
|
class: normalizeClass(unref(nsCascader).e("search-input")),
|
|
placeholder: presentText.value ? "" : inputPlaceholder.value,
|
|
onInput: _cache[3] || (_cache[3] = (e) => handleInput(searchInputValue.value, e)),
|
|
onClick: _cache[4] || (_cache[4] = withModifiers(($event) => togglePopperVisible(true), ["stop"])),
|
|
onKeydown: withKeys(handleDelete, ["delete"]),
|
|
onCompositionstart: _cache[5] || (_cache[5] = (...args) => unref(handleComposition) && unref(handleComposition)(...args)),
|
|
onCompositionupdate: _cache[6] || (_cache[6] = (...args) => unref(handleComposition) && unref(handleComposition)(...args)),
|
|
onCompositionend: _cache[7] || (_cache[7] = (...args) => unref(handleComposition) && unref(handleComposition)(...args))
|
|
}, null, 42, _hoisted_122)), [[vModelText, searchInputValue.value]]) : createCommentVNode("v-if", true)
|
|
], 2)) : createCommentVNode("v-if", true)], 38)), [[
|
|
unref(ClickOutside),
|
|
handleClickOutside,
|
|
contentRef.value
|
|
]])]),
|
|
content: withCtx(() => [
|
|
_ctx.$slots.header ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(nsCascader).e("header")),
|
|
onClick: _cache[11] || (_cache[11] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}, [renderSlot(_ctx.$slots, "header")], 2)) : createCommentVNode("v-if", true),
|
|
withDirectives(createVNode(unref(ElCascaderPanel), {
|
|
ref_key: "cascaderPanelRef",
|
|
ref: cascaderPanelRef,
|
|
modelValue: checkedValue.value,
|
|
"onUpdate:modelValue": _cache[12] || (_cache[12] = ($event) => checkedValue.value = $event),
|
|
options: __props.options,
|
|
props: props2.props,
|
|
border: false,
|
|
"render-label": _ctx.$slots.default,
|
|
onExpandChange: handleExpandChange,
|
|
onClose: _cache[13] || (_cache[13] = ($event) => _ctx.$nextTick(() => togglePopperVisible(false)))
|
|
}, {
|
|
empty: withCtx(() => [renderSlot(_ctx.$slots, "empty")]),
|
|
_: 3
|
|
}, 8, [
|
|
"modelValue",
|
|
"options",
|
|
"props",
|
|
"render-label"
|
|
]), [[vShow, !filtering.value]]),
|
|
__props.filterable ? withDirectives((openBlock(), createBlock(unref(ElScrollbar), {
|
|
key: 1,
|
|
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, _hoisted_210);
|
|
}), 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),
|
|
_ctx.$slots.footer ? (openBlock(), createElementBlock("div", {
|
|
key: 2,
|
|
class: normalizeClass(unref(nsCascader).e("footer")),
|
|
onClick: _cache[14] || (_cache[14] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}, [renderSlot(_ctx.$slots, "footer")], 2)) : createCommentVNode("v-if", true)
|
|
]),
|
|
_: 3
|
|
}, 8, [
|
|
"visible",
|
|
"teleported",
|
|
"popper-class",
|
|
"popper-style",
|
|
"fallback-placements",
|
|
"placement",
|
|
"transition",
|
|
"effect",
|
|
"persistent"
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/cascader/src/cascader2.mjs
|
|
var cascader_default = cascader_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/cascader/index.mjs
|
|
var ElCascader = withInstall(cascader_default);
|
|
|
|
// 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-tag.vue_vue_type_script_setup_true_lang.mjs
|
|
var check_tag_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElCheckTag",
|
|
__name: "check-tag",
|
|
props: checkTagProps,
|
|
emits: checkTagEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const ns = useNamespace("check-tag");
|
|
const containerKls = computed(() => [
|
|
ns.b(),
|
|
ns.is("checked", props2.checked),
|
|
ns.is("disabled", props2.disabled),
|
|
ns.m(props2.type || "primary")
|
|
]);
|
|
const handleChange = () => {
|
|
if (props2.disabled)
|
|
return;
|
|
const checked = !props2.checked;
|
|
emit(CHANGE_EVENT, checked);
|
|
emit("update:checked", checked);
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("span", {
|
|
class: normalizeClass(containerKls.value),
|
|
onClick: handleChange
|
|
}, [renderSlot(_ctx.$slots, "default")], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/check-tag/src/check-tag2.mjs
|
|
var check_tag_default = check_tag_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/check-tag/index.mjs
|
|
var ElCheckTag = withInstall(check_tag_default);
|
|
|
|
// 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/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/constants.mjs
|
|
var rowContextKey = Symbol("rowContextKey");
|
|
|
|
// node_modules/element-plus/es/components/row/src/row.vue_vue_type_script_setup_true_lang.mjs
|
|
var row_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElRow",
|
|
__name: "row",
|
|
props: rowProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("row");
|
|
provide(rowContextKey, { gutter: computed(() => props2.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(__props.tag), {
|
|
class: normalizeClass(rowKls.value),
|
|
style: normalizeStyle(style.value)
|
|
}, {
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
|
|
_: 3
|
|
}, 8, ["class", "style"]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/row/src/row2.mjs
|
|
var row_default = row_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/row/index.mjs
|
|
var ElRow = withInstall(row_default);
|
|
|
|
// node_modules/element-plus/es/components/col/src/col.vue_vue_type_script_setup_true_lang.mjs
|
|
var col_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElCol",
|
|
__name: "col",
|
|
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 = [];
|
|
[
|
|
"span",
|
|
"offset",
|
|
"pull",
|
|
"push"
|
|
].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]}`));
|
|
}
|
|
});
|
|
[
|
|
"xs",
|
|
"sm",
|
|
"md",
|
|
"lg",
|
|
"xl"
|
|
].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(__props.tag), {
|
|
class: normalizeClass(colKls.value),
|
|
style: normalizeStyle(style.value)
|
|
}, {
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
|
|
_: 3
|
|
}, 8, ["class", "style"]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/col/src/col2.mjs
|
|
var col_default = col_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/col/index.mjs
|
|
var ElCol = withInstall(col_default);
|
|
|
|
// node_modules/element-plus/es/components/collapse/src/collapse.mjs
|
|
var emitChangeFn3 = (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]: emitChangeFn3,
|
|
[CHANGE_EVENT]: emitChangeFn3
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/collapse/src/constants.mjs
|
|
var collapseContextKey = Symbol("collapseContextKey");
|
|
|
|
// 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-transition/src/collapse-transition.vue_vue_type_script_setup_true_lang.mjs
|
|
var collapse_transition_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElCollapseTransition",
|
|
__name: "collapse-transition",
|
|
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"]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/collapse-transition/src/collapse-transition.mjs
|
|
var collapse_transition_default = collapse_transition_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/collapse-transition/index.mjs
|
|
var ElCollapseTransition = withInstall(collapse_transition_default);
|
|
|
|
// node_modules/element-plus/es/components/collapse/src/use-collapse.mjs
|
|
var SCOPE7 = "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);
|
|
if (![isPromise(shouldChange), isBoolean2(shouldChange)].includes(true))
|
|
throwError(SCOPE7, "beforeCollapse must return type `Promise<boolean>` or `boolean`");
|
|
if (isPromise(shouldChange))
|
|
shouldChange.then((result2) => {
|
|
if (result2 !== false)
|
|
handleChange(name);
|
|
}).catch((e) => {
|
|
debugWarn(SCOPE7, `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");
|
|
return { rootKls: computed(() => [ns.b(), ns.b(`icon-position-${props2.expandIconPosition}`)]) };
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/collapse/src/collapse.vue_vue_type_script_setup_true_lang.mjs
|
|
var collapse_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElCollapse",
|
|
__name: "collapse",
|
|
props: collapseProps,
|
|
emits: collapseEmits,
|
|
setup(__props, { expose: __expose, emit: __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);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/collapse/src/collapse2.mjs
|
|
var collapse_default = collapse_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// 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 _a;
|
|
return (_a = props2.name) != null ? _a : `${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 = (e) => {
|
|
var _a;
|
|
if (props2.disabled)
|
|
return;
|
|
if ((_a = e.target) == null ? void 0 : _a.closest("input, textarea, select"))
|
|
return;
|
|
collapse == null ? void 0 : collapse.handleItemClick(unref(name));
|
|
focusing.value = false;
|
|
isClick.value = true;
|
|
};
|
|
const handleEnterClick = (e) => {
|
|
var _a;
|
|
if ((_a = e.target) == null ? void 0 : _a.closest("input, textarea, select"))
|
|
return;
|
|
e.preventDefault();
|
|
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))]);
|
|
return {
|
|
itemTitleKls: computed(() => [ns.be("item", "title")]),
|
|
arrowKls,
|
|
headKls,
|
|
rootKls,
|
|
itemWrapperKls: computed(() => ns.be("item", "wrap")),
|
|
itemContentKls: computed(() => ns.be("item", "content")),
|
|
scopedContentId: computed(() => ns.b(`content-${unref(id)}`)),
|
|
scopedHeadId: computed(() => ns.b(`head-${unref(id)}`))
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/collapse/src/collapse-item.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_123 = [
|
|
"id",
|
|
"aria-expanded",
|
|
"aria-controls",
|
|
"aria-describedby",
|
|
"tabindex",
|
|
"aria-disabled"
|
|
];
|
|
var _hoisted_211 = [
|
|
"id",
|
|
"aria-hidden",
|
|
"aria-labelledby"
|
|
];
|
|
var collapse_item_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElCollapseItem",
|
|
__name: "collapse-item",
|
|
props: collapseItemProps,
|
|
setup(__props, { expose: __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("div", {
|
|
id: unref(scopedHeadId),
|
|
class: normalizeClass(unref(headKls)),
|
|
"aria-expanded": unref(isActive),
|
|
"aria-controls": unref(scopedContentId),
|
|
"aria-describedby": unref(scopedContentId),
|
|
tabindex: __props.disabled ? void 0 : 0,
|
|
"aria-disabled": __props.disabled,
|
|
role: "button",
|
|
onClick: _cache[0] || (_cache[0] = (...args) => unref(handleHeaderClick) && unref(handleHeaderClick)(...args)),
|
|
onKeydown: _cache[1] || (_cache[1] = withKeys(withModifiers((...args) => unref(handleEnterClick) && unref(handleEnterClick)(...args), ["stop"]), ["space", "enter"])),
|
|
onFocus: _cache[2] || (_cache[2] = (...args) => unref(handleFocus) && unref(handleFocus)(...args)),
|
|
onBlur: _cache[3] || (_cache[3] = ($event) => focusing.value = false)
|
|
}, [createBaseVNode("span", { class: normalizeClass(unref(itemTitleKls)) }, [renderSlot(_ctx.$slots, "title", { isActive: unref(isActive) }, () => [createTextVNode(toDisplayString(__props.title), 1)])], 2), renderSlot(_ctx.$slots, "icon", { isActive: unref(isActive) }, () => [createVNode(unref(ElIcon), { class: normalizeClass(unref(arrowKls)) }, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.icon)))]),
|
|
_: 1
|
|
}, 8, ["class"])])], 42, _hoisted_123), 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, _hoisted_211), [[vShow, unref(isActive)]])]),
|
|
_: 3
|
|
})], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/collapse/src/collapse-item2.mjs
|
|
var collapse_item_default = collapse_item_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/collapse/index.mjs
|
|
var ElCollapse = withInstall(collapse_default, { CollapseItem: collapse_item_default });
|
|
var ElCollapseItem = withNoopInstall(collapse_item_default);
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/color-picker-panel.mjs
|
|
var colorPickerPanelProps = buildProps({
|
|
modelValue: {
|
|
type: definePropType(String),
|
|
default: void 0
|
|
},
|
|
border: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
showAlpha: Boolean,
|
|
colorFormat: { type: definePropType(String) },
|
|
disabled: Boolean,
|
|
predefine: { type: definePropType(Array) },
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
hueSliderClass: { type: definePropType([
|
|
String,
|
|
Array,
|
|
Object
|
|
]) },
|
|
hueSliderStyle: { type: definePropType([
|
|
String,
|
|
Array,
|
|
Object
|
|
]) }
|
|
});
|
|
var colorPickerPanelEmits = { [UPDATE_MODEL_EVENT]: (val) => isString(val) || isNil_default(val) };
|
|
var ROOT_COMMON_COLOR_INJECTION_KEY = Symbol("colorCommonPickerKey");
|
|
var colorPickerPanelContextKey = Symbol("colorPickerPanelContextKey");
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/props/slider.mjs
|
|
var alphaSliderProps = buildProps({
|
|
color: {
|
|
type: definePropType(Object),
|
|
required: true
|
|
},
|
|
vertical: Boolean,
|
|
disabled: Boolean
|
|
});
|
|
var hueSliderProps = alphaSliderProps;
|
|
|
|
// node_modules/element-plus/es/utils/dom/position.mjs
|
|
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-panel/src/utils/draggable.mjs
|
|
var isDragging = false;
|
|
function draggable(element, options) {
|
|
if (!isClient)
|
|
return;
|
|
const moveFn = function(event) {
|
|
var _a;
|
|
(_a = options.drag) == null ? void 0 : _a.call(options, event);
|
|
};
|
|
const upFn = function(event) {
|
|
var _a;
|
|
document.removeEventListener("mousemove", moveFn);
|
|
document.removeEventListener("mouseup", upFn);
|
|
document.removeEventListener("touchmove", moveFn);
|
|
document.removeEventListener("touchend", upFn);
|
|
document.onselectstart = null;
|
|
document.ondragstart = null;
|
|
isDragging = false;
|
|
(_a = options.end) == null ? void 0 : _a.call(options, event);
|
|
};
|
|
const downFn = function(event) {
|
|
var _a;
|
|
if (isDragging)
|
|
return;
|
|
document.onselectstart = () => false;
|
|
document.ondragstart = () => false;
|
|
document.addEventListener("mousemove", moveFn);
|
|
document.addEventListener("mouseup", upFn);
|
|
document.addEventListener("touchmove", moveFn);
|
|
document.addEventListener("touchend", upFn);
|
|
isDragging = true;
|
|
(_a = options.start) == null ? void 0 : _a.call(options, event);
|
|
};
|
|
element.addEventListener("mousedown", downFn);
|
|
element.addEventListener("touchstart", downFn, { passive: false });
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/composables/use-slider.mjs
|
|
var useSlider = (props2, { key, minValue: minValue3, maxValue: maxValue3 }) => {
|
|
const instance = getCurrentInstance();
|
|
const thumb = shallowRef();
|
|
const bar = shallowRef();
|
|
const currentValue = computed(() => props2.color.get(key));
|
|
function handleClick(event) {
|
|
var _a;
|
|
if (props2.disabled)
|
|
return;
|
|
if (event.target !== thumb.value)
|
|
handleDrag(event);
|
|
(_a = thumb.value) == null ? void 0 : _a.focus();
|
|
}
|
|
function handleDrag(event) {
|
|
if (!bar.value || !thumb.value || props2.disabled)
|
|
return;
|
|
const rect = instance.vnode.el.getBoundingClientRect();
|
|
const { clientX, clientY } = getClientXY(event);
|
|
let value;
|
|
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);
|
|
value = Math.round((left - thumb.value.offsetWidth / 2) / (rect.width - thumb.value.offsetWidth) * maxValue3);
|
|
} else {
|
|
let top = clientY - rect.top;
|
|
top = Math.max(thumb.value.offsetHeight / 2, top);
|
|
top = Math.min(top, rect.height - thumb.value.offsetHeight / 2);
|
|
value = Math.round((top - thumb.value.offsetHeight / 2) / (rect.height - thumb.value.offsetHeight) * maxValue3);
|
|
}
|
|
props2.color.set(key, value);
|
|
}
|
|
function handleKeydown(event) {
|
|
if (props2.disabled)
|
|
return;
|
|
const { shiftKey } = event;
|
|
const code = getEventCode(event);
|
|
const step2 = shiftKey ? 10 : 1;
|
|
const reverse2 = key === "hue" ? -1 : 1;
|
|
let isPreventDefault = true;
|
|
switch (code) {
|
|
case EVENT_CODE.left:
|
|
case EVENT_CODE.down:
|
|
incrementPosition(-step2 * reverse2);
|
|
break;
|
|
case EVENT_CODE.right:
|
|
case EVENT_CODE.up:
|
|
incrementPosition(step2 * reverse2);
|
|
break;
|
|
case EVENT_CODE.home:
|
|
props2.color.set(key, key === "hue" ? maxValue3 : minValue3);
|
|
break;
|
|
case EVENT_CODE.end:
|
|
props2.color.set(key, key === "hue" ? minValue3 : maxValue3);
|
|
break;
|
|
case EVENT_CODE.pageDown:
|
|
incrementPosition(-4 * reverse2);
|
|
break;
|
|
case EVENT_CODE.pageUp:
|
|
incrementPosition(4 * reverse2);
|
|
break;
|
|
default:
|
|
isPreventDefault = false;
|
|
break;
|
|
}
|
|
isPreventDefault && event.preventDefault();
|
|
}
|
|
function incrementPosition(step2) {
|
|
let next = currentValue.value + step2;
|
|
next = next < minValue3 ? minValue3 : next > maxValue3 ? maxValue3 : next;
|
|
props2.color.set(key, next);
|
|
}
|
|
return {
|
|
thumb,
|
|
bar,
|
|
currentValue,
|
|
handleDrag,
|
|
handleClick,
|
|
handleKeydown
|
|
};
|
|
};
|
|
var useSliderDOM = (props2, { namespace, maxValue: maxValue3, bar, thumb, currentValue, handleDrag, getBackground }) => {
|
|
const instance = getCurrentInstance();
|
|
const ns = useNamespace(namespace);
|
|
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 value = currentValue.value;
|
|
if (!el)
|
|
return 0;
|
|
return Math.round(value * (el.offsetWidth - thumb.value.offsetWidth / 2) / maxValue3);
|
|
}
|
|
function getThumbTop() {
|
|
if (!thumb.value)
|
|
return 0;
|
|
const el = instance.vnode.el;
|
|
if (!props2.vertical)
|
|
return 0;
|
|
const value = currentValue.value;
|
|
if (!el)
|
|
return 0;
|
|
return Math.round(value * (el.offsetHeight - thumb.value.offsetHeight / 2) / maxValue3);
|
|
}
|
|
function update2() {
|
|
thumbLeft.value = getThumbLeft();
|
|
thumbTop.value = getThumbTop();
|
|
background.value = getBackground == null ? void 0 : 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(currentValue, () => update2());
|
|
watch(() => props2.color.value, () => update2());
|
|
const rootKls = computed(() => [
|
|
ns.b(),
|
|
ns.is("vertical", props2.vertical),
|
|
ns.is("disabled", props2.disabled)
|
|
]);
|
|
const barKls = computed(() => ns.e("bar"));
|
|
const thumbKls = computed(() => ns.e("thumb"));
|
|
return {
|
|
rootKls,
|
|
barKls,
|
|
barStyle: computed(() => ({ background: background.value })),
|
|
thumbKls,
|
|
thumbStyle: computed(() => ({
|
|
left: addUnit(thumbLeft.value),
|
|
top: addUnit(thumbTop.value)
|
|
})),
|
|
thumbLeft,
|
|
thumbTop,
|
|
update: update2
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/components/alpha-slider.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_124 = [
|
|
"aria-label",
|
|
"aria-valuenow",
|
|
"aria-valuetext",
|
|
"aria-orientation",
|
|
"tabindex",
|
|
"aria-disabled"
|
|
];
|
|
var minValue = 0;
|
|
var maxValue = 100;
|
|
var alpha_slider_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElColorAlphaSlider",
|
|
__name: "alpha-slider",
|
|
props: alphaSliderProps,
|
|
setup(__props, { expose: __expose }) {
|
|
const props2 = __props;
|
|
const { currentValue, bar, thumb, handleDrag, handleClick, handleKeydown } = useSlider(props2, {
|
|
key: "alpha",
|
|
minValue,
|
|
maxValue
|
|
});
|
|
const { rootKls, barKls, barStyle, thumbKls, thumbStyle, update: update2 } = useSliderDOM(props2, {
|
|
namespace: "color-alpha-slider",
|
|
maxValue,
|
|
currentValue,
|
|
bar,
|
|
thumb,
|
|
handleDrag,
|
|
getBackground
|
|
});
|
|
const { t } = useLocale();
|
|
const ariaLabel = computed(() => t("el.colorpicker.alphaLabel"));
|
|
const ariaValuetext = computed(() => {
|
|
return t("el.colorpicker.alphaDescription", {
|
|
alpha: currentValue.value,
|
|
color: props2.color.value
|
|
});
|
|
});
|
|
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 "";
|
|
}
|
|
__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: _cache[0] || (_cache[0] = (...args) => unref(handleClick) && unref(handleClick)(...args))
|
|
}, null, 6), createBaseVNode("div", {
|
|
ref_key: "thumb",
|
|
ref: thumb,
|
|
class: normalizeClass(unref(thumbKls)),
|
|
style: normalizeStyle(unref(thumbStyle)),
|
|
"aria-label": ariaLabel.value,
|
|
"aria-valuenow": unref(currentValue),
|
|
"aria-valuetext": ariaValuetext.value,
|
|
"aria-orientation": __props.vertical ? "vertical" : "horizontal",
|
|
"aria-valuemin": minValue,
|
|
"aria-valuemax": maxValue,
|
|
role: "slider",
|
|
tabindex: __props.disabled ? void 0 : 0,
|
|
"aria-disabled": __props.disabled,
|
|
onKeydown: _cache[1] || (_cache[1] = (...args) => unref(handleKeydown) && unref(handleKeydown)(...args))
|
|
}, null, 46, _hoisted_124)], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/components/alpha-slider.mjs
|
|
var alpha_slider_default = alpha_slider_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/components/hue-slider.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_125 = [
|
|
"aria-label",
|
|
"aria-valuenow",
|
|
"aria-valuetext",
|
|
"aria-orientation",
|
|
"tabindex",
|
|
"aria-disabled"
|
|
];
|
|
var minValue2 = 0;
|
|
var maxValue2 = 360;
|
|
var hue_slider_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElColorHueSlider",
|
|
__name: "hue-slider",
|
|
props: hueSliderProps,
|
|
setup(__props, { expose: __expose }) {
|
|
const props2 = __props;
|
|
const { currentValue, bar, thumb, handleDrag, handleClick, handleKeydown } = useSlider(props2, {
|
|
key: "hue",
|
|
minValue: minValue2,
|
|
maxValue: maxValue2
|
|
});
|
|
const { rootKls, barKls, thumbKls, thumbStyle, thumbTop, update: update2 } = useSliderDOM(props2, {
|
|
namespace: "color-hue-slider",
|
|
maxValue: maxValue2,
|
|
currentValue,
|
|
bar,
|
|
thumb,
|
|
handleDrag
|
|
});
|
|
const { t } = useLocale();
|
|
const ariaLabel = computed(() => t("el.colorpicker.hueLabel"));
|
|
const ariaValuetext = computed(() => {
|
|
return t("el.colorpicker.hueDescription", {
|
|
hue: currentValue.value,
|
|
color: props2.color.value
|
|
});
|
|
});
|
|
__expose({
|
|
bar,
|
|
thumb,
|
|
thumbTop,
|
|
update: update2
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", { class: normalizeClass(unref(rootKls)) }, [createBaseVNode("div", {
|
|
ref_key: "bar",
|
|
ref: bar,
|
|
class: normalizeClass(unref(barKls)),
|
|
onClick: _cache[0] || (_cache[0] = (...args) => unref(handleClick) && unref(handleClick)(...args))
|
|
}, null, 2), createBaseVNode("div", {
|
|
ref_key: "thumb",
|
|
ref: thumb,
|
|
class: normalizeClass(unref(thumbKls)),
|
|
style: normalizeStyle(unref(thumbStyle)),
|
|
"aria-label": ariaLabel.value,
|
|
"aria-valuenow": unref(currentValue),
|
|
"aria-valuetext": ariaValuetext.value,
|
|
"aria-orientation": __props.vertical ? "vertical" : "horizontal",
|
|
"aria-valuemin": minValue2,
|
|
"aria-valuemax": maxValue2,
|
|
role: "slider",
|
|
tabindex: __props.disabled ? void 0 : 0,
|
|
"aria-disabled": __props.disabled,
|
|
onKeydown: _cache[1] || (_cache[1] = (...args) => unref(handleKeydown) && unref(handleKeydown)(...args))
|
|
}, null, 46, _hoisted_125)], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/components/hue-slider.mjs
|
|
var hue_slider_default = hue_slider_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/props/predefine.mjs
|
|
var predefineProps = buildProps({
|
|
colors: {
|
|
type: definePropType(Array),
|
|
required: true
|
|
},
|
|
color: {
|
|
type: definePropType(Object),
|
|
required: true
|
|
},
|
|
enableAlpha: {
|
|
type: Boolean,
|
|
required: true
|
|
},
|
|
disabled: Boolean
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/utils/color.mjs
|
|
var Color = class {
|
|
constructor(options = {}) {
|
|
this._hue = 0;
|
|
this._saturation = 100;
|
|
this._value = 100;
|
|
this._alpha = 100;
|
|
this._tiny = new TinyColor();
|
|
this._isValid = false;
|
|
this.enableAlpha = false;
|
|
this.format = "";
|
|
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._isValid = true;
|
|
this.doOnChange();
|
|
}
|
|
get(prop) {
|
|
if ([
|
|
"hue",
|
|
"saturation",
|
|
"value",
|
|
"alpha"
|
|
].includes(prop))
|
|
return Math.round(this[`_${prop}`]);
|
|
return this[`_${prop}`];
|
|
}
|
|
toRgb() {
|
|
return this._isValid ? this._tiny.toRgb() : {
|
|
r: 255,
|
|
g: 255,
|
|
b: 255,
|
|
a: 0
|
|
};
|
|
}
|
|
fromString(value) {
|
|
const color = new TinyColor(value);
|
|
this._isValid = color.isValid;
|
|
if (color.isValid) {
|
|
const { h: h3, s: s2, v: v2, a: a2 } = color.toHsv();
|
|
this._hue = h3;
|
|
this._saturation = s2 * 100;
|
|
this._value = v2 * 100;
|
|
this._alpha = a2 * 100;
|
|
} else {
|
|
this._hue = 0;
|
|
this._saturation = 100;
|
|
this._value = 100;
|
|
this._alpha = 100;
|
|
}
|
|
this.doOnChange();
|
|
}
|
|
clear() {
|
|
this._isValid = false;
|
|
this.value = "";
|
|
this._hue = 0;
|
|
this._saturation = 100;
|
|
this._value = 100;
|
|
this._alpha = 100;
|
|
}
|
|
compare(color) {
|
|
const compareColor = new TinyColor({
|
|
h: color._hue,
|
|
s: color._saturation / 100,
|
|
v: color._value / 100,
|
|
a: color._alpha / 100
|
|
});
|
|
return this._tiny.equals(compareColor);
|
|
}
|
|
doOnChange() {
|
|
const { _hue, _saturation, _value, _alpha, format: format2, enableAlpha } = this;
|
|
let _format = format2 || (enableAlpha ? "rgb" : "hex");
|
|
if (format2 === "hex" && enableAlpha)
|
|
_format = "hex8";
|
|
this._tiny = new TinyColor({
|
|
h: _hue,
|
|
s: _saturation / 100,
|
|
v: _value / 100,
|
|
a: _alpha / 100
|
|
});
|
|
this.value = this._isValid ? this._tiny.toString(_format) : "";
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/composables/use-predefine.mjs
|
|
var usePredefine = (props2) => {
|
|
const { currentColor } = inject(colorPickerPanelContextKey);
|
|
const rgbaColors = ref(parseColors(props2.colors, props2.color));
|
|
watch(() => currentColor.value, (val) => {
|
|
const color = new Color({
|
|
value: val,
|
|
enableAlpha: props2.enableAlpha
|
|
});
|
|
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({
|
|
value,
|
|
enableAlpha: props2.enableAlpha
|
|
});
|
|
c2.selected = c2.compare(color);
|
|
return c2;
|
|
});
|
|
}
|
|
return {
|
|
rgbaColors,
|
|
handleSelect
|
|
};
|
|
};
|
|
var usePredefineDOM = (props2) => {
|
|
const ns = useNamespace("color-predefine");
|
|
const rootKls = computed(() => [ns.b(), ns.is("disabled", props2.disabled)]);
|
|
const colorsKls = computed(() => ns.e("colors"));
|
|
function colorSelectorKls(item) {
|
|
return [
|
|
ns.e("color-selector"),
|
|
ns.is("alpha", item.get("alpha") < 100),
|
|
{ selected: item.selected }
|
|
];
|
|
}
|
|
return {
|
|
rootKls,
|
|
colorsKls,
|
|
colorSelectorKls
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/components/predefine.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_126 = [
|
|
"disabled",
|
|
"aria-label",
|
|
"onClick"
|
|
];
|
|
var predefine_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElColorPredefine",
|
|
__name: "predefine",
|
|
props: predefineProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const { rgbaColors, handleSelect } = usePredefine(props2);
|
|
const { rootKls, colorsKls, colorSelectorKls } = usePredefineDOM(props2);
|
|
const { t } = useLocale();
|
|
const ariaLabel = (value) => {
|
|
return t("el.colorpicker.predefineDescription", { value });
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", { class: normalizeClass(unref(rootKls)) }, [createBaseVNode("div", { class: normalizeClass(unref(colorsKls)) }, [(openBlock(true), createElementBlock(Fragment, null, renderList(unref(rgbaColors), (item, index) => {
|
|
return openBlock(), createElementBlock("button", {
|
|
key: __props.colors[index],
|
|
type: "button",
|
|
disabled: __props.disabled,
|
|
"aria-label": ariaLabel(item.value),
|
|
class: normalizeClass(unref(colorSelectorKls)(item)),
|
|
onClick: ($event) => unref(handleSelect)(index)
|
|
}, [createBaseVNode("div", { style: normalizeStyle({ backgroundColor: item.value }) }, null, 4)], 10, _hoisted_126);
|
|
}), 128))], 2)], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/components/predefine.mjs
|
|
var predefine_default = predefine_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/props/sv-panel.mjs
|
|
var svPanelProps = buildProps({
|
|
color: {
|
|
type: definePropType(Object),
|
|
required: true
|
|
},
|
|
disabled: Boolean
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/composables/use-sv-panel.mjs
|
|
var useSvPanel = (props2) => {
|
|
const instance = getCurrentInstance();
|
|
const cursorRef = ref();
|
|
const cursorTop = ref(0);
|
|
const cursorLeft = ref(0);
|
|
const background = ref("hsl(0, 100%, 50%)");
|
|
const saturation = computed(() => props2.color.get("saturation"));
|
|
const brightness = computed(() => props2.color.get("value"));
|
|
const hue = computed(() => props2.color.get("hue"));
|
|
function handleClick(event) {
|
|
var _a;
|
|
if (props2.disabled)
|
|
return;
|
|
if (event.target !== cursorRef.value)
|
|
handleDrag(event);
|
|
(_a = cursorRef.value) == null ? void 0 : _a.focus({ preventScroll: true });
|
|
}
|
|
function handleDrag(event) {
|
|
if (props2.disabled)
|
|
return;
|
|
const rect = instance.vnode.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
|
|
});
|
|
}
|
|
function handleKeydown(event) {
|
|
if (props2.disabled)
|
|
return;
|
|
const { shiftKey } = event;
|
|
const code = getEventCode(event);
|
|
const step2 = shiftKey ? 10 : 1;
|
|
let isPreventDefault = true;
|
|
switch (code) {
|
|
case EVENT_CODE.left:
|
|
incrementSaturation(-step2);
|
|
break;
|
|
case EVENT_CODE.right:
|
|
incrementSaturation(step2);
|
|
break;
|
|
case EVENT_CODE.up:
|
|
incrementBrightness(step2);
|
|
break;
|
|
case EVENT_CODE.down:
|
|
incrementBrightness(-step2);
|
|
break;
|
|
default:
|
|
isPreventDefault = false;
|
|
break;
|
|
}
|
|
isPreventDefault && event.preventDefault();
|
|
}
|
|
function incrementSaturation(step2) {
|
|
let next = saturation.value + step2;
|
|
next = next < 0 ? 0 : next > 100 ? 100 : next;
|
|
props2.color.set("saturation", next);
|
|
}
|
|
function incrementBrightness(step2) {
|
|
let next = brightness.value + step2;
|
|
next = next < 0 ? 0 : next > 100 ? 100 : next;
|
|
props2.color.set("value", next);
|
|
}
|
|
return {
|
|
cursorRef,
|
|
cursorTop,
|
|
cursorLeft,
|
|
background,
|
|
saturation,
|
|
brightness,
|
|
hue,
|
|
handleClick,
|
|
handleDrag,
|
|
handleKeydown
|
|
};
|
|
};
|
|
var useSvPanelDOM = (props2, { cursorTop, cursorLeft, background, handleDrag }) => {
|
|
const instance = getCurrentInstance();
|
|
const ns = useNamespace("color-svpanel");
|
|
function update2() {
|
|
const saturation = props2.color.get("saturation");
|
|
const brightness = props2.color.get("value");
|
|
const { clientWidth: width, clientHeight: height } = instance.vnode.el;
|
|
cursorLeft.value = saturation * width / 100;
|
|
cursorTop.value = (100 - brightness) * height / 100;
|
|
background.value = `hsl(${props2.color.get("hue")}, 100%, 50%)`;
|
|
}
|
|
onMounted(() => {
|
|
draggable(instance.vnode.el, {
|
|
drag: (event) => {
|
|
handleDrag(event);
|
|
},
|
|
end: (event) => {
|
|
handleDrag(event);
|
|
}
|
|
});
|
|
update2();
|
|
});
|
|
watch([
|
|
() => props2.color.get("hue"),
|
|
() => props2.color.get("value"),
|
|
() => props2.color.value
|
|
], () => update2());
|
|
return {
|
|
rootKls: computed(() => ns.b()),
|
|
cursorKls: computed(() => ns.e("cursor")),
|
|
rootStyle: computed(() => ({ backgroundColor: background.value })),
|
|
cursorStyle: computed(() => ({
|
|
top: addUnit(cursorTop.value),
|
|
left: addUnit(cursorLeft.value)
|
|
})),
|
|
update: update2
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/components/sv-panel.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_127 = [
|
|
"tabindex",
|
|
"aria-disabled",
|
|
"aria-label",
|
|
"aria-valuenow",
|
|
"aria-valuetext"
|
|
];
|
|
var sv_panel_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElSvPanel",
|
|
__name: "sv-panel",
|
|
props: svPanelProps,
|
|
setup(__props, { expose: __expose }) {
|
|
const props2 = __props;
|
|
const { cursorRef, cursorTop, cursorLeft, background, saturation, brightness, handleClick, handleDrag, handleKeydown } = useSvPanel(props2);
|
|
const { rootKls, cursorKls, rootStyle, cursorStyle, update: update2 } = useSvPanelDOM(props2, {
|
|
cursorTop,
|
|
cursorLeft,
|
|
background,
|
|
handleDrag
|
|
});
|
|
const { t } = useLocale();
|
|
const ariaLabel = computed(() => t("el.colorpicker.svLabel"));
|
|
const ariaValuetext = computed(() => {
|
|
return t("el.colorpicker.svDescription", {
|
|
saturation: saturation.value,
|
|
brightness: brightness.value,
|
|
color: props2.color.value
|
|
});
|
|
});
|
|
__expose({ update: update2 });
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(unref(rootKls)),
|
|
style: normalizeStyle(unref(rootStyle)),
|
|
onClick: _cache[1] || (_cache[1] = (...args) => unref(handleClick) && unref(handleClick)(...args))
|
|
}, [createBaseVNode("div", {
|
|
ref_key: "cursorRef",
|
|
ref: cursorRef,
|
|
class: normalizeClass(unref(cursorKls)),
|
|
style: normalizeStyle(unref(cursorStyle)),
|
|
tabindex: __props.disabled ? void 0 : 0,
|
|
"aria-disabled": __props.disabled,
|
|
role: "slider",
|
|
"aria-valuemin": "0,0",
|
|
"aria-valuemax": "100,100",
|
|
"aria-label": ariaLabel.value,
|
|
"aria-valuenow": `${unref(saturation)},${unref(brightness)}`,
|
|
"aria-valuetext": ariaValuetext.value,
|
|
onKeydown: _cache[0] || (_cache[0] = (...args) => unref(handleKeydown) && unref(handleKeydown)(...args))
|
|
}, null, 46, _hoisted_127)], 6);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/components/sv-panel.mjs
|
|
var sv_panel_default = sv_panel_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/composables/use-common-color.mjs
|
|
var useCommonColor = (props2, emit) => {
|
|
const color = reactive(new Color({
|
|
enableAlpha: props2.showAlpha,
|
|
format: props2.colorFormat || "",
|
|
value: props2.modelValue
|
|
}));
|
|
watch(() => [props2.colorFormat, props2.showAlpha], () => {
|
|
color.enableAlpha = props2.showAlpha;
|
|
color.format = props2.colorFormat || color.format;
|
|
color.doOnChange();
|
|
emit(UPDATE_MODEL_EVENT, color.value);
|
|
});
|
|
return { color };
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/color-picker-panel.vue_vue_type_script_setup_true_lang.mjs
|
|
var color_picker_panel_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElColorPickerPanel",
|
|
__name: "color-picker-panel",
|
|
props: colorPickerPanelProps,
|
|
emits: colorPickerPanelEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const ns = useNamespace("color-picker-panel");
|
|
const { formItem } = useFormItem();
|
|
const disabled = useFormDisabled();
|
|
const hueRef = ref();
|
|
const svRef = ref();
|
|
const alphaRef = ref();
|
|
const inputRef = ref();
|
|
const customInput = ref("");
|
|
const { color } = inject(ROOT_COMMON_COLOR_INJECTION_KEY, () => useCommonColor(props2, emit), true);
|
|
function handleConfirm() {
|
|
color.fromString(customInput.value);
|
|
if (color.value !== customInput.value)
|
|
customInput.value = color.value;
|
|
}
|
|
function handleFocusout() {
|
|
var _a;
|
|
if (props2.validateEvent)
|
|
(_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "blur").catch((err) => debugWarn(err));
|
|
}
|
|
function update2() {
|
|
var _a, _b, _c;
|
|
(_a = hueRef.value) == null ? void 0 : _a.update();
|
|
(_b = svRef.value) == null ? void 0 : _b.update();
|
|
(_c = alphaRef.value) == null ? void 0 : _c.update();
|
|
}
|
|
onMounted(() => {
|
|
if (props2.modelValue)
|
|
customInput.value = color.value;
|
|
nextTick(update2);
|
|
});
|
|
watch(() => props2.modelValue, (newVal) => {
|
|
if (newVal !== color.value)
|
|
newVal ? color.fromString(newVal) : color.clear();
|
|
});
|
|
watch(() => color.value, (val) => {
|
|
emit(UPDATE_MODEL_EVENT, val);
|
|
customInput.value = val;
|
|
if (props2.validateEvent)
|
|
formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
|
|
});
|
|
provide(colorPickerPanelContextKey, { currentColor: computed(() => color.value) });
|
|
__expose({
|
|
color,
|
|
inputRef,
|
|
update: update2
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([
|
|
unref(ns).b(),
|
|
unref(ns).is("disabled", unref(disabled)),
|
|
unref(ns).is("border", __props.border)
|
|
]),
|
|
onFocusout: handleFocusout
|
|
}, [
|
|
createBaseVNode("div", { class: normalizeClass(unref(ns).e("wrapper")) }, [createVNode(hue_slider_default, {
|
|
ref_key: "hueRef",
|
|
ref: hueRef,
|
|
color: unref(color),
|
|
vertical: "",
|
|
disabled: unref(disabled),
|
|
class: normalizeClass(["hue-slider", __props.hueSliderClass]),
|
|
style: normalizeStyle(__props.hueSliderStyle)
|
|
}, null, 8, [
|
|
"color",
|
|
"disabled",
|
|
"class",
|
|
"style"
|
|
]), createVNode(sv_panel_default, {
|
|
ref_key: "svRef",
|
|
ref: svRef,
|
|
color: unref(color),
|
|
disabled: unref(disabled)
|
|
}, null, 8, ["color", "disabled"])], 2),
|
|
__props.showAlpha ? (openBlock(), createBlock(alpha_slider_default, {
|
|
key: 0,
|
|
ref_key: "alphaRef",
|
|
ref: alphaRef,
|
|
color: unref(color),
|
|
disabled: unref(disabled)
|
|
}, null, 8, ["color", "disabled"])) : createCommentVNode("v-if", true),
|
|
__props.predefine ? (openBlock(), createBlock(predefine_default, {
|
|
key: 1,
|
|
ref: "predefine",
|
|
"enable-alpha": __props.showAlpha,
|
|
color: unref(color),
|
|
colors: __props.predefine,
|
|
disabled: unref(disabled)
|
|
}, null, 8, [
|
|
"enable-alpha",
|
|
"color",
|
|
"colors",
|
|
"disabled"
|
|
])) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", { class: normalizeClass(unref(ns).e("footer")) }, [createVNode(unref(ElInput), {
|
|
ref_key: "inputRef",
|
|
ref: inputRef,
|
|
modelValue: customInput.value,
|
|
"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => customInput.value = $event),
|
|
"validate-event": false,
|
|
size: "small",
|
|
disabled: unref(disabled),
|
|
onChange: handleConfirm
|
|
}, null, 8, ["modelValue", "disabled"]), renderSlot(_ctx.$slots, "footer")], 2)
|
|
], 34);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/src/color-picker-panel2.mjs
|
|
var color_picker_panel_default = color_picker_panel_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/color-picker-panel/index.mjs
|
|
var ElColorPickerPanel = withInstall(color_picker_panel_default);
|
|
|
|
// node_modules/element-plus/es/components/color-picker/src/color-picker.mjs
|
|
var colorPickerProps = buildProps({
|
|
persistent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
modelValue: {
|
|
type: definePropType(String),
|
|
default: void 0
|
|
},
|
|
id: String,
|
|
showAlpha: Boolean,
|
|
colorFormat: { type: definePropType(String) },
|
|
disabled: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
clearable: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
size: useSizeProp,
|
|
popperClass: useTooltipContentProps.popperClass,
|
|
popperStyle: useTooltipContentProps.popperStyle,
|
|
tabindex: {
|
|
type: [String, Number],
|
|
default: 0
|
|
},
|
|
teleported: useTooltipContentProps.teleported,
|
|
appendTo: useTooltipContentProps.appendTo,
|
|
predefine: { type: definePropType(Array) },
|
|
validateEvent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
...useEmptyValuesProps,
|
|
...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,
|
|
clear: () => true
|
|
};
|
|
var colorPickerPropsDefaults = {
|
|
persistent: true,
|
|
modelValue: void 0,
|
|
disabled: void 0,
|
|
clearable: true,
|
|
popperStyle: void 0,
|
|
tabindex: 0,
|
|
teleported: true,
|
|
validateEvent: true,
|
|
valueOnClear: void 0
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/color-picker/src/color-picker.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_128 = [
|
|
"id",
|
|
"aria-label",
|
|
"aria-labelledby",
|
|
"aria-description",
|
|
"aria-disabled",
|
|
"tabindex"
|
|
];
|
|
var color_picker_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElColorPicker",
|
|
__name: "color-picker",
|
|
props: colorPickerProps,
|
|
emits: colorPickerEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("color");
|
|
const { formItem } = useFormItem();
|
|
const colorSize = useFormSize();
|
|
const colorDisabled = useFormDisabled();
|
|
const { valueOnClear, isEmptyValue: isEmptyValue2 } = useEmptyValues(props2, null);
|
|
const commonColor = useCommonColor(props2, emit);
|
|
const { inputId: buttonId, isLabeledByFormItem } = useFormItemInputId(props2, { formItemContext: formItem });
|
|
const popper = ref();
|
|
const triggerRef2 = ref();
|
|
const pickerPanelRef = ref();
|
|
const showPicker = ref(false);
|
|
const showPanelColor = ref(false);
|
|
let shouldActiveChange = true;
|
|
const { isFocused, handleFocus, handleBlur } = useFocusController(triggerRef2, {
|
|
disabled: colorDisabled,
|
|
beforeBlur(event) {
|
|
var _a;
|
|
return (_a = popper.value) == null ? void 0 : _a.isFocusInsideContent(event);
|
|
},
|
|
afterBlur() {
|
|
var _a;
|
|
setShowPicker(false);
|
|
resetColor();
|
|
if (props2.validateEvent)
|
|
(_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "blur").catch((err) => debugWarn(err));
|
|
}
|
|
});
|
|
const color = reactiveComputed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = pickerPanelRef.value) == null ? void 0 : _a.color) != null ? _b : commonColor.color;
|
|
});
|
|
const panelProps = computed(() => pick_default(props2, Object.keys(colorPickerPanelProps)));
|
|
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) {
|
|
const { r, g, b: b2, a: a2 } = color2.toRgb();
|
|
return showAlpha ? `rgba(${r}, ${g}, ${b2}, ${a2})` : `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 confirmValue() {
|
|
const value = isEmptyValue2(color.value) ? valueOnClear.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, valueOnClear.value);
|
|
emit(CHANGE_EVENT, valueOnClear.value);
|
|
if (props2.modelValue !== valueOnClear.value && props2.validateEvent)
|
|
formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
|
|
resetColor();
|
|
emit("clear");
|
|
}
|
|
function handleShowTooltip() {
|
|
var _a, _b;
|
|
(_b = (_a = pickerPanelRef == null ? void 0 : pickerPanelRef.value) == null ? void 0 : _a.inputRef) == null ? void 0 : _b.focus();
|
|
}
|
|
function handleClickOutside() {
|
|
if (!showPicker.value)
|
|
return;
|
|
hide2();
|
|
isFocused.value && focus();
|
|
}
|
|
function handleEsc(event) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
setShowPicker(false);
|
|
resetColor();
|
|
}
|
|
function handleKeyDown(event) {
|
|
switch (getEventCode(event)) {
|
|
case EVENT_CODE.enter:
|
|
case EVENT_CODE.numpadEnter:
|
|
case EVENT_CODE.space:
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
show();
|
|
break;
|
|
case EVENT_CODE.esc:
|
|
handleEsc(event);
|
|
break;
|
|
}
|
|
}
|
|
function focus() {
|
|
triggerRef2.value.focus();
|
|
}
|
|
function blur() {
|
|
triggerRef2.value.blur();
|
|
}
|
|
watch(() => currentColor.value, (val) => {
|
|
shouldActiveChange && emit("activeChange", val);
|
|
shouldActiveChange = true;
|
|
});
|
|
watch(() => color.value, () => {
|
|
if (!props2.modelValue && !showPanelColor.value)
|
|
showPanelColor.value = true;
|
|
});
|
|
watch(() => props2.modelValue, (newVal) => {
|
|
if (!newVal)
|
|
showPanelColor.value = false;
|
|
else if (newVal && newVal !== color.value) {
|
|
shouldActiveChange = false;
|
|
color.fromString(newVal);
|
|
}
|
|
});
|
|
watch(() => showPicker.value, () => {
|
|
pickerPanelRef.value && nextTick(pickerPanelRef.value.update);
|
|
});
|
|
provide(ROOT_COMMON_COLOR_INJECTION_KEY, commonColor);
|
|
__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"), __props.popperClass],
|
|
"popper-style": __props.popperStyle,
|
|
"stop-popper-mouse-event": false,
|
|
pure: "",
|
|
loop: "",
|
|
role: "dialog",
|
|
effect: "light",
|
|
trigger: "click",
|
|
teleported: __props.teleported,
|
|
transition: `${unref(ns).namespace.value}-zoom-in-top`,
|
|
persistent: __props.persistent,
|
|
"append-to": __props.appendTo,
|
|
onShow: handleShowTooltip,
|
|
onHide: _cache[2] || (_cache[2] = ($event) => setShowPicker(false))
|
|
}, {
|
|
content: withCtx(() => [withDirectives((openBlock(), createBlock(unref(ElColorPickerPanel), mergeProps({
|
|
ref_key: "pickerPanelRef",
|
|
ref: pickerPanelRef
|
|
}, panelProps.value, {
|
|
border: false,
|
|
"validate-event": false,
|
|
onKeydown: withKeys(handleEsc, ["esc"])
|
|
}), {
|
|
footer: withCtx(() => [createBaseVNode("div", null, [__props.clearable ? (openBlock(), createBlock(unref(ElButton), {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).be("footer", "link-btn")),
|
|
text: "",
|
|
size: "small",
|
|
onClick: clear
|
|
}, {
|
|
default: withCtx(() => [createTextVNode(toDisplayString(unref(t)("el.colorpicker.clear")), 1)]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true), createVNode(unref(ElButton), {
|
|
plain: "",
|
|
size: "small",
|
|
class: normalizeClass(unref(ns).be("footer", "btn")),
|
|
onClick: confirmValue
|
|
}, {
|
|
default: withCtx(() => [createTextVNode(toDisplayString(unref(t)("el.colorpicker.confirm")), 1)]),
|
|
_: 1
|
|
}, 8, ["class"])])]),
|
|
_: 1
|
|
}, 16)), [[
|
|
unref(ClickOutside),
|
|
handleClickOutside,
|
|
triggerRef2.value
|
|
]])]),
|
|
default: withCtx(() => [createBaseVNode("div", mergeProps({
|
|
id: unref(buttonId),
|
|
ref_key: "triggerRef",
|
|
ref: triggerRef2
|
|
}, _ctx.$attrs, {
|
|
class: btnKls.value,
|
|
role: "button",
|
|
"aria-label": buttonAriaLabel.value,
|
|
"aria-labelledby": buttonAriaLabelledby.value,
|
|
"aria-description": unref(t)("el.colorpicker.description", { color: __props.modelValue || "" }),
|
|
"aria-disabled": unref(colorDisabled),
|
|
tabindex: unref(colorDisabled) ? void 0 : __props.tabindex,
|
|
onKeydown: handleKeyDown,
|
|
onFocus: _cache[0] || (_cache[0] = (...args) => unref(handleFocus) && unref(handleFocus)(...args)),
|
|
onBlur: _cache[1] || (_cache[1] = (...args) => unref(handleBlur) && unref(handleBlur)(...args))
|
|
}), [createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).be("picker", "trigger")),
|
|
onClick: handleTrigger
|
|
}, [createBaseVNode("span", { class: normalizeClass([unref(ns).be("picker", "color"), unref(ns).is("alpha", __props.showAlpha)]) }, [createBaseVNode("span", {
|
|
class: normalizeClass(unref(ns).be("picker", "color-inner")),
|
|
style: normalizeStyle({ backgroundColor: displayedColor.value })
|
|
}, [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, __props.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, !__props.modelValue && !showPanelColor.value]])], 6)], 2)], 2)], 16, _hoisted_128)]),
|
|
_: 1
|
|
}, 8, [
|
|
"visible",
|
|
"popper-class",
|
|
"popper-style",
|
|
"teleported",
|
|
"transition",
|
|
"persistent",
|
|
"append-to"
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/color-picker/src/color-picker2.mjs
|
|
var color_picker_default = color_picker_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/color-picker/index.mjs
|
|
var ElColorPicker = withInstall(color_picker_default);
|
|
|
|
// node_modules/element-plus/es/components/container/src/container.vue_vue_type_script_setup_true_lang.mjs
|
|
var container_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElContainer",
|
|
__name: "container",
|
|
props: { direction: {
|
|
type: String,
|
|
required: false
|
|
} },
|
|
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)
|
|
return slots.default().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", isVertical.value)]) }, [renderSlot(_ctx.$slots, "default")], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/container/src/container.mjs
|
|
var container_default = container_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/container/src/aside.vue_vue_type_script_setup_true_lang.mjs
|
|
var aside_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElAside",
|
|
__name: "aside",
|
|
props: { width: {
|
|
type: [String, null],
|
|
required: false,
|
|
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(style.value)
|
|
}, [renderSlot(_ctx.$slots, "default")], 6);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/container/src/aside.mjs
|
|
var aside_default = aside_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/container/src/footer.vue_vue_type_script_setup_true_lang.mjs
|
|
var footer_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElFooter",
|
|
__name: "footer",
|
|
props: { height: {
|
|
type: [String, null],
|
|
required: false,
|
|
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(style.value)
|
|
}, [renderSlot(_ctx.$slots, "default")], 6);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/container/src/footer.mjs
|
|
var footer_default = footer_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/container/src/header.vue_vue_type_script_setup_true_lang.mjs
|
|
var header_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElHeader",
|
|
__name: "header",
|
|
props: { height: {
|
|
type: [String, null],
|
|
required: false,
|
|
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(style.value)
|
|
}, [renderSlot(_ctx.$slots, "default")], 6);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/container/src/header.mjs
|
|
var header_default = header_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/container/src/main.vue_vue_type_script_setup_true_lang.mjs
|
|
var main_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElMain",
|
|
__name: "main",
|
|
setup(__props) {
|
|
const ns = useNamespace("main");
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("main", { class: normalizeClass(unref(ns).b()) }, [renderSlot(_ctx.$slots, "default")], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/container/src/main.mjs
|
|
var main_default = main_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/container/index.mjs
|
|
var ElContainer = withInstall(container_default, {
|
|
Aside: aside_default,
|
|
Footer: footer_default,
|
|
Header: header_default,
|
|
Main: main_default
|
|
});
|
|
var ElAside = withNoopInstall(aside_default);
|
|
var ElFooter = withNoopInstall(footer_default);
|
|
var ElHeader = withNoopInstall(header_default);
|
|
var ElMain = withNoopInstall(main_default);
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/props/date-picker-panel.mjs
|
|
var datePickerPanelProps = buildProps({
|
|
valueFormat: String,
|
|
dateFormat: String,
|
|
timeFormat: String,
|
|
disabled: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
modelValue: {
|
|
type: definePropType([
|
|
Date,
|
|
Array,
|
|
String,
|
|
Number
|
|
]),
|
|
default: ""
|
|
},
|
|
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,
|
|
unlinkPanels: Boolean,
|
|
showNow: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
showConfirm: Boolean,
|
|
showFooter: Boolean,
|
|
showWeekNumber: Boolean,
|
|
type: {
|
|
type: definePropType(String),
|
|
default: "date"
|
|
},
|
|
clearable: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
border: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
editable: {
|
|
type: Boolean,
|
|
default: true
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/constants.mjs
|
|
var ROOT_PICKER_INJECTION_KEY = Symbol("rootPickerContextKey");
|
|
var ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY = "ElIsDefaultFormat";
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/props/shared.mjs
|
|
var selectionModes = [
|
|
"date",
|
|
"dates",
|
|
"year",
|
|
"years",
|
|
"month",
|
|
"months",
|
|
"week",
|
|
"range"
|
|
];
|
|
var datePickerSharedProps = buildProps({
|
|
cellClassName: { type: definePropType(Function) },
|
|
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
|
|
})
|
|
},
|
|
disabled: Boolean
|
|
});
|
|
var panelSharedProps = buildProps({
|
|
type: {
|
|
type: definePropType(String),
|
|
required: true,
|
|
values: datePickTypes
|
|
},
|
|
dateFormat: String,
|
|
timeFormat: String,
|
|
showNow: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
showConfirm: Boolean,
|
|
showFooter: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
showWeekNumber: Boolean,
|
|
border: Boolean,
|
|
disabled: Boolean,
|
|
editable: {
|
|
type: Boolean,
|
|
default: true
|
|
}
|
|
});
|
|
var panelRangeSharedProps = buildProps({
|
|
unlinkPanels: Boolean,
|
|
visible: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
showConfirm: Boolean,
|
|
showFooter: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
border: Boolean,
|
|
disabled: Boolean,
|
|
parsedValue: { type: definePropType(Array) }
|
|
});
|
|
var selectionModeWithDefault = (mode) => {
|
|
return {
|
|
type: String,
|
|
values: selectionModes,
|
|
default: mode
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/props/panel-date-pick.mjs
|
|
var panelDatePickProps = buildProps({
|
|
...panelSharedProps,
|
|
parsedValue: { type: definePropType([Object, Array]) },
|
|
visible: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
format: {
|
|
type: String,
|
|
default: ""
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/utils.mjs
|
|
var import_dayjs8 = __toESM(require_dayjs_min(), 1);
|
|
var isValidRange2 = (range4) => {
|
|
if (!isArray(range4))
|
|
return false;
|
|
const [left, right] = range4;
|
|
return import_dayjs8.default.isDayjs(left) && import_dayjs8.default.isDayjs(right) && (0, import_dayjs8.default)(left).isValid() && (0, import_dayjs8.default)(right).isValid() && left.isSameOrBefore(right);
|
|
};
|
|
var getDefaultValue = (defaultValue, { lang, step: step2 = 1, unit: unit4, unlinkPanels }) => {
|
|
let start;
|
|
if (isArray(defaultValue)) {
|
|
let [left, right] = defaultValue.map((d2) => (0, import_dayjs8.default)(d2).locale(lang));
|
|
if (!unlinkPanels)
|
|
right = left.add(step2, unit4);
|
|
return [left, right];
|
|
} else if (defaultValue)
|
|
start = (0, import_dayjs8.default)(defaultValue);
|
|
else
|
|
start = (0, import_dayjs8.default)();
|
|
start = start.locale(lang);
|
|
return [start, start.add(step2, 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 nextStartDate = relativeDateGetter(rowIndex * dimension.column + columnIndex);
|
|
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);
|
|
}
|
|
if (nextStartDate.isSame(now2, unit4))
|
|
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_dayjs8.default)().locale(lang).startOf("month").month(month).year(year).hour(date4.hour()).minute(date4.minute()).second(date4.second());
|
|
return rangeArr(firstDay.daysInMonth()).map((n) => firstDay.add(n, "day").toDate());
|
|
};
|
|
var getValidDateOfMonth = (date4, year, month, lang, disabledDate) => {
|
|
const _value = (0, import_dayjs8.default)().year(year).month(month).startOf("month").hour(date4.hour()).minute(date4.minute()).second(date4.second());
|
|
const _date = datesInMonth(date4, year, month, lang).find((date5) => {
|
|
return !(disabledDate == null ? void 0 : disabledDate(date5));
|
|
});
|
|
if (_date)
|
|
return (0, import_dayjs8.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 == null ? void 0 : defaultFormat.value) ? (0, import_dayjs8.default)(value) : (0, import_dayjs8.default)(value, format2);
|
|
if (!dayjsValue.isValid())
|
|
return dayjsValue;
|
|
}
|
|
return (0, import_dayjs8.default)(value, format2).locale(lang);
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/props/basic-date-table.mjs
|
|
var basicDateTableProps = buildProps({
|
|
...datePickerSharedProps,
|
|
showWeekNumber: Boolean,
|
|
selectionMode: selectionModeWithDefault("date")
|
|
});
|
|
var basicDateTableEmits = [
|
|
"changerange",
|
|
"pick",
|
|
"select"
|
|
];
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/composables/use-basic-date-table.mjs
|
|
var import_dayjs9 = __toESM(require_dayjs_min(), 1);
|
|
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");
|
|
return {
|
|
startOfMonthDay: startOfMonth.day() || 7,
|
|
dateCountOfMonth: startOfMonth.daysInMonth(),
|
|
dateCountOfLastMonth: startOfMonth.subtract(1, "month").daysInMonth()
|
|
};
|
|
});
|
|
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;
|
|
buildPickerTable({
|
|
row: 6,
|
|
column: 7
|
|
}, rows_, {
|
|
startDate: minDate,
|
|
columnIndexOffset: showWeekNumber ? 1 : 0,
|
|
nextEndDate: rangeState.endDate || maxDate || rangeState.selecting && minDate || null,
|
|
now: (0, import_dayjs9.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
|
|
});
|
|
if (showWeekNumber) {
|
|
for (let rowIndex = 0; rowIndex < 6; rowIndex++)
|
|
if (rows_[rowIndex][1].dayjs)
|
|
rows_[rowIndex][0] = {
|
|
type: "week",
|
|
text: rows_[rowIndex][1].dayjs.week()
|
|
};
|
|
}
|
|
return rows_;
|
|
});
|
|
watch(() => props2.date, async () => {
|
|
var _a;
|
|
if ((_a = unref(tbodyRef)) == null ? void 0 : _a.contains(document.activeElement)) {
|
|
await nextTick();
|
|
await focus();
|
|
}
|
|
});
|
|
const focus = async () => {
|
|
var _a;
|
|
return (_a = unref(currentCellRef)) == null ? void 0 : _a.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_dayjs9.default)(date4).locale(unref(lang)).isSame(props2.date.date(Number(cell.text)), "day");
|
|
};
|
|
const getDateOfCell = (row, column2) => {
|
|
const startOfMonthDay = unref(days).startOfMonthDay;
|
|
const offset3 = unref(offsetDay);
|
|
const numberOfDaysFromPreviousMonth = startOfMonthDay + offset3 < 0 ? 7 + startOfMonthDay + offset3 : startOfMonthDay + offset3;
|
|
const offsetFromStart = row * 7 + (column2 - (props2.showWeekNumber ? 1 : 0));
|
|
return props2.date.startOf("month").subtract(numberOfDaysFromPreviousMonth, "day").add(offsetFromStart, "day");
|
|
};
|
|
const handleMouseMove = (event) => {
|
|
var _a;
|
|
if (!props2.rangeState.selecting)
|
|
return;
|
|
let target2 = event.target;
|
|
if (target2.tagName === "SPAN")
|
|
target2 = (_a = target2.parentNode) == null ? void 0 : _a.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 && isNormalDay(cell.type) || cell.isCurrent;
|
|
};
|
|
const handleFocus = (event) => {
|
|
if (focusWithClick || unref(hasCurrent) || props2.selectionMode !== "date")
|
|
return;
|
|
handlePickDate(event, true);
|
|
};
|
|
const handleMouseDown = (event) => {
|
|
if (!event.target.closest("td"))
|
|
return;
|
|
focusWithClick = true;
|
|
};
|
|
const handleMouseUp = (event) => {
|
|
if (!event.target.closest("td"))
|
|
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) => {
|
|
emit("pick", selected ? castArray2(props2.parsedValue).filter((d2) => (d2 == null ? void 0 : d2.valueOf()) !== newDate.valueOf()) : castArray2(props2.parsedValue).concat([newDate]));
|
|
};
|
|
const handlePickDate = (event, isKeyboardMovement = false) => {
|
|
if (props2.disabled)
|
|
return;
|
|
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;
|
|
default:
|
|
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;
|
|
return props2.parsedValue.subtract(dayOffset, "day").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(), ns.is("week-mode", props2.selectionMode === "week" && !props2.disabled)]);
|
|
const tableLabel = computed(() => t("el.datepicker.dateTablePrompt"));
|
|
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 || props2.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,
|
|
weekHeaderClass: ns.e("week-header"),
|
|
getCellClasses,
|
|
getRowKls,
|
|
t
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/props/basic-cell.mjs
|
|
var basicCellProps = buildProps({ cell: { type: definePropType(Object) } });
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/date-picker-com/basic-cell-render.mjs
|
|
var basic_cell_render_default = 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 _a;
|
|
return [createVNode("div", { "class": ns.b() }, [createVNode("span", { "class": ns.e("text") }, [(_a = cell == null ? void 0 : cell.renderText) != null ? _a : cell == null ? void 0 : cell.text])])];
|
|
});
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/date-picker-com/basic-date-table.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_129 = ["aria-label"];
|
|
var _hoisted_212 = ["aria-label"];
|
|
var _hoisted_34 = [
|
|
"aria-current",
|
|
"aria-selected",
|
|
"tabindex",
|
|
"aria-disabled"
|
|
];
|
|
var basic_date_table_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
__name: "basic-date-table",
|
|
props: basicDateTableProps,
|
|
emits: basicDateTableEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const { WEEKS, rows, tbodyRef, currentCellRef, focus, isCurrent, isWeekActive, isSelectedCell, handlePickDate, handleMouseUp, handleMouseDown, handleMouseMove, handleFocus } = useBasicDateTable(props2, __emit);
|
|
const { tableLabel, tableKls, getCellClasses, getRowKls, weekHeaderClass, 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: _cache[1] || (_cache[1] = (...args) => unref(handlePickDate) && unref(handlePickDate)(...args)),
|
|
onMousemove: _cache[2] || (_cache[2] = (...args) => unref(handleMouseMove) && unref(handleMouseMove)(...args)),
|
|
onMousedown: _cache[3] || (_cache[3] = (...args) => unref(handleMouseDown) && unref(handleMouseDown)(...args)),
|
|
onMouseup: _cache[4] || (_cache[4] = (...args) => unref(handleMouseUp) && unref(handleMouseUp)(...args))
|
|
}, [createBaseVNode("tbody", {
|
|
ref_key: "tbodyRef",
|
|
ref: tbodyRef
|
|
}, [createBaseVNode("tr", null, [_ctx.showWeekNumber ? (openBlock(), createElementBlock("th", {
|
|
key: 0,
|
|
scope: "col",
|
|
class: normalizeClass(unref(weekHeaderClass))
|
|
}, null, 2)) : 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, _hoisted_212);
|
|
}), 128))]), (openBlock(true), createElementBlock(Fragment, null, renderList(unref(rows), (row, rowKey2) => {
|
|
return openBlock(), createElementBlock("tr", {
|
|
key: rowKey2,
|
|
class: normalizeClass(unref(getRowKls)(_ctx.showWeekNumber ? row[2] : 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: _ctx.disabled ? void 0 : unref(isSelectedCell)(cell) ? 0 : -1,
|
|
"aria-disabled": _ctx.disabled,
|
|
onFocus: _cache[0] || (_cache[0] = (...args) => unref(handleFocus) && unref(handleFocus)(...args))
|
|
}, [createVNode(unref(basic_cell_render_default), { cell }, null, 8, ["cell"])], 42, _hoisted_34);
|
|
}), 128))], 2);
|
|
}), 128))], 512)], 42, _hoisted_129);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/date-picker-com/basic-date-table.mjs
|
|
var basic_date_table_default = basic_date_table_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/props/basic-month-table.mjs
|
|
var basicMonthTableProps = buildProps({
|
|
...datePickerSharedProps,
|
|
selectionMode: selectionModeWithDefault("month")
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/date-picker-com/basic-month-table.vue_vue_type_script_setup_true_lang.mjs
|
|
var import_dayjs10 = __toESM(require_dayjs_min(), 1);
|
|
var _hoisted_130 = ["aria-label"];
|
|
var _hoisted_213 = [
|
|
"aria-selected",
|
|
"aria-label",
|
|
"tabindex",
|
|
"onKeydown"
|
|
];
|
|
var basic_month_table_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
__name: "basic-month-table",
|
|
props: basicMonthTableProps,
|
|
emits: [
|
|
"changerange",
|
|
"pick",
|
|
"select"
|
|
],
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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 _a, _b, _c;
|
|
const rows2 = tableRows.value;
|
|
const now2 = (0, import_dayjs10.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,
|
|
isSelected: false,
|
|
customClass: void 0,
|
|
date: void 0,
|
|
dayjs: void 0,
|
|
isCurrent: void 0,
|
|
selected: void 0,
|
|
renderText: void 0,
|
|
timestamp: void 0
|
|
});
|
|
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 ((_a = props2.minDate) == null ? void 0 : _a.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"));
|
|
}
|
|
if (now2.isSame(calTime))
|
|
cell.type = "today";
|
|
const cellDate = calTime.toDate();
|
|
cell.text = index;
|
|
cell.disabled = ((_b = props2.disabledDate) == null ? void 0 : _b.call(props2, cellDate)) || false;
|
|
cell.date = cellDate;
|
|
cell.customClass = (_c = props2.cellClassName) == null ? void 0 : _c.call(props2, cellDate);
|
|
cell.dayjs = calTime;
|
|
cell.timestamp = calTime.valueOf();
|
|
cell.isSelected = isSelectedCell(cell);
|
|
}
|
|
}
|
|
return rows2;
|
|
});
|
|
const focus = () => {
|
|
var _a;
|
|
(_a = currentCellRef.value) == null ? void 0 : _a.focus();
|
|
};
|
|
const getCellStyle = (cell) => {
|
|
const style = {};
|
|
const year = props2.date.year();
|
|
const today = new Date();
|
|
const month = cell.text;
|
|
style.disabled = props2.disabled || (props2.disabledDate ? datesInMonth(props2.date, year, month, lang.value).every(props2.disabledDate) : false);
|
|
style.current = castArray2(props2.parsedValue).some((date4) => import_dayjs10.default.isDayjs(date4) && date4.year() === year && date4.month() === month);
|
|
style.today = today.getFullYear() === year && today.getMonth() === month;
|
|
if (cell.customClass)
|
|
style[cell.customClass] = true;
|
|
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).some((date4) => date4.year() === year && date4.month() === month);
|
|
};
|
|
const handleMouseMove = (event) => {
|
|
var _a;
|
|
if (!props2.rangeState.selecting)
|
|
return;
|
|
let target2 = event.target;
|
|
if (target2.tagName === "SPAN")
|
|
target2 = (_a = target2.parentNode) == null ? void 0 : _a.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 _a;
|
|
if (props2.disabled)
|
|
return;
|
|
const target2 = (_a = event.target) == null ? void 0 : _a.closest("td");
|
|
if ((target2 == null ? void 0 : target2.tagName) !== "TD")
|
|
return;
|
|
if (hasClass(target2, "disabled"))
|
|
return;
|
|
const column2 = target2.cellIndex;
|
|
const month = target2.parentNode.rowIndex * 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);
|
|
emit("pick", 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_dayjs10.default)(newMonth)]));
|
|
} 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 _a, _b;
|
|
if ((_a = tbodyRef.value) == null ? void 0 : _a.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(rows.value, (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) => cell.isSelected && (currentCellRef.value = el),
|
|
class: normalizeClass(getCellStyle(cell)),
|
|
"aria-selected": !!cell.isSelected,
|
|
"aria-label": unref(t)(`el.datepicker.month${+cell.text + 1}`),
|
|
tabindex: cell.isSelected ? 0 : -1,
|
|
onKeydown: [withKeys(withModifiers(handleMonthTableClick, ["prevent", "stop"]), ["space"]), withKeys(withModifiers(handleMonthTableClick, ["prevent", "stop"]), ["enter"])]
|
|
}, [createVNode(unref(basic_cell_render_default), { cell: {
|
|
...cell,
|
|
renderText: unref(t)("el.datepicker.months." + months.value[cell.text])
|
|
} }, null, 8, ["cell"])], 42, _hoisted_213);
|
|
}), 128))]);
|
|
}), 128))], 512)], 42, _hoisted_130);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/date-picker-com/basic-month-table.mjs
|
|
var basic_month_table_default = basic_month_table_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/props/basic-year-table.mjs
|
|
var basicYearTableProps = buildProps({
|
|
...datePickerSharedProps,
|
|
selectionMode: selectionModeWithDefault("year")
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/date-picker-com/basic-year-table.vue_vue_type_script_setup_true_lang.mjs
|
|
var import_dayjs11 = __toESM(require_dayjs_min(), 1);
|
|
var _hoisted_131 = ["aria-label"];
|
|
var _hoisted_214 = [
|
|
"aria-selected",
|
|
"aria-label",
|
|
"tabindex",
|
|
"onKeydown"
|
|
];
|
|
var basic_year_table_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
__name: "basic-year-table",
|
|
props: basicYearTableProps,
|
|
emits: [
|
|
"changerange",
|
|
"pick",
|
|
"select"
|
|
],
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const datesInYear = (year, lang2) => {
|
|
const firstDay = (0, import_dayjs11.default)(String(year)).locale(lang2).startOf("year");
|
|
return rangeArr(firstDay.endOf("year").dayOfYear()).map((n) => firstDay.add(n, "day").toDate());
|
|
};
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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 _a, _b, _c;
|
|
const rows2 = tableRows.value;
|
|
const now2 = (0, import_dayjs11.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,
|
|
isSelected: false,
|
|
customClass: void 0,
|
|
date: void 0,
|
|
dayjs: void 0,
|
|
isCurrent: void 0,
|
|
selected: void 0,
|
|
renderText: void 0,
|
|
timestamp: void 0
|
|
};
|
|
cell.type = "normal";
|
|
const index = i * 4 + j + startYear.value;
|
|
const calTime = (0, import_dayjs11.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 ((_a = props2.minDate) == null ? void 0 : _a.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"));
|
|
}
|
|
if (now2.isSame(calTime))
|
|
cell.type = "today";
|
|
cell.text = index;
|
|
const cellDate = calTime.toDate();
|
|
cell.disabled = ((_b = props2.disabledDate) == null ? void 0 : _b.call(props2, cellDate)) || false;
|
|
cell.date = cellDate;
|
|
cell.customClass = (_c = props2.cellClassName) == null ? void 0 : _c.call(props2, cellDate);
|
|
cell.dayjs = calTime;
|
|
cell.timestamp = calTime.valueOf();
|
|
cell.isSelected = isSelectedCell(cell);
|
|
row[j] = cell;
|
|
}
|
|
}
|
|
return rows2;
|
|
});
|
|
const focus = () => {
|
|
var _a;
|
|
(_a = currentCellRef.value) == null ? void 0 : _a.focus();
|
|
};
|
|
const getCellKls = (cell) => {
|
|
const kls = {};
|
|
const today = (0, import_dayjs11.default)().locale(lang.value);
|
|
const year = cell.text;
|
|
kls.disabled = props2.disabled || (props2.disabledDate ? datesInYear(year, lang.value).every(props2.disabledDate) : false);
|
|
kls.today = today.year() === year;
|
|
kls.current = castArray2(props2.parsedValue).some((d2) => d2.year() === year);
|
|
if (cell.customClass)
|
|
kls[cell.customClass] = true;
|
|
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).some((date4) => date4.year() === year);
|
|
};
|
|
const handleYearTableClick = (event) => {
|
|
var _a;
|
|
if (props2.disabled)
|
|
return;
|
|
const target2 = (_a = event.target) == null ? void 0 : _a.closest("td");
|
|
if (!target2 || !target2.textContent || hasClass(target2, "disabled"))
|
|
return;
|
|
const column2 = target2.cellIndex;
|
|
const selectedYear = target2.parentNode.rowIndex * 4 + column2 + startYear.value;
|
|
const newDate = (0, import_dayjs11.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);
|
|
emit("pick", hasClass(target2, "current") ? castArray2(props2.parsedValue).filter((d2) => (d2 == null ? void 0 : d2.year()) !== selectedYear) : castArray2(props2.parsedValue).concat([vaildYear]));
|
|
} else
|
|
emit("pick", selectedYear);
|
|
};
|
|
const handleMouseMove = (event) => {
|
|
var _a;
|
|
if (!props2.rangeState.selecting)
|
|
return;
|
|
const target2 = (_a = event.target) == null ? void 0 : _a.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_dayjs11.default)().year(startYear.value).add(row * 4 + column2, "year")
|
|
});
|
|
}
|
|
};
|
|
watch(() => props2.date, async () => {
|
|
var _a, _b;
|
|
if ((_a = tbodyRef.value) == null ? void 0 : _a.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(rows.value, (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) => cell.isSelected && (currentCellRef.value = el),
|
|
class: normalizeClass(["available", getCellKls(cell)]),
|
|
"aria-selected": cell.isSelected,
|
|
"aria-label": String(cell.text),
|
|
tabindex: cell.isSelected ? 0 : -1,
|
|
onKeydown: [withKeys(withModifiers(handleYearTableClick, ["prevent", "stop"]), ["space"]), withKeys(withModifiers(handleYearTableClick, ["prevent", "stop"]), ["enter"])]
|
|
}, [createVNode(unref(basic_cell_render_default), { cell }, null, 8, ["cell"])], 42, _hoisted_214);
|
|
}), 128))]);
|
|
}), 128))], 512)], 42, _hoisted_131);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/date-picker-com/basic-year-table.mjs
|
|
var basic_year_table_default = basic_year_table_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/date-picker-com/panel-date-pick.vue_vue_type_script_setup_true_lang.mjs
|
|
var import_dayjs12 = __toESM(require_dayjs_min(), 1);
|
|
var _hoisted_132 = ["disabled", "onClick"];
|
|
var _hoisted_215 = ["aria-label", "disabled"];
|
|
var _hoisted_35 = ["aria-label", "disabled"];
|
|
var _hoisted_42 = ["tabindex", "aria-disabled"];
|
|
var _hoisted_52 = ["tabindex", "aria-disabled"];
|
|
var _hoisted_62 = ["aria-label", "disabled"];
|
|
var _hoisted_7 = ["aria-label", "disabled"];
|
|
var panel_date_pick_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
__name: "panel-date-pick",
|
|
props: panelDatePickProps,
|
|
emits: [
|
|
"pick",
|
|
"set-picker-option",
|
|
"panel-change"
|
|
],
|
|
setup(__props, { emit: __emit }) {
|
|
const timeWithinRange = (_2, __, ___) => true;
|
|
const props2 = __props;
|
|
const contextEmit = __emit;
|
|
const ppNs = useNamespace("picker-panel");
|
|
const dpNs = useNamespace("date-picker");
|
|
const attrs = useAttrs();
|
|
const slots = useSlots();
|
|
const { t, lang } = useLocale();
|
|
const pickerBase = inject(PICKER_BASE_INJECTION_KEY);
|
|
const isDefaultFormat = inject(ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY, void 0);
|
|
const { shortcuts, disabledDate, cellClassName, defaultTime } = pickerBase.props;
|
|
const defaultValue = toRef(pickerBase.props, "defaultValue");
|
|
const currentViewRef = ref();
|
|
const innerDate = ref((0, import_dayjs12.default)().locale(lang.value));
|
|
const isChangeToNow = ref(false);
|
|
let isShortcut = false;
|
|
const defaultTimeD = computed(() => {
|
|
return (0, import_dayjs12.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 || DEFAULT_FORMATS_TIME) : 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))
|
|
contextEmit("pick", value.map(formatEmit), ...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" && import_dayjs12.default.isDayjs(value)) {
|
|
const parsedDateValue = extractFirst(props2.parsedValue);
|
|
let newDate = parsedDateValue ? parsedDateValue.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);
|
|
} 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_dayjs12.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") {
|
|
innerDate.value = getValidDateOfYear(innerDate.value.startOf("year").year(year2), lang.value, disabledDate);
|
|
emit(innerDate.value, false);
|
|
} else if (selectionMode.value === "years")
|
|
emit(year2, keepOpen != null ? keepOpen : true);
|
|
else {
|
|
innerDate.value = getValidDateOfYear(innerDate.value.year(year2), lang.value, disabledDate);
|
|
currentView.value = "month";
|
|
if ([
|
|
"month",
|
|
"year",
|
|
"date",
|
|
"week"
|
|
].includes(selectionMode.value)) {
|
|
emit(innerDate.value, true);
|
|
await nextTick();
|
|
handleFocusPicker();
|
|
}
|
|
}
|
|
handlePanelChange("year");
|
|
};
|
|
const dateDisabled = useFormDisabled();
|
|
const showPicker = async (view) => {
|
|
if (dateDisabled.value)
|
|
return;
|
|
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 footerFilled = computed(() => !isMultipleType.value && props2.showNow || props2.showConfirm);
|
|
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 = extractFirst(props2.parsedValue);
|
|
if (!result2) {
|
|
const defaultTimeD2 = (0, import_dayjs12.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_dayjs12.default)().locale(lang.value).toDate());
|
|
});
|
|
const changeToNow = () => {
|
|
const nowDate = (0, import_dayjs12.default)().locale(lang.value).toDate();
|
|
isChangeToNow.value = true;
|
|
if ((!disabledDate || !disabledDate(nowDate)) && checkDateWithinRange(nowDate)) {
|
|
innerDate.value = (0, import_dayjs12.default)().locale(lang.value);
|
|
emit(innerDate.value);
|
|
}
|
|
};
|
|
const timeFormat = computed(() => {
|
|
return props2.timeFormat || extractTimeFormat(props2.format) || DEFAULT_FORMATS_TIME;
|
|
});
|
|
const dateFormat = computed(() => {
|
|
return props2.dateFormat || extractDateFormat(props2.format) || DEFAULT_FORMATS_DATE;
|
|
});
|
|
const visibleTime = computed(() => {
|
|
if (userInputTime.value)
|
|
return userInputTime.value;
|
|
if (!props2.parsedValue && !defaultValue.value)
|
|
return;
|
|
return (extractFirst(props2.parsedValue) || innerDate.value).format(timeFormat.value);
|
|
});
|
|
const visibleDate = computed(() => {
|
|
if (userInputDate.value)
|
|
return userInputDate.value;
|
|
if (!props2.parsedValue && !defaultValue.value)
|
|
return;
|
|
return (extractFirst(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 parsedDateValue = extractFirst(props2.parsedValue);
|
|
innerDate.value = parsedDateValue ? parsedDateValue.hour(hour).minute(minute).second(second) : value;
|
|
emit(innerDate.value, true);
|
|
if (!first)
|
|
timePickerVisible.value = visible;
|
|
};
|
|
const handleVisibleTimeChange = (value) => {
|
|
const newDate = (0, import_dayjs12.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_dayjs12.default.isDayjs(date4) && date4.isValid() && (disabledDate ? !disabledDate(date4.toDate()) : true);
|
|
};
|
|
const parseUserInput = (value) => {
|
|
return correctlyParseUserInput(value, props2.format, lang.value, isDefaultFormat);
|
|
};
|
|
const getDefaultValue2 = () => {
|
|
const parseDate2 = (0, import_dayjs12.default)(defaultValue.value).locale(lang.value);
|
|
if (!defaultValue.value) {
|
|
const defaultTimeDValue = defaultTimeD.value;
|
|
return (0, import_dayjs12.default)().hour(defaultTimeDValue.hour()).minute(defaultTimeDValue.minute()).second(defaultTimeDValue.second()).locale(lang.value);
|
|
}
|
|
return parseDate2;
|
|
};
|
|
const handleFocusPicker = () => {
|
|
var _a;
|
|
if ([
|
|
"week",
|
|
"month",
|
|
"year",
|
|
"date"
|
|
].includes(selectionMode.value))
|
|
(_a = currentViewRef.value) == null ? void 0 : _a.focus();
|
|
};
|
|
const _handleFocusPicker = () => {
|
|
handleFocusPicker();
|
|
if (selectionMode.value === "week")
|
|
handleKeyControl(EVENT_CODE.down);
|
|
};
|
|
const handleKeydownTable = (event) => {
|
|
const code = getEventCode(event);
|
|
if ([
|
|
EVENT_CODE.up,
|
|
EVENT_CODE.down,
|
|
EVENT_CODE.left,
|
|
EVENT_CODE.right,
|
|
EVENT_CODE.home,
|
|
EVENT_CODE.end,
|
|
EVENT_CODE.pageUp,
|
|
EVENT_CODE.pageDown
|
|
].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 _a;
|
|
const { up, down, left, right, home, end, pageUp, pageDown } = EVENT_CODE;
|
|
const mapping = {
|
|
year: {
|
|
[up]: -4,
|
|
[down]: 4,
|
|
[left]: -1,
|
|
[right]: 1,
|
|
offset: (date4, step2) => date4.setFullYear(date4.getFullYear() + step2)
|
|
},
|
|
month: {
|
|
[up]: -4,
|
|
[down]: 4,
|
|
[left]: -1,
|
|
[right]: 1,
|
|
offset: (date4, step2) => date4.setMonth(date4.getMonth() + step2)
|
|
},
|
|
week: {
|
|
[up]: -1,
|
|
[down]: 1,
|
|
[left]: -1,
|
|
[right]: 1,
|
|
offset: (date4, step2) => date4.setDate(date4.getDate() + step2 * 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, step2) => date4.setDate(date4.getDate() + step2)
|
|
}
|
|
};
|
|
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) : (_a = map2[code]) != null ? _a : 0);
|
|
if (disabledDate && disabledDate(newDate))
|
|
break;
|
|
const result2 = (0, import_dayjs12.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(() => 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", ["parseUserInput", parseUserInput]);
|
|
contextEmit("set-picker-option", ["handleFocusPicker", _handleFocusPicker]);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", { class: normalizeClass([
|
|
unref(ppNs).b(),
|
|
unref(dpNs).b(),
|
|
unref(ppNs).is("border", _ctx.border),
|
|
unref(ppNs).is("disabled", unref(dateDisabled)),
|
|
{
|
|
"has-sidebar": _ctx.$slots.sidebar || hasShortcuts.value,
|
|
"has-time": showTime.value
|
|
}
|
|
]) }, [createBaseVNode("div", { class: normalizeClass(unref(ppNs).e("body-wrapper")) }, [
|
|
renderSlot(_ctx.$slots, "sidebar", { class: normalizeClass(unref(ppNs).e("sidebar")) }),
|
|
hasShortcuts.value ? (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",
|
|
disabled: unref(dateDisabled),
|
|
class: normalizeClass(unref(ppNs).e("shortcut")),
|
|
onClick: ($event) => handleShortcutClick(shortcut)
|
|
}, toDisplayString(shortcut.text), 11, _hoisted_132);
|
|
}), 128))], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", { class: normalizeClass(unref(ppNs).e("body")) }, [
|
|
showTime.value ? (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": visibleDate.value,
|
|
size: "small",
|
|
"validate-event": false,
|
|
disabled: unref(dateDisabled),
|
|
readonly: !_ctx.editable,
|
|
onInput: _cache[0] || (_cache[0] = (val) => userInputDate.value = val),
|
|
onChange: handleVisibleDateChange
|
|
}, null, 8, [
|
|
"placeholder",
|
|
"model-value",
|
|
"disabled",
|
|
"readonly"
|
|
])], 2), withDirectives((openBlock(), createElementBlock("span", { class: normalizeClass(unref(dpNs).e("editor-wrap")) }, [createVNode(unref(ElInput), {
|
|
placeholder: unref(t)("el.datepicker.selectTime"),
|
|
"model-value": visibleTime.value,
|
|
size: "small",
|
|
"validate-event": false,
|
|
disabled: unref(dateDisabled),
|
|
readonly: !_ctx.editable,
|
|
onFocus: onTimePickerInputFocus,
|
|
onInput: _cache[1] || (_cache[1] = (val) => userInputTime.value = val),
|
|
onChange: handleVisibleTimeChange
|
|
}, null, 8, [
|
|
"placeholder",
|
|
"model-value",
|
|
"disabled",
|
|
"readonly"
|
|
]), createVNode(unref(panel_time_pick_default), {
|
|
visible: timePickerVisible.value,
|
|
format: timeFormat.value,
|
|
"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).em("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")]),
|
|
disabled: unref(dateDisabled),
|
|
onClick: _cache[2] || (_cache[2] = ($event) => moveByYear(false))
|
|
}, [renderSlot(_ctx.$slots, "prev-year", {}, () => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(d_arrow_left_default))]),
|
|
_: 1
|
|
})])], 10, _hoisted_215), withDirectives(createBaseVNode("button", {
|
|
type: "button",
|
|
"aria-label": unref(t)(`el.datepicker.prevMonth`),
|
|
class: normalizeClass([unref(ppNs).e("icon-btn"), "arrow-left"]),
|
|
disabled: unref(dateDisabled),
|
|
onClick: _cache[3] || (_cache[3] = ($event) => moveByMonth(false))
|
|
}, [renderSlot(_ctx.$slots, "prev-month", {}, () => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(arrow_left_default))]),
|
|
_: 1
|
|
})])], 10, _hoisted_35), [[vShow, currentView.value === "date"]])], 2),
|
|
createBaseVNode("span", {
|
|
role: "button",
|
|
class: normalizeClass(unref(dpNs).e("header-label")),
|
|
"aria-live": "polite",
|
|
tabindex: _ctx.disabled ? void 0 : 0,
|
|
"aria-disabled": _ctx.disabled,
|
|
onKeydown: _cache[4] || (_cache[4] = withKeys(($event) => showPicker("year"), ["enter"])),
|
|
onClick: _cache[5] || (_cache[5] = ($event) => showPicker("year"))
|
|
}, toDisplayString(yearLabel.value), 43, _hoisted_42),
|
|
withDirectives(createBaseVNode("span", {
|
|
role: "button",
|
|
"aria-live": "polite",
|
|
tabindex: _ctx.disabled ? void 0 : 0,
|
|
"aria-disabled": _ctx.disabled,
|
|
class: normalizeClass([unref(dpNs).e("header-label"), { active: currentView.value === "month" }]),
|
|
onKeydown: _cache[6] || (_cache[6] = withKeys(($event) => showPicker("month"), ["enter"])),
|
|
onClick: _cache[7] || (_cache[7] = ($event) => showPicker("month"))
|
|
}, toDisplayString(unref(t)(`el.datepicker.month${month.value + 1}`)), 43, _hoisted_52), [[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"]),
|
|
disabled: unref(dateDisabled),
|
|
onClick: _cache[8] || (_cache[8] = ($event) => moveByMonth(true))
|
|
}, [renderSlot(_ctx.$slots, "next-month", {}, () => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(arrow_right_default))]),
|
|
_: 1
|
|
})])], 10, _hoisted_62), [[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"]),
|
|
disabled: unref(dateDisabled),
|
|
onClick: _cache[9] || (_cache[9] = ($event) => moveByYear(true))
|
|
}, [renderSlot(_ctx.$slots, "next-year", {}, () => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(d_arrow_right_default))]),
|
|
_: 1
|
|
})])], 10, _hoisted_7)], 2)
|
|
], 2), [[vShow, currentView.value !== "time"]]),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ppNs).e("content")),
|
|
onKeydown: handleKeydownTable
|
|
}, [
|
|
currentView.value === "date" ? (openBlock(), createBlock(basic_date_table_default, {
|
|
key: 0,
|
|
ref_key: "currentViewRef",
|
|
ref: currentViewRef,
|
|
"selection-mode": selectionMode.value,
|
|
date: innerDate.value,
|
|
"parsed-value": _ctx.parsedValue,
|
|
"disabled-date": unref(disabledDate),
|
|
disabled: unref(dateDisabled),
|
|
"cell-class-name": unref(cellClassName),
|
|
"show-week-number": _ctx.showWeekNumber,
|
|
onPick: handleDatePick
|
|
}, null, 8, [
|
|
"selection-mode",
|
|
"date",
|
|
"parsed-value",
|
|
"disabled-date",
|
|
"disabled",
|
|
"cell-class-name",
|
|
"show-week-number"
|
|
])) : createCommentVNode("v-if", true),
|
|
currentView.value === "year" ? (openBlock(), createBlock(basic_year_table_default, {
|
|
key: 1,
|
|
ref_key: "currentViewRef",
|
|
ref: currentViewRef,
|
|
"selection-mode": selectionMode.value,
|
|
date: innerDate.value,
|
|
"disabled-date": unref(disabledDate),
|
|
disabled: unref(dateDisabled),
|
|
"parsed-value": _ctx.parsedValue,
|
|
"cell-class-name": unref(cellClassName),
|
|
onPick: handleYearPick
|
|
}, null, 8, [
|
|
"selection-mode",
|
|
"date",
|
|
"disabled-date",
|
|
"disabled",
|
|
"parsed-value",
|
|
"cell-class-name"
|
|
])) : createCommentVNode("v-if", true),
|
|
currentView.value === "month" ? (openBlock(), createBlock(basic_month_table_default, {
|
|
key: 2,
|
|
ref_key: "currentViewRef",
|
|
ref: currentViewRef,
|
|
"selection-mode": selectionMode.value,
|
|
date: innerDate.value,
|
|
"parsed-value": _ctx.parsedValue,
|
|
"disabled-date": unref(disabledDate),
|
|
disabled: unref(dateDisabled),
|
|
"cell-class-name": unref(cellClassName),
|
|
onPick: handleMonthPick
|
|
}, null, 8, [
|
|
"selection-mode",
|
|
"date",
|
|
"parsed-value",
|
|
"disabled-date",
|
|
"disabled",
|
|
"cell-class-name"
|
|
])) : createCommentVNode("v-if", true)
|
|
], 34)
|
|
], 2)
|
|
], 2), _ctx.showFooter && footerVisible.value && footerFilled.value ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ppNs).e("footer"))
|
|
}, [withDirectives(createVNode(unref(ElButton), {
|
|
text: "",
|
|
size: "small",
|
|
class: normalizeClass(unref(ppNs).e("link-btn")),
|
|
disabled: disabledNow.value,
|
|
onClick: changeToNow
|
|
}, {
|
|
default: withCtx(() => [createTextVNode(toDisplayString(unref(t)("el.datepicker.now")), 1)]),
|
|
_: 1
|
|
}, 8, ["class", "disabled"]), [[vShow, !isMultipleType.value && _ctx.showNow]]), _ctx.showConfirm ? (openBlock(), createBlock(unref(ElButton), {
|
|
key: 0,
|
|
plain: "",
|
|
size: "small",
|
|
class: normalizeClass(unref(ppNs).e("link-btn")),
|
|
disabled: disabledConfirm.value,
|
|
onClick: onConfirm
|
|
}, {
|
|
default: withCtx(() => [createTextVNode(toDisplayString(unref(t)("el.datepicker.confirm")), 1)]),
|
|
_: 1
|
|
}, 8, ["class", "disabled"])) : createCommentVNode("v-if", true)], 2)) : createCommentVNode("v-if", true)], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/date-picker-com/panel-date-pick.mjs
|
|
var panel_date_pick_default = panel_date_pick_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/props/panel-date-range.mjs
|
|
var panelDateRangeProps = buildProps({
|
|
...panelSharedProps,
|
|
...panelRangeSharedProps
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/composables/use-shortcut.mjs
|
|
var import_dayjs13 = __toESM(require_dayjs_min(), 1);
|
|
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_dayjs13.default)(shortcutValues[0]).locale(lang.value), (0, import_dayjs13.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-panel/src/composables/use-range-picker.mjs
|
|
var import_dayjs14 = __toESM(require_dayjs_min(), 1);
|
|
var useRangePicker = (props2, { defaultValue, defaultTime, leftDate, rightDate, step: step2, unit: unit4, sortDates }) => {
|
|
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 parseValue = (parsedValue) => {
|
|
if (isArray(parsedValue) && parsedValue.length === 2) {
|
|
const [start, end] = parsedValue;
|
|
minDate.value = start;
|
|
leftDate.value = start;
|
|
maxDate.value = end;
|
|
sortDates(unref(minDate), unref(maxDate));
|
|
} else
|
|
restoreDefault();
|
|
};
|
|
const restoreDefault = () => {
|
|
let [start, end] = getDefaultValue(unref(defaultValue), {
|
|
lang: unref(lang),
|
|
step: step2,
|
|
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_dayjs14.default);
|
|
leftShift = getShift(timeStart);
|
|
rightShift = getShift(timeEnd);
|
|
} else {
|
|
const shift3 = getShift((0, import_dayjs14.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, (parsedValue) => {
|
|
if (!(parsedValue == null ? void 0 : parsedValue.length) || !isEqual_default(parsedValue, [minDate.value, maxDate.value]))
|
|
parseValue(parsedValue);
|
|
}, { immediate: true });
|
|
watch(() => props2.visible, () => {
|
|
if (props2.visible)
|
|
parseValue(props2.parsedValue);
|
|
}, { immediate: true });
|
|
return {
|
|
minDate,
|
|
maxDate,
|
|
rangeState,
|
|
lang,
|
|
ppNs: pickerNs,
|
|
drpNs,
|
|
handleChangeRange,
|
|
handleRangeConfirm,
|
|
handleShortcutClick,
|
|
onSelect,
|
|
parseValue,
|
|
t
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/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 { disabledDate } = inject(PICKER_BASE_INJECTION_KEY).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) {
|
|
if (props2.disabled)
|
|
return;
|
|
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) {
|
|
if (props2.disabled)
|
|
return;
|
|
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")
|
|
startDate.value = getValidDateOfYear(startDate.value.year(value), 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-panel/src/date-picker-com/panel-date-range.vue_vue_type_script_setup_true_lang.mjs
|
|
var import_dayjs15 = __toESM(require_dayjs_min(), 1);
|
|
var _hoisted_133 = ["disabled", "onClick"];
|
|
var _hoisted_216 = ["aria-label", "disabled"];
|
|
var _hoisted_36 = ["aria-label", "disabled"];
|
|
var _hoisted_43 = ["disabled", "aria-label"];
|
|
var _hoisted_53 = ["disabled", "aria-label"];
|
|
var _hoisted_63 = ["tabindex", "aria-disabled"];
|
|
var _hoisted_72 = ["tabindex", "aria-disabled"];
|
|
var _hoisted_8 = ["disabled", "aria-label"];
|
|
var _hoisted_9 = ["disabled", "aria-label"];
|
|
var _hoisted_10 = ["aria-label", "disabled"];
|
|
var _hoisted_11 = ["disabled", "aria-label"];
|
|
var _hoisted_1210 = ["tabindex", "aria-disabled"];
|
|
var _hoisted_134 = ["tabindex", "aria-disabled"];
|
|
var unit = "month";
|
|
var panel_date_range_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
__name: "panel-date-range",
|
|
props: panelDateRangeProps,
|
|
emits: [
|
|
"pick",
|
|
"set-picker-option",
|
|
"calendar-change",
|
|
"panel-change",
|
|
"clear"
|
|
],
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const pickerBase = inject(PICKER_BASE_INJECTION_KEY);
|
|
const isDefaultFormat = inject(ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY, void 0);
|
|
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_dayjs15.default)().locale(lang.value));
|
|
const rightDate = ref((0, import_dayjs15.default)().locale(lang.value).add(1, unit));
|
|
const { minDate, maxDate, rangeState, ppNs, drpNs, handleChangeRange, handleRangeConfirm, handleShortcutClick, onSelect, parseValue, t } = useRangePicker(props2, {
|
|
defaultValue,
|
|
defaultTime,
|
|
leftDate,
|
|
rightDate,
|
|
unit,
|
|
sortDates
|
|
});
|
|
watch(() => props2.visible, (visible) => {
|
|
if (!visible && rangeState.value.selecting) {
|
|
parseValue(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 || "") || DEFAULT_FORMATS_TIME;
|
|
});
|
|
const dateFormat = computed(() => {
|
|
return props2.dateFormat || extractDateFormat(format2.value || "") || DEFAULT_FORMATS_DATE;
|
|
});
|
|
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 dateRangeDisabled = useFormDisabled();
|
|
const btnDisabled = computed(() => {
|
|
return !(minDate.value && maxDate.value && !rangeState.value.selecting && isValidRange2([minDate.value, maxDate.value]) && !dateRangeDisabled.value);
|
|
});
|
|
const showTime = computed(() => props2.type === "datetime" || props2.type === "datetimerange");
|
|
const formatEmit = (emitDayjs, index) => {
|
|
if (!emitDayjs)
|
|
return;
|
|
if (defaultTime)
|
|
return (0, import_dayjs15.default)(defaultTime[index] || defaultTime).locale(lang.value).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 (!showTime.value && close2)
|
|
close2 = !minDate_ || !maxDate_;
|
|
handleRangeConfirm(close2);
|
|
};
|
|
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_dayjs15.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");
|
|
}
|
|
}
|
|
sortDates(minDate.value, maxDate.value);
|
|
handleRangeConfirm(true);
|
|
}
|
|
};
|
|
const handleDateChange = (_2, type4) => {
|
|
dateUserInput.value[type4] = null;
|
|
};
|
|
const handleTimeInput = (value, type4) => {
|
|
timeUserInput.value[type4] = value;
|
|
const parsedValueD = (0, import_dayjs15.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());
|
|
leftDate.value = minDate.value;
|
|
} 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;
|
|
}
|
|
handleRangeConfirm(true);
|
|
};
|
|
const handleMinTimePick = (value, visible, first) => {
|
|
if (timeUserInput.value.min)
|
|
return;
|
|
if (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;
|
|
nextTick(() => {
|
|
parseValue(props2.parsedValue);
|
|
});
|
|
}
|
|
handleRangeConfirm(true);
|
|
};
|
|
const handleMaxTimePick = (value, visible, first) => {
|
|
if (timeUserInput.value.max)
|
|
return;
|
|
if (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;
|
|
handleRangeConfirm(true);
|
|
};
|
|
const onClear = () => {
|
|
handleClear();
|
|
emit("clear");
|
|
};
|
|
const handleClear = () => {
|
|
let valueOnClear = null;
|
|
if (pickerBase == null ? void 0 : pickerBase.emptyValues)
|
|
valueOnClear = pickerBase.emptyValues.valueOnClear.value;
|
|
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;
|
|
handleRangeConfirm(true);
|
|
emit("pick", valueOnClear);
|
|
};
|
|
const parseUserInput = (value) => {
|
|
return correctlyParseUserInput(value, format2.value || "", lang.value, isDefaultFormat);
|
|
};
|
|
function sortDates(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", ["handleClear", handleClear]);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", { class: normalizeClass([
|
|
unref(ppNs).b(),
|
|
unref(drpNs).b(),
|
|
unref(ppNs).is("border", _ctx.border),
|
|
unref(ppNs).is("disabled", unref(dateRangeDisabled)),
|
|
{
|
|
"has-sidebar": _ctx.$slots.sidebar || hasShortcuts.value,
|
|
"has-time": showTime.value
|
|
}
|
|
]) }, [createBaseVNode("div", { class: normalizeClass(unref(ppNs).e("body-wrapper")) }, [
|
|
renderSlot(_ctx.$slots, "sidebar", { class: normalizeClass(unref(ppNs).e("sidebar")) }),
|
|
hasShortcuts.value ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ppNs).e("sidebar"))
|
|
}, [(openBlock(true), createElementBlock(Fragment, null, renderList(shortcuts.value, (shortcut, key) => {
|
|
return openBlock(), createElementBlock("button", {
|
|
key,
|
|
type: "button",
|
|
disabled: unref(dateRangeDisabled),
|
|
class: normalizeClass(unref(ppNs).e("shortcut")),
|
|
onClick: ($event) => unref(handleShortcutClick)(shortcut)
|
|
}, toDisplayString(shortcut.text), 11, _hoisted_133);
|
|
}), 128))], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", { class: normalizeClass(unref(ppNs).e("body")) }, [
|
|
showTime.value ? (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 || unref(dateRangeDisabled),
|
|
placeholder: unref(t)("el.datepicker.startDate"),
|
|
class: normalizeClass(unref(drpNs).e("editor")),
|
|
"model-value": minVisibleDate.value,
|
|
"validate-event": false,
|
|
readonly: !_ctx.editable,
|
|
onInput: _cache[0] || (_cache[0] = (val) => handleDateInput(val, "min")),
|
|
onChange: _cache[1] || (_cache[1] = (val) => handleDateChange(val, "min"))
|
|
}, null, 8, [
|
|
"disabled",
|
|
"placeholder",
|
|
"class",
|
|
"model-value",
|
|
"readonly"
|
|
])], 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 || unref(dateRangeDisabled),
|
|
placeholder: unref(t)("el.datepicker.startTime"),
|
|
"model-value": minVisibleTime.value,
|
|
"validate-event": false,
|
|
readonly: !_ctx.editable,
|
|
onFocus: _cache[2] || (_cache[2] = ($event) => minTimePickerVisible.value = true),
|
|
onInput: _cache[3] || (_cache[3] = (val) => handleTimeInput(val, "min")),
|
|
onChange: _cache[4] || (_cache[4] = (val) => handleTimeChange(val, "min"))
|
|
}, null, 8, [
|
|
"class",
|
|
"disabled",
|
|
"placeholder",
|
|
"model-value",
|
|
"readonly"
|
|
]), createVNode(unref(panel_time_pick_default), {
|
|
visible: minTimePickerVisible.value,
|
|
format: timeFormat.value,
|
|
"datetime-role": "start",
|
|
"parsed-value": unref(minDate) || 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 || unref(dateRangeDisabled),
|
|
placeholder: unref(t)("el.datepicker.endDate"),
|
|
"model-value": maxVisibleDate.value,
|
|
readonly: !unref(minDate) || !_ctx.editable,
|
|
"validate-event": false,
|
|
onInput: _cache[5] || (_cache[5] = (val) => handleDateInput(val, "max")),
|
|
onChange: _cache[6] || (_cache[6] = (val) => handleDateChange(val, "max"))
|
|
}, null, 8, [
|
|
"class",
|
|
"disabled",
|
|
"placeholder",
|
|
"model-value",
|
|
"readonly"
|
|
])], 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 || unref(dateRangeDisabled),
|
|
placeholder: unref(t)("el.datepicker.endTime"),
|
|
"model-value": maxVisibleTime.value,
|
|
readonly: !unref(minDate) || !_ctx.editable,
|
|
"validate-event": false,
|
|
onFocus: _cache[7] || (_cache[7] = ($event) => unref(minDate) && (maxTimePickerVisible.value = true)),
|
|
onInput: _cache[8] || (_cache[8] = (val) => handleTimeInput(val, "max")),
|
|
onChange: _cache[9] || (_cache[9] = (val) => handleTimeChange(val, "max"))
|
|
}, null, 8, [
|
|
"class",
|
|
"disabled",
|
|
"placeholder",
|
|
"model-value",
|
|
"readonly"
|
|
]), createVNode(unref(panel_time_pick_default), {
|
|
"datetime-role": "end",
|
|
visible: maxTimePickerVisible.value,
|
|
format: timeFormat.value,
|
|
"parsed-value": unref(maxDate) || 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`),
|
|
disabled: unref(dateRangeDisabled),
|
|
onClick: leftPrevYear
|
|
}, [renderSlot(_ctx.$slots, "prev-year", {}, () => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(d_arrow_left_default))]),
|
|
_: 1
|
|
})])], 10, _hoisted_216),
|
|
withDirectives(createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass([unref(ppNs).e("icon-btn"), "arrow-left"]),
|
|
"aria-label": unref(t)(`el.datepicker.prevMonth`),
|
|
disabled: unref(dateRangeDisabled),
|
|
onClick: leftPrevMonth
|
|
}, [renderSlot(_ctx.$slots, "prev-month", {}, () => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(arrow_left_default))]),
|
|
_: 1
|
|
})])], 10, _hoisted_36), [[vShow, unref(leftCurrentView) === "date"]]),
|
|
_ctx.unlinkPanels ? (openBlock(), createElementBlock("button", {
|
|
key: 0,
|
|
type: "button",
|
|
disabled: !enableYearArrow.value || unref(dateRangeDisabled),
|
|
class: normalizeClass([[unref(ppNs).e("icon-btn"), unref(ppNs).is("disabled", !enableYearArrow.value || unref(dateRangeDisabled))], "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, _hoisted_43)) : createCommentVNode("v-if", true),
|
|
_ctx.unlinkPanels && unref(leftCurrentView) === "date" ? (openBlock(), createElementBlock("button", {
|
|
key: 1,
|
|
type: "button",
|
|
disabled: !enableMonthArrow.value || unref(dateRangeDisabled),
|
|
class: normalizeClass([[unref(ppNs).e("icon-btn"), unref(ppNs).is("disabled", !enableMonthArrow.value || unref(dateRangeDisabled))], "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, _hoisted_53)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", null, [createBaseVNode("span", {
|
|
role: "button",
|
|
class: normalizeClass(unref(drpNs).e("header-label")),
|
|
"aria-live": "polite",
|
|
tabindex: _ctx.disabled ? void 0 : 0,
|
|
"aria-disabled": _ctx.disabled,
|
|
onKeydown: _cache[10] || (_cache[10] = withKeys(($event) => unref(showLeftPicker)("year"), ["enter"])),
|
|
onClick: _cache[11] || (_cache[11] = ($event) => unref(showLeftPicker)("year"))
|
|
}, toDisplayString(unref(leftYearLabel)), 43, _hoisted_63), withDirectives(createBaseVNode("span", {
|
|
role: "button",
|
|
"aria-live": "polite",
|
|
tabindex: _ctx.disabled ? void 0 : 0,
|
|
"aria-disabled": _ctx.disabled,
|
|
class: normalizeClass([unref(drpNs).e("header-label"), { active: unref(leftCurrentView) === "month" }]),
|
|
onKeydown: _cache[12] || (_cache[12] = withKeys(($event) => unref(showLeftPicker)("month"), ["enter"])),
|
|
onClick: _cache[13] || (_cache[13] = ($event) => unref(showLeftPicker)("month"))
|
|
}, toDisplayString(unref(t)(`el.datepicker.month${leftDate.value.month() + 1}`)), 43, _hoisted_72), [[vShow, unref(leftCurrentView) === "date"]])])
|
|
], 2),
|
|
unref(leftCurrentView) === "date" ? (openBlock(), createBlock(basic_date_table_default, {
|
|
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),
|
|
"show-week-number": _ctx.showWeekNumber,
|
|
disabled: unref(dateRangeDisabled),
|
|
onChangerange: unref(handleChangeRange),
|
|
onPick: handleRangePick,
|
|
onSelect: unref(onSelect)
|
|
}, null, 8, [
|
|
"date",
|
|
"min-date",
|
|
"max-date",
|
|
"range-state",
|
|
"disabled-date",
|
|
"cell-class-name",
|
|
"show-week-number",
|
|
"disabled",
|
|
"onChangerange",
|
|
"onSelect"
|
|
])) : createCommentVNode("v-if", true),
|
|
unref(leftCurrentView) === "year" ? (openBlock(), createBlock(basic_year_table_default, {
|
|
key: 1,
|
|
ref_key: "leftCurrentViewRef",
|
|
ref: leftCurrentViewRef,
|
|
"selection-mode": "year",
|
|
date: leftDate.value,
|
|
"disabled-date": unref(disabledDate),
|
|
"parsed-value": _ctx.parsedValue,
|
|
disabled: unref(dateRangeDisabled),
|
|
onPick: unref(handleLeftYearPick)
|
|
}, null, 8, [
|
|
"date",
|
|
"disabled-date",
|
|
"parsed-value",
|
|
"disabled",
|
|
"onPick"
|
|
])) : createCommentVNode("v-if", true),
|
|
unref(leftCurrentView) === "month" ? (openBlock(), createBlock(basic_month_table_default, {
|
|
key: 2,
|
|
ref_key: "leftCurrentViewRef",
|
|
ref: leftCurrentViewRef,
|
|
"selection-mode": "month",
|
|
date: leftDate.value,
|
|
"parsed-value": _ctx.parsedValue,
|
|
"disabled-date": unref(disabledDate),
|
|
disabled: unref(dateRangeDisabled),
|
|
onPick: unref(handleLeftMonthPick)
|
|
}, null, 8, [
|
|
"date",
|
|
"parsed-value",
|
|
"disabled-date",
|
|
"disabled",
|
|
"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: !enableYearArrow.value || unref(dateRangeDisabled),
|
|
class: normalizeClass([[unref(ppNs).e("icon-btn"), unref(ppNs).is("disabled", !enableYearArrow.value || unref(dateRangeDisabled))], "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, _hoisted_8)) : createCommentVNode("v-if", true),
|
|
_ctx.unlinkPanels && unref(rightCurrentView) === "date" ? (openBlock(), createElementBlock("button", {
|
|
key: 1,
|
|
type: "button",
|
|
disabled: !enableMonthArrow.value || unref(dateRangeDisabled),
|
|
class: normalizeClass([[unref(ppNs).e("icon-btn"), unref(ppNs).is("disabled", !enableMonthArrow.value || unref(dateRangeDisabled))], "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, _hoisted_9)) : 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"]),
|
|
disabled: unref(dateRangeDisabled),
|
|
onClick: rightNextYear
|
|
}, [renderSlot(_ctx.$slots, "next-year", {}, () => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(d_arrow_right_default))]),
|
|
_: 1
|
|
})])], 10, _hoisted_10),
|
|
withDirectives(createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass([unref(ppNs).e("icon-btn"), "arrow-right"]),
|
|
disabled: unref(dateRangeDisabled),
|
|
"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, _hoisted_11), [[vShow, unref(rightCurrentView) === "date"]]),
|
|
createBaseVNode("div", null, [createBaseVNode("span", {
|
|
role: "button",
|
|
class: normalizeClass(unref(drpNs).e("header-label")),
|
|
"aria-live": "polite",
|
|
tabindex: _ctx.disabled ? void 0 : 0,
|
|
"aria-disabled": _ctx.disabled,
|
|
onKeydown: _cache[14] || (_cache[14] = withKeys(($event) => unref(showRightPicker)("year"), ["enter"])),
|
|
onClick: _cache[15] || (_cache[15] = ($event) => unref(showRightPicker)("year"))
|
|
}, toDisplayString(unref(rightYearLabel)), 43, _hoisted_1210), withDirectives(createBaseVNode("span", {
|
|
role: "button",
|
|
"aria-live": "polite",
|
|
tabindex: _ctx.disabled ? void 0 : 0,
|
|
"aria-disabled": _ctx.disabled,
|
|
class: normalizeClass([unref(drpNs).e("header-label"), { active: unref(rightCurrentView) === "month" }]),
|
|
onKeydown: _cache[16] || (_cache[16] = withKeys(($event) => unref(showRightPicker)("month"), ["enter"])),
|
|
onClick: _cache[17] || (_cache[17] = ($event) => unref(showRightPicker)("month"))
|
|
}, toDisplayString(unref(t)(`el.datepicker.month${rightDate.value.month() + 1}`)), 43, _hoisted_134), [[vShow, unref(rightCurrentView) === "date"]])])
|
|
], 2),
|
|
unref(rightCurrentView) === "date" ? (openBlock(), createBlock(basic_date_table_default, {
|
|
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),
|
|
"show-week-number": _ctx.showWeekNumber,
|
|
disabled: unref(dateRangeDisabled),
|
|
onChangerange: unref(handleChangeRange),
|
|
onPick: handleRangePick,
|
|
onSelect: unref(onSelect)
|
|
}, null, 8, [
|
|
"date",
|
|
"min-date",
|
|
"max-date",
|
|
"range-state",
|
|
"disabled-date",
|
|
"cell-class-name",
|
|
"show-week-number",
|
|
"disabled",
|
|
"onChangerange",
|
|
"onSelect"
|
|
])) : createCommentVNode("v-if", true),
|
|
unref(rightCurrentView) === "year" ? (openBlock(), createBlock(basic_year_table_default, {
|
|
key: 1,
|
|
ref_key: "rightCurrentViewRef",
|
|
ref: rightCurrentViewRef,
|
|
"selection-mode": "year",
|
|
date: rightDate.value,
|
|
"disabled-date": unref(disabledDate),
|
|
"parsed-value": _ctx.parsedValue,
|
|
disabled: unref(dateRangeDisabled),
|
|
onPick: unref(handleRightYearPick)
|
|
}, null, 8, [
|
|
"date",
|
|
"disabled-date",
|
|
"parsed-value",
|
|
"disabled",
|
|
"onPick"
|
|
])) : createCommentVNode("v-if", true),
|
|
unref(rightCurrentView) === "month" ? (openBlock(), createBlock(basic_month_table_default, {
|
|
key: 2,
|
|
ref_key: "rightCurrentViewRef",
|
|
ref: rightCurrentViewRef,
|
|
"selection-mode": "month",
|
|
date: rightDate.value,
|
|
"parsed-value": _ctx.parsedValue,
|
|
"disabled-date": unref(disabledDate),
|
|
disabled: unref(dateRangeDisabled),
|
|
onPick: unref(handleRightMonthPick)
|
|
}, null, 8, [
|
|
"date",
|
|
"parsed-value",
|
|
"disabled-date",
|
|
"disabled",
|
|
"onPick"
|
|
])) : createCommentVNode("v-if", true)
|
|
], 2)
|
|
], 2)
|
|
], 2), _ctx.showFooter && showTime.value && (_ctx.showConfirm || unref(clearable)) ? (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: onClear
|
|
}, {
|
|
default: withCtx(() => [createTextVNode(toDisplayString(unref(t)("el.datepicker.clear")), 1)]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true), _ctx.showConfirm ? (openBlock(), createBlock(unref(ElButton), {
|
|
key: 1,
|
|
plain: "",
|
|
size: "small",
|
|
class: normalizeClass(unref(ppNs).e("link-btn")),
|
|
disabled: btnDisabled.value,
|
|
onClick: _cache[18] || (_cache[18] = ($event) => unref(handleRangeConfirm)(false))
|
|
}, {
|
|
default: withCtx(() => [createTextVNode(toDisplayString(unref(t)("el.datepicker.confirm")), 1)]),
|
|
_: 1
|
|
}, 8, ["class", "disabled"])) : createCommentVNode("v-if", true)], 2)) : createCommentVNode("v-if", true)], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/date-picker-com/panel-date-range.mjs
|
|
var panel_date_range_default = panel_date_range_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/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-panel/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");
|
|
};
|
|
return {
|
|
leftPrevYear,
|
|
rightNextYear,
|
|
leftNextYear,
|
|
rightPrevYear,
|
|
leftLabel: computed(() => {
|
|
return `${leftDate.value.year()} ${t("el.datepicker.year")}`;
|
|
}),
|
|
rightLabel: computed(() => {
|
|
return `${rightDate.value.year()} ${t("el.datepicker.year")}`;
|
|
}),
|
|
leftYear: computed(() => {
|
|
return leftDate.value.year();
|
|
}),
|
|
rightYear: computed(() => {
|
|
return rightDate.value.year() === leftDate.value.year() ? leftDate.value.year() + 1 : rightDate.value.year();
|
|
})
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/date-picker-com/panel-month-range.vue_vue_type_script_setup_true_lang.mjs
|
|
var import_dayjs16 = __toESM(require_dayjs_min(), 1);
|
|
var _hoisted_135 = ["disabled", "onClick"];
|
|
var _hoisted_217 = ["disabled"];
|
|
var _hoisted_37 = ["disabled"];
|
|
var _hoisted_44 = ["disabled"];
|
|
var _hoisted_54 = ["disabled"];
|
|
var unit2 = "year";
|
|
var panel_month_range_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "DatePickerMonthRange",
|
|
__name: "panel-month-range",
|
|
props: panelMonthRangeProps,
|
|
emits: panelMonthRangeEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const { lang } = useLocale();
|
|
const pickerBase = inject(PICKER_BASE_INJECTION_KEY);
|
|
const isDefaultFormat = inject(ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY, void 0);
|
|
const { shortcuts, disabledDate, cellClassName } = pickerBase.props;
|
|
const format2 = toRef(pickerBase.props, "format");
|
|
const defaultValue = toRef(pickerBase.props, "defaultValue");
|
|
const leftDate = ref((0, import_dayjs16.default)().locale(lang.value));
|
|
const rightDate = ref((0, import_dayjs16.default)().locale(lang.value).add(1, unit2));
|
|
const { minDate, maxDate, rangeState, ppNs, drpNs, handleChangeRange, handleRangeConfirm, handleShortcutClick, onSelect, parseValue } = useRangePicker(props2, {
|
|
defaultValue,
|
|
leftDate,
|
|
rightDate,
|
|
unit: unit2,
|
|
sortDates
|
|
});
|
|
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 = () => {
|
|
let valueOnClear = null;
|
|
if (pickerBase == null ? void 0 : pickerBase.emptyValues)
|
|
valueOnClear = pickerBase.emptyValues.valueOnClear.value;
|
|
leftDate.value = getDefaultValue(unref(defaultValue), {
|
|
lang: unref(lang),
|
|
unit: "year",
|
|
unlinkPanels: props2.unlinkPanels
|
|
})[0];
|
|
rightDate.value = leftDate.value.add(1, "year");
|
|
emit("pick", valueOnClear);
|
|
};
|
|
const parseUserInput = (value) => {
|
|
return correctlyParseUserInput(value, format2.value, lang.value, isDefaultFormat);
|
|
};
|
|
function sortDates(minDate2, maxDate2) {
|
|
if (props2.unlinkPanels && maxDate2)
|
|
rightDate.value = ((minDate2 == null ? void 0 : minDate2.year()) || 0) === maxDate2.year() ? maxDate2.add(1, unit2) : maxDate2;
|
|
else
|
|
rightDate.value = leftDate.value.add(1, unit2);
|
|
}
|
|
const monthRangeDisabled = useFormDisabled();
|
|
watch(() => props2.visible, (visible) => {
|
|
if (!visible && rangeState.value.selecting) {
|
|
parseValue(props2.parsedValue);
|
|
onSelect(false);
|
|
}
|
|
});
|
|
emit("set-picker-option", ["isValidValue", isValidRange2]);
|
|
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(),
|
|
unref(ppNs).is("border", _ctx.border),
|
|
unref(ppNs).is("disabled", unref(monthRangeDisabled)),
|
|
{ "has-sidebar": Boolean(_ctx.$slots.sidebar) || hasShortcuts.value }
|
|
]) }, [createBaseVNode("div", { class: normalizeClass(unref(ppNs).e("body-wrapper")) }, [
|
|
renderSlot(_ctx.$slots, "sidebar", { class: normalizeClass(unref(ppNs).e("sidebar")) }),
|
|
hasShortcuts.value ? (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")),
|
|
disabled: unref(monthRangeDisabled),
|
|
onClick: ($event) => unref(handleShortcutClick)(shortcut)
|
|
}, toDisplayString(shortcut.text), 11, _hoisted_135);
|
|
}), 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"]),
|
|
disabled: unref(monthRangeDisabled),
|
|
onClick: _cache[0] || (_cache[0] = (...args) => unref(leftPrevYear) && unref(leftPrevYear)(...args))
|
|
}, [renderSlot(_ctx.$slots, "prev-year", {}, () => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(d_arrow_left_default))]),
|
|
_: 1
|
|
})])], 10, _hoisted_217),
|
|
_ctx.unlinkPanels ? (openBlock(), createElementBlock("button", {
|
|
key: 0,
|
|
type: "button",
|
|
disabled: !enableYearArrow.value || unref(monthRangeDisabled),
|
|
class: normalizeClass([[unref(ppNs).e("icon-btn"), unref(ppNs).is("disabled", !enableYearArrow.value || unref(monthRangeDisabled))], "d-arrow-right"]),
|
|
onClick: _cache[1] || (_cache[1] = (...args) => unref(leftNextYear) && unref(leftNextYear)(...args))
|
|
}, [renderSlot(_ctx.$slots, "next-year", {}, () => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(d_arrow_right_default))]),
|
|
_: 1
|
|
})])], 10, _hoisted_37)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", null, toDisplayString(unref(leftLabel)), 1)
|
|
], 2), createVNode(basic_month_table_default, {
|
|
"selection-mode": "range",
|
|
date: leftDate.value,
|
|
"min-date": unref(minDate),
|
|
"max-date": unref(maxDate),
|
|
"range-state": unref(rangeState),
|
|
"disabled-date": unref(disabledDate),
|
|
disabled: unref(monthRangeDisabled),
|
|
"cell-class-name": unref(cellClassName),
|
|
onChangerange: unref(handleChangeRange),
|
|
onPick: handleRangePick,
|
|
onSelect: unref(onSelect)
|
|
}, null, 8, [
|
|
"date",
|
|
"min-date",
|
|
"max-date",
|
|
"range-state",
|
|
"disabled-date",
|
|
"disabled",
|
|
"cell-class-name",
|
|
"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: !enableYearArrow.value || unref(monthRangeDisabled),
|
|
class: normalizeClass([[unref(ppNs).e("icon-btn"), unref(ppNs).is("disabled", !enableYearArrow.value || unref(monthRangeDisabled))], "d-arrow-left"]),
|
|
onClick: _cache[2] || (_cache[2] = (...args) => unref(rightPrevYear) && unref(rightPrevYear)(...args))
|
|
}, [renderSlot(_ctx.$slots, "prev-year", {}, () => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(d_arrow_left_default))]),
|
|
_: 1
|
|
})])], 10, _hoisted_44)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass([unref(ppNs).e("icon-btn"), "d-arrow-right"]),
|
|
disabled: unref(monthRangeDisabled),
|
|
onClick: _cache[3] || (_cache[3] = (...args) => unref(rightNextYear) && unref(rightNextYear)(...args))
|
|
}, [renderSlot(_ctx.$slots, "next-year", {}, () => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(d_arrow_right_default))]),
|
|
_: 1
|
|
})])], 10, _hoisted_54),
|
|
createBaseVNode("div", null, toDisplayString(unref(rightLabel)), 1)
|
|
], 2), createVNode(basic_month_table_default, {
|
|
"selection-mode": "range",
|
|
date: rightDate.value,
|
|
"min-date": unref(minDate),
|
|
"max-date": unref(maxDate),
|
|
"range-state": unref(rangeState),
|
|
"disabled-date": unref(disabledDate),
|
|
disabled: unref(monthRangeDisabled),
|
|
"cell-class-name": unref(cellClassName),
|
|
onChangerange: unref(handleChangeRange),
|
|
onPick: handleRangePick,
|
|
onSelect: unref(onSelect)
|
|
}, null, 8, [
|
|
"date",
|
|
"min-date",
|
|
"max-date",
|
|
"range-state",
|
|
"disabled-date",
|
|
"disabled",
|
|
"cell-class-name",
|
|
"onChangerange",
|
|
"onSelect"
|
|
])], 2)], 2)
|
|
], 2)], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/date-picker-com/panel-month-range.mjs
|
|
var panel_month_range_default = panel_month_range_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/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-panel/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");
|
|
};
|
|
return {
|
|
leftPrevYear,
|
|
rightNextYear,
|
|
leftNextYear,
|
|
rightPrevYear,
|
|
leftLabel: computed(() => {
|
|
const leftStartDate = Math.floor(leftDate.value.year() / 10) * 10;
|
|
return `${leftStartDate}-${leftStartDate + 9}`;
|
|
}),
|
|
rightLabel: computed(() => {
|
|
const rightStartDate = Math.floor(rightDate.value.year() / 10) * 10;
|
|
return `${rightStartDate}-${rightStartDate + 9}`;
|
|
}),
|
|
leftYear: computed(() => {
|
|
return Math.floor(leftDate.value.year() / 10) * 10 + 9;
|
|
}),
|
|
rightYear: computed(() => {
|
|
return Math.floor(rightDate.value.year() / 10) * 10;
|
|
})
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/date-picker-com/panel-year-range.vue_vue_type_script_setup_true_lang.mjs
|
|
var import_dayjs17 = __toESM(require_dayjs_min(), 1);
|
|
var _hoisted_136 = ["disabled", "onClick"];
|
|
var _hoisted_218 = ["disabled"];
|
|
var _hoisted_38 = ["disabled"];
|
|
var _hoisted_45 = ["disabled"];
|
|
var _hoisted_55 = ["disabled"];
|
|
var step = 10;
|
|
var unit3 = "year";
|
|
var panel_year_range_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "DatePickerYearRange",
|
|
__name: "panel-year-range",
|
|
props: panelYearRangeProps,
|
|
emits: panelYearRangeEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const { lang } = useLocale();
|
|
const leftDate = ref((0, import_dayjs17.default)().locale(lang.value));
|
|
const rightDate = ref((0, import_dayjs17.default)().locale(lang.value).add(step, unit3));
|
|
const isDefaultFormat = inject(ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY, void 0);
|
|
const pickerBase = inject(PICKER_BASE_INJECTION_KEY);
|
|
const { shortcuts, disabledDate, cellClassName } = pickerBase.props;
|
|
const format2 = toRef(pickerBase.props, "format");
|
|
const defaultValue = toRef(pickerBase.props, "defaultValue");
|
|
const { minDate, maxDate, rangeState, ppNs, drpNs, handleChangeRange, handleRangeConfirm, handleShortcutClick, onSelect, parseValue } = useRangePicker(props2, {
|
|
defaultValue,
|
|
leftDate,
|
|
rightDate,
|
|
step,
|
|
unit: unit3,
|
|
sortDates
|
|
});
|
|
const { leftPrevYear, rightNextYear, leftNextYear, rightPrevYear, leftLabel, rightLabel, leftYear, rightYear } = useYearRangeHeader({
|
|
unlinkPanels: toRef(props2, "unlinkPanels"),
|
|
leftDate,
|
|
rightDate
|
|
});
|
|
const yearRangeDisabled = useFormDisabled();
|
|
const hasShortcuts = computed(() => !!shortcuts.length);
|
|
const panelKls = computed(() => [
|
|
ppNs.b(),
|
|
drpNs.b(),
|
|
ppNs.is("border", props2.border),
|
|
ppNs.is("disabled", yearRangeDisabled.value),
|
|
{ "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 || yearRangeDisabled.value),
|
|
"d-arrow-right"
|
|
]
|
|
};
|
|
});
|
|
const rightPanelKls = computed(() => {
|
|
return {
|
|
content: [
|
|
ppNs.e("content"),
|
|
drpNs.e("content"),
|
|
"is-right"
|
|
],
|
|
arrowLeftBtn: [
|
|
ppNs.e("icon-btn"),
|
|
ppNs.is("disabled", !enableYearArrow.value || yearRangeDisabled.value),
|
|
"d-arrow-left"
|
|
],
|
|
arrowRightBtn: [ppNs.e("icon-btn"), "d-arrow-right"]
|
|
};
|
|
});
|
|
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 parseUserInput = (value) => {
|
|
return correctlyParseUserInput(value, format2.value, lang.value, isDefaultFormat);
|
|
};
|
|
const isValidValue3 = (date4) => {
|
|
return isValidRange2(date4) && (disabledDate ? !disabledDate(date4[0].toDate()) && !disabledDate(date4[1].toDate()) : true);
|
|
};
|
|
const handleClear = () => {
|
|
let valueOnClear = null;
|
|
if (pickerBase == null ? void 0 : pickerBase.emptyValues)
|
|
valueOnClear = pickerBase.emptyValues.valueOnClear.value;
|
|
const defaultArr = getDefaultValue(unref(defaultValue), {
|
|
lang: unref(lang),
|
|
step,
|
|
unit: unit3,
|
|
unlinkPanels: props2.unlinkPanels
|
|
});
|
|
leftDate.value = defaultArr[0];
|
|
rightDate.value = defaultArr[1];
|
|
emit("pick", valueOnClear);
|
|
};
|
|
function sortDates(minDate2, maxDate2) {
|
|
if (props2.unlinkPanels && maxDate2) {
|
|
const minDateYear = (minDate2 == null ? void 0 : minDate2.year()) || 0;
|
|
const maxDateYear = maxDate2.year();
|
|
rightDate.value = minDateYear + step > maxDateYear ? maxDate2.add(step, unit3) : maxDate2;
|
|
} else
|
|
rightDate.value = leftDate.value.add(step, unit3);
|
|
}
|
|
watch(() => props2.visible, (visible) => {
|
|
if (!visible && rangeState.value.selecting) {
|
|
parseValue(props2.parsedValue);
|
|
onSelect(false);
|
|
}
|
|
});
|
|
emit("set-picker-option", ["isValidValue", isValidValue3]);
|
|
emit("set-picker-option", ["parseUserInput", parseUserInput]);
|
|
emit("set-picker-option", ["handleClear", handleClear]);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", { class: normalizeClass(panelKls.value) }, [createBaseVNode("div", { class: normalizeClass(unref(ppNs).e("body-wrapper")) }, [
|
|
renderSlot(_ctx.$slots, "sidebar", { class: normalizeClass(unref(ppNs).e("sidebar")) }),
|
|
hasShortcuts.value ? (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")),
|
|
disabled: unref(yearRangeDisabled),
|
|
onClick: ($event) => unref(handleShortcutClick)(shortcut)
|
|
}, toDisplayString(shortcut.text), 11, _hoisted_136);
|
|
}), 128))], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", { class: normalizeClass(unref(ppNs).e("body")) }, [createBaseVNode("div", { class: normalizeClass(leftPanelKls.value.content) }, [createBaseVNode("div", { class: normalizeClass(unref(drpNs).e("header")) }, [
|
|
createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass(leftPanelKls.value.arrowLeftBtn),
|
|
disabled: unref(yearRangeDisabled),
|
|
onClick: _cache[0] || (_cache[0] = (...args) => unref(leftPrevYear) && unref(leftPrevYear)(...args))
|
|
}, [renderSlot(_ctx.$slots, "prev-year", {}, () => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(d_arrow_left_default))]),
|
|
_: 1
|
|
})])], 10, _hoisted_218),
|
|
_ctx.unlinkPanels ? (openBlock(), createElementBlock("button", {
|
|
key: 0,
|
|
type: "button",
|
|
disabled: !enableYearArrow.value || unref(yearRangeDisabled),
|
|
class: normalizeClass(leftPanelKls.value.arrowRightBtn),
|
|
onClick: _cache[1] || (_cache[1] = (...args) => unref(leftNextYear) && unref(leftNextYear)(...args))
|
|
}, [renderSlot(_ctx.$slots, "next-year", {}, () => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(d_arrow_right_default))]),
|
|
_: 1
|
|
})])], 10, _hoisted_38)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", null, toDisplayString(unref(leftLabel)), 1)
|
|
], 2), createVNode(basic_year_table_default, {
|
|
"selection-mode": "range",
|
|
date: leftDate.value,
|
|
"min-date": unref(minDate),
|
|
"max-date": unref(maxDate),
|
|
"range-state": unref(rangeState),
|
|
"disabled-date": unref(disabledDate),
|
|
disabled: unref(yearRangeDisabled),
|
|
"cell-class-name": unref(cellClassName),
|
|
onChangerange: unref(handleChangeRange),
|
|
onPick: handleRangePick,
|
|
onSelect: unref(onSelect)
|
|
}, null, 8, [
|
|
"date",
|
|
"min-date",
|
|
"max-date",
|
|
"range-state",
|
|
"disabled-date",
|
|
"disabled",
|
|
"cell-class-name",
|
|
"onChangerange",
|
|
"onSelect"
|
|
])], 2), createBaseVNode("div", { class: normalizeClass(rightPanelKls.value.content) }, [createBaseVNode("div", { class: normalizeClass(unref(drpNs).e("header")) }, [
|
|
_ctx.unlinkPanels ? (openBlock(), createElementBlock("button", {
|
|
key: 0,
|
|
type: "button",
|
|
disabled: !enableYearArrow.value || unref(yearRangeDisabled),
|
|
class: normalizeClass(rightPanelKls.value.arrowLeftBtn),
|
|
onClick: _cache[2] || (_cache[2] = (...args) => unref(rightPrevYear) && unref(rightPrevYear)(...args))
|
|
}, [renderSlot(_ctx.$slots, "prev-year", {}, () => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(d_arrow_left_default))]),
|
|
_: 1
|
|
})])], 10, _hoisted_45)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass(rightPanelKls.value.arrowRightBtn),
|
|
disabled: unref(yearRangeDisabled),
|
|
onClick: _cache[3] || (_cache[3] = (...args) => unref(rightNextYear) && unref(rightNextYear)(...args))
|
|
}, [renderSlot(_ctx.$slots, "next-year", {}, () => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(d_arrow_right_default))]),
|
|
_: 1
|
|
})])], 10, _hoisted_55),
|
|
createBaseVNode("div", null, toDisplayString(unref(rightLabel)), 1)
|
|
], 2), createVNode(basic_year_table_default, {
|
|
"selection-mode": "range",
|
|
date: rightDate.value,
|
|
"min-date": unref(minDate),
|
|
"max-date": unref(maxDate),
|
|
"range-state": unref(rangeState),
|
|
"disabled-date": unref(disabledDate),
|
|
disabled: unref(yearRangeDisabled),
|
|
"cell-class-name": unref(cellClassName),
|
|
onChangerange: unref(handleChangeRange),
|
|
onPick: handleRangePick,
|
|
onSelect: unref(onSelect)
|
|
}, null, 8, [
|
|
"date",
|
|
"min-date",
|
|
"max-date",
|
|
"range-state",
|
|
"disabled-date",
|
|
"disabled",
|
|
"cell-class-name",
|
|
"onChangerange",
|
|
"onSelect"
|
|
])], 2)], 2)
|
|
], 2)], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/date-picker-com/panel-year-range.mjs
|
|
var panel_year_range_default = panel_year_range_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/panel-utils.mjs
|
|
var getPanel = function(type4) {
|
|
switch (type4) {
|
|
case "daterange":
|
|
case "datetimerange":
|
|
return panel_date_range_default;
|
|
case "monthrange":
|
|
return panel_month_range_default;
|
|
case "yearrange":
|
|
return panel_year_range_default;
|
|
default:
|
|
return panel_date_pick_default;
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/src/date-picker-panel.mjs
|
|
var import_dayjs18 = __toESM(require_dayjs_min(), 1);
|
|
var import_customParseFormat2 = __toESM(require_customParseFormat(), 1);
|
|
var import_localeData2 = __toESM(require_localeData(), 1);
|
|
var import_advancedFormat = __toESM(require_advancedFormat(), 1);
|
|
var import_weekOfYear = __toESM(require_weekOfYear(), 1);
|
|
var import_weekYear = __toESM(require_weekYear(), 1);
|
|
var import_dayOfYear = __toESM(require_dayOfYear(), 1);
|
|
var import_isSameOrAfter = __toESM(require_isSameOrAfter(), 1);
|
|
var import_isSameOrBefore = __toESM(require_isSameOrBefore(), 1);
|
|
function _isSlot(s2) {
|
|
return typeof s2 === "function" || Object.prototype.toString.call(s2) === "[object Object]" && !isVNode(s2);
|
|
}
|
|
import_dayjs18.default.extend(import_localeData2.default);
|
|
import_dayjs18.default.extend(import_advancedFormat.default);
|
|
import_dayjs18.default.extend(import_customParseFormat2.default);
|
|
import_dayjs18.default.extend(import_weekOfYear.default);
|
|
import_dayjs18.default.extend(import_weekYear.default);
|
|
import_dayjs18.default.extend(import_dayOfYear.default);
|
|
import_dayjs18.default.extend(import_isSameOrAfter.default);
|
|
import_dayjs18.default.extend(import_isSameOrBefore.default);
|
|
var date_picker_panel_default = defineComponent({
|
|
name: "ElDatePickerPanel",
|
|
install: null,
|
|
inheritAttrs: false,
|
|
props: datePickerPanelProps,
|
|
emits: [
|
|
UPDATE_MODEL_EVENT,
|
|
"calendar-change",
|
|
"panel-change",
|
|
"visible-change",
|
|
"clear"
|
|
],
|
|
setup(props2, { slots, emit, attrs }) {
|
|
const ns = useNamespace("picker-panel");
|
|
if (isUndefined2(inject(PICKER_BASE_INJECTION_KEY, void 0)))
|
|
provide(PICKER_BASE_INJECTION_KEY, { props: reactive({ ...toRefs(props2) }) });
|
|
provide(ROOT_PICKER_INJECTION_KEY, {
|
|
slots,
|
|
pickerNs: ns
|
|
});
|
|
const { parsedValue, onCalendarChange, onPanelChange, onSetPickerOption, onPick } = inject(ROOT_COMMON_PICKER_INJECTION_KEY, () => useCommonPicker(props2, emit), true);
|
|
return () => {
|
|
return createVNode(getPanel(props2.type), mergeProps(omit_default(attrs, "onPick"), props2, {
|
|
"parsedValue": parsedValue.value,
|
|
"onSet-picker-option": onSetPickerOption,
|
|
"onCalendar-change": onCalendarChange,
|
|
"onPanel-change": onPanelChange,
|
|
"onClear": () => emit("clear"),
|
|
"onPick": onPick
|
|
}), _isSlot(slots) ? slots : { default: () => [slots] });
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker-panel/index.mjs
|
|
var ElDatePickerPanel = withInstall(date_picker_panel_default);
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/props.mjs
|
|
var datePickerProps = buildProps({
|
|
...timePickerDefaultProps,
|
|
type: {
|
|
type: definePropType(String),
|
|
default: "date"
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker/src/date-picker.mjs
|
|
function _isSlot2(s2) {
|
|
return typeof s2 === "function" || Object.prototype.toString.call(s2) === "[object Object]" && !isVNode(s2);
|
|
}
|
|
var date_picker_default = defineComponent({
|
|
name: "ElDatePicker",
|
|
install: null,
|
|
props: datePickerProps,
|
|
emits: [UPDATE_MODEL_EVENT],
|
|
setup(props2, { expose, emit, slots }) {
|
|
provide(ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY, computed(() => {
|
|
return !props2.format;
|
|
}));
|
|
provide(PICKER_POPPER_OPTIONS_INJECTION_KEY, reactive(toRef(props2, "popperOptions")));
|
|
const commonPicker = ref();
|
|
expose({
|
|
focus: () => {
|
|
var _a;
|
|
(_a = commonPicker.value) == null ? void 0 : _a.focus();
|
|
},
|
|
blur: () => {
|
|
var _a;
|
|
(_a = commonPicker.value) == null ? void 0 : _a.blur();
|
|
},
|
|
handleOpen: () => {
|
|
var _a;
|
|
(_a = commonPicker.value) == null ? void 0 : _a.handleOpen();
|
|
},
|
|
handleClose: () => {
|
|
var _a;
|
|
(_a = commonPicker.value) == null ? void 0 : _a.handleClose();
|
|
}
|
|
});
|
|
const onModelValueUpdated = (val) => {
|
|
emit(UPDATE_MODEL_EVENT, val);
|
|
};
|
|
return () => {
|
|
var _a;
|
|
const format2 = (_a = props2.format) != null ? _a : DEFAULT_FORMATS_DATEPICKER[props2.type] || DEFAULT_FORMATS_DATE;
|
|
return createVNode(picker_default, mergeProps(props2, {
|
|
"format": format2,
|
|
"type": props2.type,
|
|
"ref": commonPicker,
|
|
"onUpdate:modelValue": onModelValueUpdated
|
|
}), {
|
|
default: (scopedProps) => createVNode(ElDatePickerPanel, mergeProps({
|
|
"disabled": props2.disabled,
|
|
"editable": props2.editable,
|
|
"border": false
|
|
}, scopedProps), _isSlot2(slots) ? slots : { default: () => [slots] }),
|
|
"range-separator": slots["range-separator"]
|
|
});
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/date-picker/index.mjs
|
|
var ElDatePicker = withInstall(date_picker_default);
|
|
|
|
// 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] }
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/descriptions/src/constants.mjs
|
|
var COMPONENT_NAME13 = "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] },
|
|
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_NAME13,
|
|
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-row.mjs
|
|
var descriptionsRowProps = buildProps({ row: {
|
|
type: definePropType(Array),
|
|
default: () => []
|
|
} });
|
|
|
|
// node_modules/element-plus/es/components/descriptions/src/descriptions-cell.mjs
|
|
var descriptions_cell_default = defineComponent({
|
|
name: "ElDescriptionsCell",
|
|
props: {
|
|
cell: { type: Object },
|
|
tag: {
|
|
type: String,
|
|
default: "td"
|
|
},
|
|
type: { type: String }
|
|
},
|
|
setup() {
|
|
return { descriptions: inject(descriptionsKey, {}) };
|
|
},
|
|
render() {
|
|
var _a, _b, _c, _d;
|
|
const item = getNormalizedProps(this.cell);
|
|
const directives = (((_a = this.cell) == null ? void 0 : _a.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 _a2, _b2, _c2;
|
|
return ((_c2 = (_b2 = (_a2 = this.cell) == null ? void 0 : _a2.children) == null ? void 0 : _b2.label) == null ? void 0 : _c2.call(_b2)) || item.label;
|
|
};
|
|
const renderContent = () => {
|
|
var _a2, _b2, _c2;
|
|
return (_c2 = (_b2 = (_a2 = this.cell) == null ? void 0 : _a2.children) == null ? void 0 : _b2.default) == null ? void 0 : _c2.call(_b2);
|
|
};
|
|
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 style = {
|
|
width: addUnit(this.type === "label" ? (_c = (_b = item.labelWidth) != null ? _b : this.descriptions.labelWidth) != null ? _c : item.width : item.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 width = addUnit((_d = item.labelWidth) != null ? _d : this.descriptions.labelWidth);
|
|
if (width) {
|
|
labelStyle.width = width;
|
|
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-row.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_137 = { key: 1 };
|
|
var descriptions_row_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElDescriptionsRow",
|
|
__name: "descriptions-row",
|
|
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(__props.row, (cell, _index) => {
|
|
return openBlock(), createBlock(unref(descriptions_cell_default), {
|
|
key: `tr1-${_index}`,
|
|
cell,
|
|
tag: "th",
|
|
type: "label"
|
|
}, null, 8, ["cell"]);
|
|
}), 128))]), createBaseVNode("tr", null, [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.row, (cell, _index) => {
|
|
return openBlock(), createBlock(unref(descriptions_cell_default), {
|
|
key: `tr2-${_index}`,
|
|
cell,
|
|
tag: "td",
|
|
type: "content"
|
|
}, null, 8, ["cell"]);
|
|
}), 128))])], 64)) : (openBlock(), createElementBlock("tr", _hoisted_137, [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.row, (cell, _index) => {
|
|
return openBlock(), createElementBlock(Fragment, { key: `tr3-${_index}` }, [unref(descriptions).border ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [createVNode(unref(descriptions_cell_default), {
|
|
cell,
|
|
tag: "td",
|
|
type: "label"
|
|
}, null, 8, ["cell"]), createVNode(unref(descriptions_cell_default), {
|
|
cell,
|
|
tag: "td",
|
|
type: "content"
|
|
}, null, 8, ["cell"])], 64)) : (openBlock(), createBlock(unref(descriptions_cell_default), {
|
|
key: 1,
|
|
cell,
|
|
tag: "td",
|
|
type: "both"
|
|
}, null, 8, ["cell"]))], 64);
|
|
}), 128))]));
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/descriptions/src/descriptions-row2.mjs
|
|
var descriptions_row_default = descriptions_row_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/descriptions/src/description.vue_vue_type_script_setup_true_lang.mjs
|
|
var description_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElDescriptions",
|
|
__name: "description",
|
|
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 _a;
|
|
return ((_a = node == null ? void 0 : node.type) == null ? void 0 : _a.name) === COMPONENT_NAME13;
|
|
});
|
|
const rows = [];
|
|
let temp = [];
|
|
let count = props2.column;
|
|
let totalSpan = 0;
|
|
const rowspanTemp = [];
|
|
children.forEach((node, index) => {
|
|
var _a, _b, _c;
|
|
const span = ((_a = node.props) == null ? void 0 : _a.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(descriptionKls.value) }, [__props.title || __props.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(__props.title), 1)])], 2), createBaseVNode("div", { class: normalizeClass(unref(ns).e("extra")) }, [renderSlot(_ctx.$slots, "extra", {}, () => [createTextVNode(toDisplayString(__props.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", __props.border)]) }, [createBaseVNode("tbody", null, [(openBlock(true), createElementBlock(Fragment, null, renderList(getRows(), (row, _index) => {
|
|
return openBlock(), createBlock(descriptions_row_default, {
|
|
key: _index,
|
|
row
|
|
}, null, 8, ["row"]);
|
|
}), 128))])], 2)], 2)], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/descriptions/src/description2.mjs
|
|
var description_default = description_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/descriptions/index.mjs
|
|
var ElDescriptions = withInstall(description_default, { DescriptionsItem: DescriptionItem });
|
|
var ElDescriptionsItem = withNoopInstall(DescriptionItem);
|
|
|
|
// node_modules/element-plus/es/components/dialog/src/dialog-content.mjs
|
|
var dialogContentProps = buildProps({
|
|
center: Boolean,
|
|
alignCenter: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
closeIcon: { type: iconPropType },
|
|
draggable: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
overflow: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
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 };
|
|
var dialogContentPropsDefaults = {
|
|
alignCenter: void 0,
|
|
draggable: void 0,
|
|
overflow: void 0,
|
|
showClose: true,
|
|
title: "",
|
|
ariaLevel: "2"
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/dialog/src/dialog.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
|
|
},
|
|
modalPenetrable: Boolean,
|
|
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"
|
|
},
|
|
transition: {
|
|
type: definePropType([String, Object]),
|
|
default: void 0
|
|
}
|
|
});
|
|
var dialogEmits = {
|
|
open: () => true,
|
|
opened: () => true,
|
|
close: () => true,
|
|
closed: () => true,
|
|
[UPDATE_MODEL_EVENT]: (value) => isBoolean2(value),
|
|
openAutoFocus: () => true,
|
|
closeAutoFocus: () => true
|
|
};
|
|
var dialogContextKey = Symbol("dialogContextKey");
|
|
var dialogPropsDefaults = {
|
|
...dialogContentPropsDefaults,
|
|
appendTo: "body",
|
|
closeOnClickModal: true,
|
|
closeOnPressEscape: true,
|
|
lockScroll: true,
|
|
modal: true,
|
|
openDelay: 0,
|
|
closeDelay: 0,
|
|
headerAriaLevel: "2",
|
|
transition: void 0
|
|
};
|
|
|
|
// 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_default = 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_default;
|
|
|
|
// node_modules/element-plus/es/components/dialog/src/constants.mjs
|
|
var dialogInjectionKey = Symbol("dialogInjectionKey");
|
|
var DEFAULT_DIALOG_TRANSITION = "dialog-fade";
|
|
|
|
// node_modules/element-plus/es/components/dialog/src/use-dialog.mjs
|
|
var COMPONENT_NAME14 = "ElDialog";
|
|
var useDialog = (props2, targetRef) => {
|
|
var _a;
|
|
const emit = getCurrentInstance().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((_a = props2.zIndex) != null ? _a : nextZIndex());
|
|
const closing = ref(false);
|
|
let openTimer = void 0;
|
|
let closeTimer = void 0;
|
|
const config = useGlobalConfig();
|
|
const namespace = computed(() => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = config.value) == null ? void 0 : _a2.namespace) != null ? _b : defaultNamespace;
|
|
});
|
|
const globalConfig2 = computed(() => {
|
|
var _a2;
|
|
return (_a2 = config.value) == null ? void 0 : _a2.dialog;
|
|
});
|
|
const style = computed(() => {
|
|
const style2 = {};
|
|
const varPrefix = `--${namespace.value}-dialog`;
|
|
if (!props2.fullscreen) {
|
|
if (props2.top)
|
|
style2[`${varPrefix}-margin-top`] = props2.top;
|
|
const width = addUnit(props2.width);
|
|
if (width)
|
|
style2[`${varPrefix}-width`] = width;
|
|
}
|
|
return style2;
|
|
});
|
|
const _draggable = computed(() => {
|
|
var _a2, _b, _c;
|
|
return ((_c = (_b = props2.draggable) != null ? _b : (_a2 = globalConfig2.value) == null ? void 0 : _a2.draggable) != null ? _c : false) && !props2.fullscreen;
|
|
});
|
|
const _alignCenter = computed(() => {
|
|
var _a2, _b, _c;
|
|
return (_c = (_b = props2.alignCenter) != null ? _b : (_a2 = globalConfig2.value) == null ? void 0 : _a2.alignCenter) != null ? _c : false;
|
|
});
|
|
const _overflow = computed(() => {
|
|
var _a2, _b, _c;
|
|
return (_c = (_b = props2.overflow) != null ? _b : (_a2 = globalConfig2.value) == null ? void 0 : _a2.overflow) != null ? _c : false;
|
|
});
|
|
const penetrable = computed(() => props2.modalPenetrable && !props2.modal && !props2.fullscreen);
|
|
const overlayDialogStyle = computed(() => {
|
|
if (_alignCenter.value)
|
|
return { display: "flex" };
|
|
return {};
|
|
});
|
|
const transitionConfig = computed(() => {
|
|
var _a2, _b, _c;
|
|
const transition = (_c = (_b = props2.transition) != null ? _b : (_a2 = globalConfig2.value) == null ? void 0 : _a2.transition) != null ? _c : DEFAULT_DIALOG_TRANSITION;
|
|
const baseConfig = {
|
|
name: transition,
|
|
onAfterEnter: afterEnter,
|
|
onBeforeLeave: beforeLeave,
|
|
onAfterLeave: afterLeave
|
|
};
|
|
if (isObject(transition)) {
|
|
const config2 = { ...transition };
|
|
const _mergeHook = (userHook, defaultHook) => {
|
|
return (el) => {
|
|
if (isArray(userHook))
|
|
userHook.forEach((fn2) => {
|
|
if (isFunction(fn2))
|
|
fn2(el);
|
|
});
|
|
else if (isFunction(userHook))
|
|
userHook(el);
|
|
defaultHook();
|
|
};
|
|
};
|
|
config2.onAfterEnter = _mergeHook(config2.onAfterEnter, afterEnter);
|
|
config2.onBeforeLeave = _mergeHook(config2.onBeforeLeave, beforeLeave);
|
|
config2.onAfterLeave = _mergeHook(config2.onAfterLeave, afterLeave);
|
|
if (!config2.name) {
|
|
config2.name = DEFAULT_DIALOG_TRANSITION;
|
|
debugWarn(COMPONENT_NAME14, `transition.name is missing when using object syntax, fallback to '${DEFAULT_DIALOG_TRANSITION}'`);
|
|
}
|
|
return config2;
|
|
}
|
|
return baseConfig;
|
|
});
|
|
function afterEnter() {
|
|
emit("opened");
|
|
}
|
|
function afterLeave() {
|
|
emit("closed");
|
|
emit(UPDATE_MODEL_EVENT, false);
|
|
if (props2.destroyOnClose)
|
|
rendered.value = false;
|
|
closing.value = false;
|
|
}
|
|
function beforeLeave() {
|
|
closing.value = true;
|
|
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 _a2;
|
|
if (((_a2 = event.detail) == null ? void 0 : _a2.focusReason) === "pointer")
|
|
event.preventDefault();
|
|
}
|
|
if (props2.lockScroll)
|
|
useLockscreen(visible);
|
|
function onCloseRequested() {
|
|
if (props2.closeOnPressEscape)
|
|
handleClose();
|
|
}
|
|
function bringToFront() {
|
|
if (!visible.value || !penetrable.value || props2.zIndex !== void 0)
|
|
return;
|
|
zIndex2.value = nextZIndex();
|
|
}
|
|
watch(() => props2.zIndex, () => {
|
|
var _a2;
|
|
zIndex2.value = (_a2 = props2.zIndex) != null ? _a2 : nextZIndex();
|
|
});
|
|
watch(() => props2.modelValue, (val) => {
|
|
var _a2;
|
|
if (val) {
|
|
closed.value = false;
|
|
closing.value = false;
|
|
open();
|
|
rendered.value = true;
|
|
zIndex2.value = (_a2 = props2.zIndex) != null ? _a2 : nextZIndex();
|
|
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,
|
|
bringToFront,
|
|
titleId,
|
|
bodyId,
|
|
closed,
|
|
style,
|
|
overlayDialogStyle,
|
|
rendered,
|
|
visible,
|
|
zIndex: zIndex2,
|
|
transitionConfig,
|
|
_draggable,
|
|
_alignCenter,
|
|
_overflow,
|
|
closing,
|
|
penetrable
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/utils/vue/refs.mjs
|
|
var composeRefs = (...refs) => {
|
|
return (el) => {
|
|
refs.forEach((ref2) => {
|
|
ref2.value = el;
|
|
});
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/dialog/src/dialog-content.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_138 = ["aria-level"];
|
|
var _hoisted_219 = ["aria-label"];
|
|
var _hoisted_39 = ["id"];
|
|
var dialog_content_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElDialogContent",
|
|
__name: "dialog-content",
|
|
props: dialogContentProps,
|
|
emits: dialogContentEmits,
|
|
setup(__props, { expose: __expose }) {
|
|
const { t } = useLocale();
|
|
const { Close } = CloseComponents;
|
|
const props2 = __props;
|
|
const { dialogRef, headerRef, bodyId, ns, style } = inject(dialogInjectionKey);
|
|
const { focusTrapRef } = inject(FOCUS_TRAP_INJECTION_KEY);
|
|
const composedDialogRef = composeRefs(focusTrapRef, dialogRef);
|
|
const draggable2 = computed(() => !!props2.draggable);
|
|
const { resetPosition, updatePosition, isDragging: isDragging2 } = useDraggable(dialogRef, headerRef, draggable2, computed(() => !!props2.overflow));
|
|
const dialogKls = computed(() => [
|
|
ns.b(),
|
|
ns.is("fullscreen", props2.fullscreen),
|
|
ns.is("draggable", draggable2.value),
|
|
ns.is("dragging", isDragging2.value),
|
|
ns.is("align-center", !!props2.alignCenter),
|
|
{ [ns.m("center")]: props2.center }
|
|
]);
|
|
__expose({
|
|
resetPosition,
|
|
updatePosition
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref: unref(composedDialogRef),
|
|
class: normalizeClass(dialogKls.value),
|
|
style: normalizeStyle(unref(style)),
|
|
tabindex: "-1"
|
|
}, [
|
|
createBaseVNode("header", {
|
|
ref_key: "headerRef",
|
|
ref: headerRef,
|
|
class: normalizeClass([
|
|
unref(ns).e("header"),
|
|
__props.headerClass,
|
|
{ "show-close": __props.showClose }
|
|
])
|
|
}, [renderSlot(_ctx.$slots, "header", {}, () => [createBaseVNode("span", {
|
|
role: "heading",
|
|
"aria-level": __props.ariaLevel,
|
|
class: normalizeClass(unref(ns).e("title"))
|
|
}, toDisplayString(__props.title), 11, _hoisted_138)]), __props.showClose ? (openBlock(), createElementBlock("button", {
|
|
key: 0,
|
|
"aria-label": unref(t)("el.dialog.close"),
|
|
class: normalizeClass(unref(ns).e("headerbtn")),
|
|
type: "button",
|
|
onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("close"))
|
|
}, [createVNode(unref(ElIcon), { class: normalizeClass(unref(ns).e("close")) }, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.closeIcon || unref(Close))))]),
|
|
_: 1
|
|
}, 8, ["class"])], 10, _hoisted_219)) : createCommentVNode("v-if", true)], 2),
|
|
createBaseVNode("div", {
|
|
id: unref(bodyId),
|
|
class: normalizeClass([unref(ns).e("body"), __props.bodyClass])
|
|
}, [renderSlot(_ctx.$slots, "default")], 10, _hoisted_39),
|
|
_ctx.$slots.footer ? (openBlock(), createElementBlock("footer", {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("footer"), __props.footerClass])
|
|
}, [renderSlot(_ctx.$slots, "footer")], 2)) : createCommentVNode("v-if", true)
|
|
], 6);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/dialog/src/dialog-content2.mjs
|
|
var dialog_content_default = dialog_content_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/dialog/src/dialog.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_139 = [
|
|
"aria-label",
|
|
"aria-labelledby",
|
|
"aria-describedby"
|
|
];
|
|
var dialog_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElDialog",
|
|
inheritAttrs: false,
|
|
__name: "dialog",
|
|
props: dialogProps,
|
|
emits: dialogEmits,
|
|
setup(__props, { expose: __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, transitionConfig, zIndex: zIndex2, _draggable, _alignCenter, _overflow, penetrable, handleClose, onModalClick, onOpenAutoFocus, onCloseAutoFocus, onCloseRequested, onFocusoutPrevented, bringToFront, closing } = useDialog(props2, dialogRef);
|
|
provide(dialogInjectionKey, {
|
|
dialogRef,
|
|
headerRef,
|
|
bodyId,
|
|
ns,
|
|
rendered,
|
|
style
|
|
});
|
|
const overlayEvent = useSameTarget(onModalClick);
|
|
const resetPosition = () => {
|
|
var _a;
|
|
(_a = dialogContentRef.value) == null ? void 0 : _a.resetPosition();
|
|
};
|
|
__expose({
|
|
visible,
|
|
dialogContentRef,
|
|
resetPosition,
|
|
handleClose
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElTeleport), {
|
|
to: __props.appendTo,
|
|
disabled: __props.appendTo !== "body" ? false : !__props.appendToBody
|
|
}, {
|
|
default: withCtx(() => [createVNode(Transition, mergeProps(unref(transitionConfig), { persisted: "" }), {
|
|
default: withCtx(() => {
|
|
var _a;
|
|
return [withDirectives(createVNode(unref(ElOverlay), {
|
|
"custom-mask-event": "",
|
|
mask: __props.modal,
|
|
"overlay-class": [
|
|
(_a = __props.modalClass) != null ? _a : "",
|
|
`${unref(ns).namespace.value}-modal-dialog`,
|
|
unref(ns).is("penetrable", unref(penetrable))
|
|
],
|
|
"z-index": unref(zIndex2)
|
|
}, {
|
|
default: withCtx(() => [createBaseVNode("div", {
|
|
role: "dialog",
|
|
"aria-modal": "true",
|
|
"aria-label": __props.title || void 0,
|
|
"aria-labelledby": !__props.title ? unref(titleId) : void 0,
|
|
"aria-describedby": unref(bodyId),
|
|
class: normalizeClass([`${unref(ns).namespace.value}-overlay-dialog`, unref(ns).is("closing", unref(closing))]),
|
|
style: normalizeStyle(unref(overlayDialogStyle)),
|
|
onClick: _cache[0] || (_cache[0] = (...args) => unref(overlayEvent).onClick && unref(overlayEvent).onClick(...args)),
|
|
onMousedown: _cache[1] || (_cache[1] = (...args) => unref(overlayEvent).onMousedown && unref(overlayEvent).onMousedown(...args)),
|
|
onMouseup: _cache[2] || (_cache[2] = (...args) => unref(overlayEvent).onMouseup && unref(overlayEvent).onMouseup(...args))
|
|
}, [createVNode(unref(focus_trap_default$1), {
|
|
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(dialog_content_default, mergeProps({
|
|
key: 0,
|
|
ref_key: "dialogContentRef",
|
|
ref: dialogContentRef
|
|
}, _ctx.$attrs, {
|
|
center: __props.center,
|
|
"align-center": unref(_alignCenter),
|
|
"close-icon": __props.closeIcon,
|
|
draggable: unref(_draggable),
|
|
overflow: unref(_overflow),
|
|
fullscreen: __props.fullscreen,
|
|
"header-class": __props.headerClass,
|
|
"body-class": __props.bodyClass,
|
|
"footer-class": __props.footerClass,
|
|
"show-close": __props.showClose,
|
|
title: __props.title,
|
|
"aria-level": __props.headerAriaLevel,
|
|
onClose: unref(handleClose),
|
|
onMousedown: unref(bringToFront)
|
|
}), 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")]),
|
|
key: "0"
|
|
} : void 0]), 1040, [
|
|
"center",
|
|
"align-center",
|
|
"close-icon",
|
|
"draggable",
|
|
"overflow",
|
|
"fullscreen",
|
|
"header-class",
|
|
"body-class",
|
|
"footer-class",
|
|
"show-close",
|
|
"title",
|
|
"aria-level",
|
|
"onClose",
|
|
"onMousedown"
|
|
])) : createCommentVNode("v-if", true)]),
|
|
_: 3
|
|
}, 8, [
|
|
"trapped",
|
|
"onFocusAfterTrapped",
|
|
"onFocusAfterReleased",
|
|
"onFocusoutPrevented",
|
|
"onReleaseRequested"
|
|
])], 46, _hoisted_139)]),
|
|
_: 3
|
|
}, 8, [
|
|
"mask",
|
|
"overlay-class",
|
|
"z-index"
|
|
]), [[vShow, unref(visible)]])];
|
|
}),
|
|
_: 3
|
|
}, 16)]),
|
|
_: 3
|
|
}, 8, ["to", "disabled"]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/dialog/src/dialog2.mjs
|
|
var dialog_default = dialog_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/dialog/index.mjs
|
|
var ElDialog = withInstall(dialog_default);
|
|
|
|
// 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/divider.vue_vue_type_script_setup_true_lang.mjs
|
|
var divider_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElDivider",
|
|
__name: "divider",
|
|
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(__props.direction)]),
|
|
style: normalizeStyle(dividerStyle.value),
|
|
role: "separator"
|
|
}, [_ctx.$slots.default && __props.direction !== "vertical" ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("text"), unref(ns).is(__props.contentPosition)])
|
|
}, [renderSlot(_ctx.$slots, "default")], 2)) : createCommentVNode("v-if", true)], 6);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/divider/src/divider2.mjs
|
|
var divider_default = divider_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/divider/index.mjs
|
|
var ElDivider = withInstall(divider_default);
|
|
|
|
// node_modules/element-plus/es/components/drawer/src/drawer.mjs
|
|
var drawerProps = buildProps({
|
|
...dialogProps,
|
|
direction: {
|
|
type: String,
|
|
default: "rtl",
|
|
values: [
|
|
"ltr",
|
|
"rtl",
|
|
"ttb",
|
|
"btt"
|
|
]
|
|
},
|
|
resizable: Boolean,
|
|
size: {
|
|
type: [String, Number],
|
|
default: "30%"
|
|
},
|
|
withHeader: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
modalFade: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
headerAriaLevel: {
|
|
type: String,
|
|
default: "2"
|
|
}
|
|
});
|
|
var drawerEmits = {
|
|
...dialogEmits,
|
|
"resize-start": (evt, size3) => evt instanceof MouseEvent && typeof size3 === "number",
|
|
resize: (evt, size3) => evt instanceof MouseEvent && typeof size3 === "number",
|
|
"resize-end": (evt, size3) => evt instanceof MouseEvent && typeof size3 === "number"
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/drawer/src/composables/useResizable.mjs
|
|
function useResizable(props2, target2, emit) {
|
|
const { width, height } = useWindowSize();
|
|
const isHorizontal2 = computed(() => ["ltr", "rtl"].includes(props2.direction));
|
|
const sign = computed(() => ["ltr", "ttb"].includes(props2.direction) ? 1 : -1);
|
|
const windowSize = computed(() => isHorizontal2.value ? width.value : height.value);
|
|
const getSize = computed(() => {
|
|
return clamp(startSize.value + sign.value * offset3.value, 4, windowSize.value);
|
|
});
|
|
const startSize = ref(0);
|
|
const offset3 = ref(0);
|
|
const isResizing = ref(false);
|
|
const hasStartedDragging = ref(false);
|
|
let startPos = [];
|
|
let cleanups = [];
|
|
const getActualSize = () => {
|
|
var _a;
|
|
const drawerEl = (_a = target2.value) == null ? void 0 : _a.closest('[aria-modal="true"]');
|
|
if (drawerEl)
|
|
return isHorizontal2.value ? drawerEl.offsetWidth : drawerEl.offsetHeight;
|
|
return 100;
|
|
};
|
|
watch(() => [props2.size, props2.resizable], () => {
|
|
hasStartedDragging.value = false;
|
|
startSize.value = 0;
|
|
offset3.value = 0;
|
|
onMouseUp();
|
|
});
|
|
const onMousedown = (e) => {
|
|
if (!props2.resizable)
|
|
return;
|
|
if (!hasStartedDragging.value) {
|
|
startSize.value = getActualSize();
|
|
hasStartedDragging.value = true;
|
|
}
|
|
startPos = [e.pageX, e.pageY];
|
|
isResizing.value = true;
|
|
emit("resize-start", e, startSize.value);
|
|
cleanups.push(useEventListener(window, "mouseup", onMouseUp), useEventListener(window, "mousemove", onMouseMove));
|
|
};
|
|
const onMouseMove = (e) => {
|
|
const { pageX, pageY } = e;
|
|
const offsetX = pageX - startPos[0];
|
|
const offsetY = pageY - startPos[1];
|
|
offset3.value = isHorizontal2.value ? offsetX : offsetY;
|
|
emit("resize", e, getSize.value);
|
|
};
|
|
const onMouseUp = (e) => {
|
|
if (!isResizing.value)
|
|
return;
|
|
startPos = [];
|
|
startSize.value = getSize.value;
|
|
offset3.value = 0;
|
|
isResizing.value = false;
|
|
cleanups.forEach((cleanup2) => cleanup2 == null ? void 0 : cleanup2());
|
|
cleanups = [];
|
|
if (e)
|
|
emit("resize-end", e, startSize.value);
|
|
};
|
|
const cleanup = useEventListener(target2, "mousedown", onMousedown);
|
|
onBeforeUnmount(() => {
|
|
cleanup();
|
|
onMouseUp();
|
|
});
|
|
return {
|
|
size: computed(() => {
|
|
return hasStartedDragging.value ? `${getSize.value}px` : addUnit(props2.size);
|
|
}),
|
|
isResizing,
|
|
isHorizontal: isHorizontal2
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/drawer/src/drawer.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_140 = [
|
|
"aria-label",
|
|
"aria-labelledby",
|
|
"aria-describedby"
|
|
];
|
|
var _hoisted_220 = ["id", "aria-level"];
|
|
var _hoisted_310 = ["aria-label"];
|
|
var _hoisted_46 = ["id"];
|
|
var drawer_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElDrawer",
|
|
inheritAttrs: false,
|
|
__name: "drawer",
|
|
props: drawerProps,
|
|
emits: drawerEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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 draggerRef = 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 { isHorizontal: isHorizontal2, size: size3, isResizing } = useResizable(props2, draggerRef, emit);
|
|
const penetrable = computed(() => props2.modalPenetrable && !props2.modal);
|
|
__expose({
|
|
handleClose,
|
|
afterEnter,
|
|
afterLeave
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElTeleport), {
|
|
to: __props.appendTo,
|
|
disabled: __props.appendTo !== "body" ? false : !__props.appendToBody
|
|
}, {
|
|
default: withCtx(() => [createVNode(Transition, {
|
|
name: unref(ns).b("fade"),
|
|
onAfterEnter: unref(afterEnter),
|
|
onAfterLeave: unref(afterLeave),
|
|
onBeforeLeave: unref(beforeLeave),
|
|
persisted: ""
|
|
}, {
|
|
default: withCtx(() => {
|
|
var _a;
|
|
return [withDirectives(createVNode(unref(ElOverlay), {
|
|
mask: __props.modal,
|
|
"overlay-class": [
|
|
unref(ns).is("drawer"),
|
|
(_a = __props.modalClass) != null ? _a : "",
|
|
`${unref(ns).namespace.value}-modal-drawer`,
|
|
unref(ns).is("penetrable", penetrable.value)
|
|
],
|
|
"z-index": unref(zIndex2),
|
|
onClick: unref(onModalClick)
|
|
}, {
|
|
default: withCtx(() => [createVNode(unref(focus_trap_default$1), {
|
|
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": __props.title || void 0,
|
|
"aria-labelledby": !__props.title ? unref(titleId) : void 0,
|
|
"aria-describedby": unref(bodyId)
|
|
}, _ctx.$attrs, {
|
|
class: [
|
|
unref(ns).b(),
|
|
__props.direction,
|
|
unref(visible) && "open",
|
|
unref(ns).is("dragging", unref(isResizing))
|
|
],
|
|
style: { [unref(isHorizontal2) ? "width" : "height"]: unref(size3) },
|
|
role: "dialog",
|
|
onClick: _cache[1] || (_cache[1] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}), [
|
|
createBaseVNode("span", {
|
|
ref_key: "focusStartRef",
|
|
ref: focusStartRef,
|
|
class: normalizeClass(unref(ns).e("sr-focus")),
|
|
tabindex: "-1"
|
|
}, null, 2),
|
|
__props.withHeader ? (openBlock(), createElementBlock("header", {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("header"), __props.headerClass])
|
|
}, [!_ctx.$slots.title ? renderSlot(_ctx.$slots, "header", {
|
|
key: 0,
|
|
close: unref(handleClose),
|
|
titleId: unref(titleId),
|
|
titleClass: unref(ns).e("title")
|
|
}, () => [createBaseVNode("span", {
|
|
id: unref(titleId),
|
|
role: "heading",
|
|
"aria-level": __props.headerAriaLevel,
|
|
class: normalizeClass(unref(ns).e("title"))
|
|
}, toDisplayString(__props.title), 11, _hoisted_220)]) : renderSlot(_ctx.$slots, "title", { key: 1 }, () => [createCommentVNode(" DEPRECATED SLOT ")]), __props.showClose ? (openBlock(), createElementBlock("button", {
|
|
key: 2,
|
|
"aria-label": unref(t)("el.drawer.close"),
|
|
class: normalizeClass(unref(ns).e("close-btn")),
|
|
type: "button",
|
|
onClick: _cache[0] || (_cache[0] = (...args) => unref(handleClose) && unref(handleClose)(...args))
|
|
}, [createVNode(unref(ElIcon), { class: normalizeClass(unref(ns).e("close")) }, {
|
|
default: withCtx(() => [createVNode(unref(close_default))]),
|
|
_: 1
|
|
}, 8, ["class"])], 10, _hoisted_310)) : 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"), __props.bodyClass])
|
|
}, [renderSlot(_ctx.$slots, "default")], 10, _hoisted_46)) : createCommentVNode("v-if", true),
|
|
_ctx.$slots.footer ? (openBlock(), createElementBlock("div", {
|
|
key: 2,
|
|
class: normalizeClass([unref(ns).e("footer"), __props.footerClass])
|
|
}, [renderSlot(_ctx.$slots, "footer")], 2)) : createCommentVNode("v-if", true),
|
|
__props.resizable ? (openBlock(), createElementBlock("div", {
|
|
key: 3,
|
|
ref_key: "draggerRef",
|
|
ref: draggerRef,
|
|
style: normalizeStyle({ zIndex: unref(zIndex2) }),
|
|
class: normalizeClass(unref(ns).e("dragger"))
|
|
}, null, 6)) : createCommentVNode("v-if", true)
|
|
], 16, _hoisted_140)]),
|
|
_: 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"]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/drawer/src/drawer2.mjs
|
|
var drawer_default = drawer_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/drawer/index.mjs
|
|
var ElDrawer = withInstall(drawer_default);
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/dropdown.mjs
|
|
var dropdownProps = buildProps({
|
|
trigger: {
|
|
...useTooltipTriggerProps.trigger,
|
|
type: definePropType([String, Array])
|
|
},
|
|
triggerKeys: {
|
|
type: definePropType(Array),
|
|
default: () => [
|
|
EVENT_CODE.enter,
|
|
EVENT_CODE.numpadEnter,
|
|
EVENT_CODE.space,
|
|
EVENT_CODE.down
|
|
]
|
|
},
|
|
virtualTriggering: useTooltipTriggerProps.virtualTriggering,
|
|
virtualRef: useTooltipTriggerProps.virtualRef,
|
|
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
|
|
},
|
|
showArrow: {
|
|
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: useTooltipContentProps.popperClass,
|
|
popperStyle: useTooltipContentProps.popperStyle,
|
|
disabled: Boolean,
|
|
role: {
|
|
type: String,
|
|
values: roleTypes,
|
|
default: "menu"
|
|
},
|
|
buttonProps: { type: definePropType(Object) },
|
|
teleported: useTooltipContentProps.teleported,
|
|
appendTo: useTooltipContentProps.appendTo,
|
|
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];
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/tokens.mjs
|
|
var DROPDOWN_INJECTION_KEY = Symbol("elDropdown");
|
|
var DROPDOWN_INSTANCE_INJECTION_KEY = "elDropdown";
|
|
|
|
// node_modules/element-plus/es/components/collection/src/collection.vue_vue_type_script_lang.mjs
|
|
var collection_vue_vue_type_script_lang_default = defineComponent({ inheritAttrs: false });
|
|
|
|
// node_modules/element-plus/es/components/collection/src/collection2.mjs
|
|
function _sfc_render6(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return renderSlot(_ctx.$slots, "default");
|
|
}
|
|
var collection_default = _plugin_vue_export_helper_default(collection_vue_vue_type_script_lang_default, [["render", _sfc_render6]]);
|
|
|
|
// node_modules/element-plus/es/components/collection/src/collection-item.vue_vue_type_script_lang.mjs
|
|
var collection_item_vue_vue_type_script_lang_default = defineComponent({
|
|
name: "ElCollectionItem",
|
|
inheritAttrs: false
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/collection/src/collection-item.mjs
|
|
function _sfc_render7(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return renderSlot(_ctx.$slots, "default");
|
|
}
|
|
var collection_item_default = _plugin_vue_export_helper_default(collection_item_vue_vue_type_script_lang_default, [["render", _sfc_render7]]);
|
|
|
|
// 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_KEY2 = Symbol(COLLECTION_NAME);
|
|
const COLLECTION_ITEM_INJECTION_KEY2 = Symbol(COLLECTION_ITEM_NAME);
|
|
return {
|
|
COLLECTION_INJECTION_KEY: COLLECTION_INJECTION_KEY2,
|
|
COLLECTION_ITEM_INJECTION_KEY: COLLECTION_ITEM_INJECTION_KEY2,
|
|
ElCollection: Object.assign({}, collection_default, {
|
|
name: COLLECTION_NAME,
|
|
setup() {
|
|
const collectionRef = ref();
|
|
const itemMap = /* @__PURE__ */ new Map();
|
|
const getItems = () => {
|
|
const collectionEl = unref(collectionRef);
|
|
if (!collectionEl)
|
|
return [];
|
|
const orderedNodes = Array.from(collectionEl.querySelectorAll(`[${COLLECTION_ITEM_SIGN}]`));
|
|
return [...itemMap.values()].sort((a2, b2) => orderedNodes.indexOf(a2.ref) - orderedNodes.indexOf(b2.ref));
|
|
};
|
|
provide(COLLECTION_INJECTION_KEY2, {
|
|
itemMap,
|
|
getItems,
|
|
collectionRef
|
|
});
|
|
}
|
|
}),
|
|
ElCollectionItem: Object.assign({}, collection_item_default, {
|
|
name: COLLECTION_ITEM_NAME,
|
|
setup(_2, { attrs }) {
|
|
const collectionItemRef = ref();
|
|
const collectionInjection = inject(COLLECTION_INJECTION_KEY2, void 0);
|
|
provide(COLLECTION_ITEM_INJECTION_KEY2, { collectionItemRef });
|
|
onMounted(() => {
|
|
const collectionItemEl = unref(collectionItemRef);
|
|
if (collectionItemEl)
|
|
collectionInjection.itemMap.set(collectionItemEl, {
|
|
ref: collectionItemEl,
|
|
...attrs
|
|
});
|
|
});
|
|
onBeforeUnmount(() => {
|
|
const collectionItemEl = unref(collectionItemRef);
|
|
collectionInjection.itemMap.delete(collectionItemEl);
|
|
});
|
|
}
|
|
})
|
|
};
|
|
};
|
|
|
|
// 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, ElCollectionItem, COLLECTION_INJECTION_KEY, COLLECTION_ITEM_INJECTION_KEY } = 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(getEventCode(event), 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.vue_vue_type_script_lang.mjs
|
|
var CURRENT_TAB_ID_CHANGE_EVT = "currentTabIdChange";
|
|
var ENTRY_FOCUS_EVT = "rovingFocusGroup.entryFocus";
|
|
var EVT_OPTS = {
|
|
bubbles: false,
|
|
cancelable: true
|
|
};
|
|
var roving_focus_group_impl_vue_vue_type_script_lang_default = defineComponent({
|
|
name: "ElRovingFocusGroupImpl",
|
|
inheritAttrs: false,
|
|
props: rovingFocusGroupProps,
|
|
emits: [CURRENT_TAB_ID_CHANGE_EVT, "entryFocus"],
|
|
setup(props2, { emit }) {
|
|
var _a;
|
|
const currentTabbedId = ref((_a = props2.currentTabId || props2.defaultCurrentTabId) != null ? _a : null);
|
|
const isBackingOut = ref(false);
|
|
const isClickFocus = ref(false);
|
|
const rovingFocusGroupRef = ref();
|
|
const { getItems } = inject(COLLECTION_INJECTION_KEY, 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 _a2;
|
|
(_a2 = props2.onMousedown) == null ? void 0 : _a2.call(props2, e);
|
|
}, () => {
|
|
isClickFocus.value = true;
|
|
});
|
|
const onFocus = composeEventHandlers((e) => {
|
|
var _a2;
|
|
(_a2 = props2.onFocus) == null ? void 0 : _a2.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);
|
|
focusFirst([
|
|
items.find((item) => item.active),
|
|
items.find((item) => item.id === unref(currentTabbedId)),
|
|
...items
|
|
].filter(Boolean).map((item) => item.ref));
|
|
}
|
|
}
|
|
isClickFocus.value = false;
|
|
});
|
|
const onBlur = composeEventHandlers((e) => {
|
|
var _a2;
|
|
(_a2 = props2.onBlur) == null ? void 0 : _a2.call(props2, e);
|
|
}, () => {
|
|
isBackingOut.value = false;
|
|
});
|
|
const handleEntryFocus = (...args) => {
|
|
emit("entryFocus", ...args);
|
|
};
|
|
const onKeydown = (e) => {
|
|
const focusIntent = getFocusIntent(e);
|
|
if (focusIntent) {
|
|
e.preventDefault();
|
|
let elements = getItems().filter((item) => item.focusable).map((item) => item.ref);
|
|
switch (focusIntent) {
|
|
case "last":
|
|
elements.reverse();
|
|
break;
|
|
case "prev":
|
|
case "next": {
|
|
if (focusIntent === "prev")
|
|
elements.reverse();
|
|
const currentIdx = elements.indexOf(e.currentTarget);
|
|
elements = props2.loop ? reorderArray(elements, currentIdx + 1) : elements.slice(currentIdx + 1);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
nextTick(() => {
|
|
focusFirst(elements);
|
|
});
|
|
}
|
|
};
|
|
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,
|
|
onKeydown
|
|
});
|
|
watch(() => props2.currentTabId, (val) => {
|
|
currentTabbedId.value = val != null ? val : null;
|
|
});
|
|
useEventListener(rovingFocusGroupRef, ENTRY_FOCUS_EVT, handleEntryFocus);
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/roving-focus-group/src/roving-focus-group-impl.mjs
|
|
function _sfc_render8(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return renderSlot(_ctx.$slots, "default");
|
|
}
|
|
var roving_focus_group_impl_default = _plugin_vue_export_helper_default(roving_focus_group_impl_vue_vue_type_script_lang_default, [["render", _sfc_render8]]);
|
|
|
|
// node_modules/element-plus/es/components/roving-focus-group/src/roving-focus-group.vue_vue_type_script_lang.mjs
|
|
var roving_focus_group_vue_vue_type_script_lang_default = defineComponent({
|
|
name: "ElRovingFocusGroup",
|
|
components: {
|
|
ElFocusGroupCollection: ElCollection,
|
|
ElRovingFocusGroupImpl: roving_focus_group_impl_default
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/roving-focus-group/src/roving-focus-group2.mjs
|
|
function _sfc_render9(_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 roving_focus_group_default = _plugin_vue_export_helper_default(roving_focus_group_vue_vue_type_script_lang_default, [["render", _sfc_render9]]);
|
|
|
|
// node_modules/element-plus/es/components/roving-focus-group/src/roving-focus-item.vue_vue_type_script_lang.mjs
|
|
var roving_focus_item_vue_vue_type_script_lang_default = defineComponent({
|
|
components: { ElRovingFocusCollectionItem: ElCollectionItem },
|
|
props: {
|
|
focusable: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
active: Boolean
|
|
},
|
|
emits: [
|
|
"mousedown",
|
|
"focus",
|
|
"keydown"
|
|
],
|
|
setup(props2, { emit }) {
|
|
const { currentTabbedId, onItemFocus, onItemShiftTab, onKeydown } = inject(ROVING_FOCUS_GROUP_INJECTION_KEY, 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 { shiftKey, target: target2, currentTarget } = e;
|
|
if (getEventCode(e) === EVENT_CODE.tab && shiftKey) {
|
|
onItemShiftTab();
|
|
return;
|
|
}
|
|
if (target2 !== currentTarget)
|
|
return;
|
|
onKeydown(e);
|
|
});
|
|
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
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/roving-focus-group/src/roving-focus-item.mjs
|
|
function _sfc_render10(_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 roving_focus_item_default = _plugin_vue_export_helper_default(roving_focus_item_vue_vue_type_script_lang_default, [["render", _sfc_render10]]);
|
|
|
|
// node_modules/element-plus/es/components/roving-focus-group/index.mjs
|
|
var roving_focus_group_default$1 = roving_focus_group_default;
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/dropdown.vue_vue_type_script_lang.mjs
|
|
var { ButtonGroup: ElButtonGroup2 } = ElButton;
|
|
var dropdown_vue_vue_type_script_lang_default = defineComponent({
|
|
name: "ElDropdown",
|
|
components: {
|
|
ElButton,
|
|
ElButtonGroup: ElButtonGroup2,
|
|
ElScrollbar,
|
|
ElTooltip,
|
|
ElRovingFocusGroup: roving_focus_group_default$1,
|
|
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);
|
|
function handleClick() {
|
|
var _a;
|
|
(_a = popperRef.value) == null ? void 0 : _a.onClose(void 0, 0);
|
|
}
|
|
function handleClose() {
|
|
var _a;
|
|
(_a = popperRef.value) == null ? void 0 : _a.onClose();
|
|
}
|
|
function handleOpen() {
|
|
var _a;
|
|
(_a = popperRef.value) == null ? void 0 : _a.onOpen();
|
|
}
|
|
const dropdownSize = useFormSize();
|
|
function commandHandler(...args) {
|
|
emit("command", ...args);
|
|
}
|
|
function onItemEnter() {
|
|
}
|
|
function onItemLeave() {
|
|
const contentEl = unref(contentRef);
|
|
trigger.value.includes("hover") && (contentEl == null ? void 0 : contentEl.focus({ preventScroll: true }));
|
|
currentTabId.value = null;
|
|
}
|
|
function handleCurrentTabIdChange(id) {
|
|
currentTabId.value = id;
|
|
}
|
|
function handleBeforeShowTooltip() {
|
|
emit("visible-change", true);
|
|
}
|
|
function handleShowTooltip(event) {
|
|
var _a;
|
|
isUsingKeyboard.value = (event == null ? void 0 : event.type) === "keydown";
|
|
(_a = contentRef.value) == null ? void 0 : _a.focus();
|
|
}
|
|
function handleBeforeHideTooltip() {
|
|
emit("visible-change", false);
|
|
}
|
|
provide(DROPDOWN_INJECTION_KEY, {
|
|
contentRef,
|
|
role: computed(() => props2.role),
|
|
triggerId,
|
|
isUsingKeyboard,
|
|
onItemEnter,
|
|
onItemLeave,
|
|
handleClose
|
|
});
|
|
provide(DROPDOWN_INSTANCE_INJECTION_KEY, {
|
|
instance: _instance,
|
|
dropdownSize,
|
|
handleClick,
|
|
commandHandler,
|
|
trigger: toRef(props2, "trigger"),
|
|
hideOnClick: toRef(props2, "hideOnClick")
|
|
});
|
|
const handlerMainButtonClick = (event) => {
|
|
emit("click", event);
|
|
};
|
|
return {
|
|
t,
|
|
ns,
|
|
scrollbar,
|
|
wrapStyle,
|
|
dropdownTriggerKls,
|
|
dropdownSize,
|
|
triggerId,
|
|
currentTabId,
|
|
handleCurrentTabIdChange,
|
|
handlerMainButtonClick,
|
|
handleClose,
|
|
handleOpen,
|
|
handleBeforeShowTooltip,
|
|
handleShowTooltip,
|
|
handleBeforeHideTooltip,
|
|
popperRef,
|
|
contentRef,
|
|
triggeringElementRef,
|
|
referenceElementRef
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/dropdown2.mjs
|
|
function _sfc_render11(_ctx, _cache, $props, $setup, $data, $options) {
|
|
var _a;
|
|
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,
|
|
placement: _ctx.placement,
|
|
"popper-class": [_ctx.ns.e("popper"), _ctx.popperClass],
|
|
"popper-style": _ctx.popperStyle,
|
|
trigger: _ctx.trigger,
|
|
"trigger-keys": _ctx.triggerKeys,
|
|
"trigger-target-el": _ctx.contentRef,
|
|
"show-arrow": _ctx.showArrow,
|
|
"show-after": _ctx.trigger === "hover" ? _ctx.showTimeout : 0,
|
|
"hide-after": _ctx.trigger === "hover" ? _ctx.hideTimeout : 0,
|
|
"virtual-ref": (_a = _ctx.virtualRef) != null ? _a : _ctx.triggeringElementRef,
|
|
"virtual-triggering": _ctx.virtualTriggering || _ctx.splitButton,
|
|
disabled: _ctx.disabled,
|
|
transition: `${_ctx.ns.namespace.value}-zoom-in-top`,
|
|
teleported: _ctx.teleported,
|
|
"append-to": _ctx.appendTo,
|
|
pure: "",
|
|
"focus-on-target": "",
|
|
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
|
|
}, {
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "dropdown")]),
|
|
_: 3
|
|
}, 8, [
|
|
"loop",
|
|
"current-tab-id",
|
|
"onCurrentTabIdChange"
|
|
])]),
|
|
_: 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"])]),
|
|
key: "0"
|
|
} : void 0]), 1032, [
|
|
"role",
|
|
"effect",
|
|
"popper-options",
|
|
"placement",
|
|
"popper-class",
|
|
"popper-style",
|
|
"trigger",
|
|
"trigger-keys",
|
|
"trigger-target-el",
|
|
"show-arrow",
|
|
"show-after",
|
|
"hide-after",
|
|
"virtual-ref",
|
|
"virtual-triggering",
|
|
"disabled",
|
|
"transition",
|
|
"teleported",
|
|
"append-to",
|
|
"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_default = _plugin_vue_export_helper_default(dropdown_vue_vue_type_script_lang_default, [["render", _sfc_render11]]);
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/dropdown-item-impl.vue_vue_type_script_lang.mjs
|
|
var dropdown_item_impl_vue_vue_type_script_lang_default = 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: rovingFocusCollectionItemRef } = inject(COLLECTION_ITEM_INJECTION_KEY, void 0);
|
|
const { rovingFocusGroupItemRef, tabIndex, handleFocus, handleKeydown: handleItemKeydown, handleMousedown } = inject(ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY, void 0);
|
|
const itemRef = composeRefs(rovingFocusCollectionItemRef, rovingFocusGroupItemRef);
|
|
const role = computed(() => {
|
|
if (menuRole.value === "menu")
|
|
return "menuitem";
|
|
else if (menuRole.value === "navigation")
|
|
return "link";
|
|
return "button";
|
|
});
|
|
const handleKeydown = composeEventHandlers((e) => {
|
|
const code = getEventCode(e);
|
|
if ([
|
|
EVENT_CODE.enter,
|
|
EVENT_CODE.numpadEnter,
|
|
EVENT_CODE.space
|
|
].includes(code)) {
|
|
e.preventDefault();
|
|
e.stopImmediatePropagation();
|
|
emit("clickimpl", e);
|
|
return true;
|
|
}
|
|
}, handleItemKeydown);
|
|
return {
|
|
ns,
|
|
itemRef,
|
|
dataset: { [COLLECTION_ITEM_SIGN]: "" },
|
|
role,
|
|
tabIndex,
|
|
handleFocus,
|
|
handleKeydown,
|
|
handleMousedown
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/dropdown-item-impl.mjs
|
|
var _hoisted_141 = [
|
|
"aria-disabled",
|
|
"tabindex",
|
|
"role"
|
|
];
|
|
function _sfc_render12(_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: _cache[0] || (_cache[0] = (e) => _ctx.$emit("clickimpl", e)),
|
|
onFocus: _cache[1] || (_cache[1] = (...args) => _ctx.handleFocus && _ctx.handleFocus(...args)),
|
|
onKeydown: _cache[2] || (_cache[2] = withModifiers((...args) => _ctx.handleKeydown && _ctx.handleKeydown(...args), ["self"])),
|
|
onMousedown: _cache[3] || (_cache[3] = (...args) => _ctx.handleMousedown && _ctx.handleMousedown(...args)),
|
|
onPointermove: _cache[4] || (_cache[4] = (e) => _ctx.$emit("pointermove", e)),
|
|
onPointerleave: _cache[5] || (_cache[5] = (e) => _ctx.$emit("pointerleave", e))
|
|
}), [_ctx.icon || _ctx.$slots.icon ? (openBlock(), createBlock(_component_el_icon, { key: 0 }, {
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "icon", {}, () => [(openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))])]),
|
|
_: 3
|
|
})) : createCommentVNode("v-if", true), renderSlot(_ctx.$slots, "default")], 16, _hoisted_141)], 64);
|
|
}
|
|
var dropdown_item_impl_default = _plugin_vue_export_helper_default(dropdown_item_impl_vue_vue_type_script_lang_default, [["render", _sfc_render12]]);
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/useDropdown.mjs
|
|
var useDropdown = () => {
|
|
const elDropdown = inject(DROPDOWN_INSTANCE_INJECTION_KEY, {});
|
|
return {
|
|
elDropdown,
|
|
_elDropdownSize: computed(() => elDropdown == null ? void 0 : elDropdown.dropdownSize)
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/dropdown-item.vue_vue_type_script_lang.mjs
|
|
var dropdown_item_vue_vue_type_script_lang_default = defineComponent({
|
|
name: "ElDropdownItem",
|
|
components: {
|
|
ElRovingFocusItem: roving_focus_item_default,
|
|
ElDropdownItemImpl: dropdown_item_impl_default
|
|
},
|
|
inheritAttrs: false,
|
|
props: dropdownItemProps,
|
|
emits: [
|
|
"pointermove",
|
|
"pointerleave",
|
|
"click"
|
|
],
|
|
setup(props2, { emit, attrs }) {
|
|
const { elDropdown } = useDropdown();
|
|
const _instance = getCurrentInstance();
|
|
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({ preventScroll: true });
|
|
}));
|
|
const handlePointerLeave = composeEventHandlers((e) => {
|
|
emit("pointerleave", e);
|
|
return e.defaultPrevented;
|
|
}, whenMouse(onItemLeave));
|
|
return {
|
|
handleClick: composeEventHandlers((e) => {
|
|
if (props2.disabled)
|
|
return;
|
|
emit("click", e);
|
|
return e.type !== "keydown" && e.defaultPrevented;
|
|
}, (e) => {
|
|
var _a, _b, _c;
|
|
if (props2.disabled) {
|
|
e.stopImmediatePropagation();
|
|
return;
|
|
}
|
|
if ((_a = elDropdown == null ? void 0 : elDropdown.hideOnClick) == null ? void 0 : _a.value)
|
|
(_b = elDropdown.handleClick) == null ? void 0 : _b.call(elDropdown);
|
|
(_c = elDropdown.commandHandler) == null ? void 0 : _c.call(elDropdown, props2.command, _instance, e);
|
|
}),
|
|
handlePointerMove,
|
|
handlePointerLeave,
|
|
propsAndAttrs: computed(() => ({
|
|
...props2,
|
|
...attrs
|
|
}))
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/dropdown-item.mjs
|
|
function _sfc_render13(_ctx, _cache, $props, $setup, $data, $options) {
|
|
const _component_el_dropdown_item_impl = resolveComponent("el-dropdown-item-impl");
|
|
const _component_el_roving_focus_item = resolveComponent("el-roving-focus-item");
|
|
return openBlock(), createBlock(_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
|
|
}), createSlots({
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
|
|
_: 2
|
|
}, [_ctx.$slots.icon ? {
|
|
name: "icon",
|
|
fn: withCtx(() => [renderSlot(_ctx.$slots, "icon")]),
|
|
key: "0"
|
|
} : void 0]), 1040, [
|
|
"onPointerleave",
|
|
"onPointermove",
|
|
"onClickimpl"
|
|
])]),
|
|
_: 3
|
|
}, 8, ["focusable"]);
|
|
}
|
|
var dropdown_item_default = _plugin_vue_export_helper_default(dropdown_item_vue_vue_type_script_lang_default, [["render", _sfc_render13]]);
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/dropdown-menu.vue_vue_type_script_lang.mjs
|
|
var dropdown_menu_vue_vue_type_script_lang_default = defineComponent({
|
|
name: "ElDropdownMenu",
|
|
props: dropdownMenuProps,
|
|
setup(props2) {
|
|
const ns = useNamespace("dropdown");
|
|
const { _elDropdownSize } = useDropdown();
|
|
const size3 = _elDropdownSize.value;
|
|
const { contentRef, role, triggerId, isUsingKeyboard, handleClose } = inject(DROPDOWN_INJECTION_KEY, void 0);
|
|
const { rovingFocusGroupRef, rovingFocusGroupRootStyle, onBlur, onFocus, onKeydown, onMousedown } = inject(ROVING_FOCUS_GROUP_INJECTION_KEY, void 0);
|
|
const { collectionRef: rovingFocusGroupCollectionRef } = inject(COLLECTION_INJECTION_KEY, void 0);
|
|
const dropdownKls = computed(() => {
|
|
return [ns.b("menu"), ns.bm("menu", size3 == null ? void 0 : size3.value)];
|
|
});
|
|
const dropdownListWrapperRef = composeRefs(contentRef, rovingFocusGroupRef, rovingFocusGroupCollectionRef);
|
|
const handleKeydown = composeEventHandlers((e) => {
|
|
var _a;
|
|
(_a = props2.onKeydown) == null ? void 0 : _a.call(props2, e);
|
|
}, (e) => {
|
|
const { currentTarget, target: target2 } = e;
|
|
const code = getEventCode(e);
|
|
if (currentTarget.contains(target2)) {
|
|
}
|
|
if (EVENT_CODE.tab === code)
|
|
return handleClose();
|
|
onKeydown(e);
|
|
});
|
|
function handleFocus(e) {
|
|
isUsingKeyboard.value && onFocus(e);
|
|
}
|
|
return {
|
|
size: size3,
|
|
rovingFocusGroupRootStyle,
|
|
dropdownKls,
|
|
role,
|
|
triggerId,
|
|
dropdownListWrapperRef,
|
|
handleKeydown,
|
|
onBlur,
|
|
handleFocus,
|
|
onMousedown
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/dropdown/src/dropdown-menu.mjs
|
|
var _hoisted_142 = ["role", "aria-labelledby"];
|
|
function _sfc_render14(_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,
|
|
onFocusin: _cache[0] || (_cache[0] = (...args) => _ctx.handleFocus && _ctx.handleFocus(...args)),
|
|
onFocusout: _cache[1] || (_cache[1] = (...args) => _ctx.onBlur && _ctx.onBlur(...args)),
|
|
onKeydown: _cache[2] || (_cache[2] = withModifiers((...args) => _ctx.handleKeydown && _ctx.handleKeydown(...args), ["self"])),
|
|
onMousedown: _cache[3] || (_cache[3] = withModifiers((...args) => _ctx.onMousedown && _ctx.onMousedown(...args), ["self"]))
|
|
}, [renderSlot(_ctx.$slots, "default")], 46, _hoisted_142);
|
|
}
|
|
var dropdown_menu_default = _plugin_vue_export_helper_default(dropdown_menu_vue_vue_type_script_lang_default, [["render", _sfc_render14]]);
|
|
|
|
// node_modules/element-plus/es/components/dropdown/index.mjs
|
|
var ElDropdown = withInstall(dropdown_default, {
|
|
DropdownItem: dropdown_item_default,
|
|
DropdownMenu: dropdown_menu_default
|
|
});
|
|
var ElDropdownItem = withNoopInstall(dropdown_item_default);
|
|
var ElDropdownMenu = withNoopInstall(dropdown_menu_default);
|
|
|
|
// 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.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_143 = {
|
|
viewBox: "0 0 79 86",
|
|
version: "1.1",
|
|
xmlns: "http://www.w3.org/2000/svg",
|
|
"xmlns:xlink": "http://www.w3.org/1999/xlink"
|
|
};
|
|
var _hoisted_221 = ["id"];
|
|
var _hoisted_311 = ["stop-color"];
|
|
var _hoisted_47 = ["stop-color"];
|
|
var _hoisted_56 = ["id"];
|
|
var _hoisted_64 = ["stop-color"];
|
|
var _hoisted_73 = ["stop-color"];
|
|
var _hoisted_82 = ["id"];
|
|
var _hoisted_92 = {
|
|
stroke: "none",
|
|
"stroke-width": "1",
|
|
fill: "none",
|
|
"fill-rule": "evenodd"
|
|
};
|
|
var _hoisted_102 = { transform: "translate(-1268.000000, -535.000000)" };
|
|
var _hoisted_1110 = { transform: "translate(1268.000000, 535.000000)" };
|
|
var _hoisted_1211 = ["fill"];
|
|
var _hoisted_1310 = ["fill"];
|
|
var _hoisted_144 = { transform: "translate(34.500000, 31.500000) scale(-1, 1) rotate(-25.000000) translate(-34.500000, -31.500000) translate(7.000000, 10.000000)" };
|
|
var _hoisted_152 = ["fill"];
|
|
var _hoisted_162 = ["fill"];
|
|
var _hoisted_172 = ["fill"];
|
|
var _hoisted_182 = ["fill"];
|
|
var _hoisted_192 = ["fill"];
|
|
var _hoisted_20 = { transform: "translate(53.000000, 45.000000)" };
|
|
var _hoisted_21 = ["fill", "xlink:href"];
|
|
var _hoisted_222 = ["fill", "mask"];
|
|
var _hoisted_232 = ["fill"];
|
|
var img_empty_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ImgEmpty",
|
|
__name: "img-empty",
|
|
setup(__props) {
|
|
const ns = useNamespace("empty");
|
|
const id = useId();
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("svg", _hoisted_143, [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, _hoisted_311), createBaseVNode("stop", {
|
|
"stop-color": `var(${unref(ns).cssVarBlockName("fill-color-4")})`,
|
|
offset: "100%"
|
|
}, null, 8, _hoisted_47)], 8, _hoisted_221),
|
|
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, _hoisted_64), createBaseVNode("stop", {
|
|
"stop-color": `var(${unref(ns).cssVarBlockName("fill-color-6")})`,
|
|
offset: "100%"
|
|
}, null, 8, _hoisted_73)], 8, _hoisted_56),
|
|
createBaseVNode("rect", {
|
|
id: `path-3-${unref(id)}`,
|
|
x: "0",
|
|
y: "0",
|
|
width: "17",
|
|
height: "36"
|
|
}, null, 8, _hoisted_82)
|
|
]), createBaseVNode("g", _hoisted_92, [createBaseVNode("g", _hoisted_102, [createBaseVNode("g", _hoisted_1110, [
|
|
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, _hoisted_1211),
|
|
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, _hoisted_1310),
|
|
createBaseVNode("g", _hoisted_144, [
|
|
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, _hoisted_152),
|
|
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, _hoisted_162),
|
|
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, _hoisted_172),
|
|
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, _hoisted_182)
|
|
]),
|
|
createBaseVNode("rect", {
|
|
fill: `url(#linearGradient-2-${unref(id)})`,
|
|
x: "13",
|
|
y: "45",
|
|
width: "40",
|
|
height: "36"
|
|
}, null, 8, _hoisted_192),
|
|
createBaseVNode("g", _hoisted_20, [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, _hoisted_21), 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, _hoisted_222)]),
|
|
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, _hoisted_232)
|
|
])])])]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/empty/src/img-empty.mjs
|
|
var img_empty_default = img_empty_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/empty/src/empty.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_145 = ["src"];
|
|
var _hoisted_223 = { key: 1 };
|
|
var empty_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElEmpty",
|
|
__name: "empty",
|
|
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(imageStyle.value)
|
|
}, [__props.image ? (openBlock(), createElementBlock("img", {
|
|
key: 0,
|
|
src: __props.image,
|
|
ondragstart: "return false"
|
|
}, null, 8, _hoisted_145)) : renderSlot(_ctx.$slots, "image", { key: 1 }, () => [createVNode(img_empty_default)])], 6),
|
|
createBaseVNode("div", { class: normalizeClass(unref(ns).e("description")) }, [_ctx.$slots.description ? renderSlot(_ctx.$slots, "description", { key: 0 }) : (openBlock(), createElementBlock("p", _hoisted_223, toDisplayString(emptyDescription.value), 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);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/empty/src/empty2.mjs
|
|
var empty_default = empty_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/empty/index.mjs
|
|
var ElEmpty = withInstall(empty_default);
|
|
|
|
// 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
|
|
},
|
|
scale: {
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
minScale: {
|
|
type: Number,
|
|
default: 0.2
|
|
},
|
|
maxScale: {
|
|
type: Number,
|
|
default: 7
|
|
},
|
|
showProgress: Boolean,
|
|
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-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
|
|
},
|
|
scale: {
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
minScale: {
|
|
type: Number,
|
|
default: 0.2
|
|
},
|
|
maxScale: {
|
|
type: Number,
|
|
default: 7
|
|
},
|
|
showProgress: Boolean,
|
|
crossorigin: { type: definePropType(String) }
|
|
});
|
|
var imageViewerEmits = {
|
|
close: () => true,
|
|
error: (evt) => evt instanceof Event,
|
|
switch: (index) => isNumber2(index),
|
|
rotate: (deg) => isNumber2(deg)
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/image-viewer/src/image-viewer.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_146 = ["src", "crossorigin"];
|
|
var image_viewer_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElImageViewer",
|
|
__name: "image-viewer",
|
|
props: imageViewerProps,
|
|
emits: imageViewerEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
var _a;
|
|
const modes = {
|
|
CONTAIN: {
|
|
name: "contain",
|
|
icon: markRaw(full_screen_default)
|
|
},
|
|
ORIGINAL: {
|
|
name: "original",
|
|
icon: markRaw(scale_to_original_default)
|
|
}
|
|
};
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
let stopWheelListener;
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("image-viewer");
|
|
const { nextZIndex } = useZIndex();
|
|
const wrapper = ref();
|
|
const imgRef = ref();
|
|
const scopeEventListener = effectScope();
|
|
const scaleClamped = computed(() => {
|
|
const { scale, minScale, maxScale } = props2;
|
|
return clamp(scale, minScale, maxScale);
|
|
});
|
|
const loading = ref(true);
|
|
const loadError = ref(false);
|
|
const visible = ref(false);
|
|
const activeIndex = ref(props2.initialIndex);
|
|
const mode = shallowRef(modes.CONTAIN);
|
|
const transform2 = ref({
|
|
scale: scaleClamped.value,
|
|
deg: 0,
|
|
offsetX: 0,
|
|
offsetY: 0,
|
|
enableTransition: false
|
|
});
|
|
const zIndex2 = ref((_a = props2.zIndex) != null ? _a : nextZIndex());
|
|
useLockscreen(visible, { ns });
|
|
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();
|
|
visible.value = false;
|
|
emit("close");
|
|
}
|
|
function registerEventListener() {
|
|
const keydownHandler = throttle_default((e) => {
|
|
switch (getEventCode(e)) {
|
|
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) => {
|
|
handleActions((e.deltaY || e.deltaX) < 0 ? "zoomIn" : "zoomOut", {
|
|
zoomRate: props2.zoomRate,
|
|
enableTransition: false
|
|
});
|
|
});
|
|
scopeEventListener.run(() => {
|
|
useEventListener(document, "keydown", keydownHandler);
|
|
useEventListener(wrapper, "wheel", mousewheelHandler);
|
|
});
|
|
}
|
|
function unregisterEventListener() {
|
|
scopeEventListener.stop();
|
|
}
|
|
function handleImgLoad() {
|
|
loading.value = false;
|
|
}
|
|
function handleImgError(e) {
|
|
loadError.value = true;
|
|
loading.value = false;
|
|
emit("error", e);
|
|
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);
|
|
const removeMouseup = useEventListener(document, "mouseup", () => {
|
|
removeMousemove();
|
|
removeMouseup();
|
|
});
|
|
e.preventDefault();
|
|
}
|
|
function handleTouchStart(e) {
|
|
if (loading.value || !wrapper.value || e.touches.length !== 1)
|
|
return;
|
|
transform2.value.enableTransition = false;
|
|
const { offsetX, offsetY } = transform2.value;
|
|
const { pageX: startX, pageY: startY } = e.touches[0];
|
|
const dragHandler = throttle_default((ev) => {
|
|
const targetTouch = ev.touches[0];
|
|
transform2.value = {
|
|
...transform2.value,
|
|
offsetX: offsetX + targetTouch.pageX - startX,
|
|
offsetY: offsetY + targetTouch.pageY - startY
|
|
};
|
|
});
|
|
const removeTouchmove = useEventListener(document, "touchmove", dragHandler);
|
|
const removeTouchend = useEventListener(document, "touchend", () => {
|
|
removeTouchmove();
|
|
removeTouchend();
|
|
});
|
|
e.preventDefault();
|
|
}
|
|
function reset() {
|
|
transform2.value = {
|
|
scale: scaleClamped.value,
|
|
deg: 0,
|
|
offsetX: 0,
|
|
offsetY: 0,
|
|
enableTransition: false
|
|
};
|
|
}
|
|
function toggleMode() {
|
|
if (loading.value || loadError.value)
|
|
return;
|
|
const modeNames = keysOf(modes);
|
|
const modeValues = Object.values(modes);
|
|
const currentMode = mode.value.name;
|
|
mode.value = modes[modeNames[(modeValues.findIndex((i) => i.name === currentMode) + 1) % modeNames.length]];
|
|
reset();
|
|
}
|
|
function setActiveItem(index) {
|
|
loadError.value = false;
|
|
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 || loadError.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 _a2;
|
|
if (((_a2 = event.detail) == null ? void 0 : _a2.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(() => scaleClamped.value, (val) => {
|
|
transform2.value.scale = val;
|
|
});
|
|
watch(currentImg, () => {
|
|
nextTick(() => {
|
|
var _a2;
|
|
if (!((_a2 = imgRef.value) == null ? void 0 : _a2.complete))
|
|
loading.value = true;
|
|
});
|
|
});
|
|
watch(activeIndex, (val) => {
|
|
reset();
|
|
emit("switch", val);
|
|
});
|
|
onMounted(() => {
|
|
visible.value = true;
|
|
registerEventListener();
|
|
stopWheelListener = useEventListener("wheel", wheelHandler, { passive: false });
|
|
});
|
|
__expose({ setActiveItem });
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElTeleport), {
|
|
to: "body",
|
|
disabled: !__props.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(focus_trap_default$1), {
|
|
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: _cache[0] || (_cache[0] = withModifiers(($event) => __props.hideOnClickModal && hide2(), ["self"]))
|
|
}, null, 2),
|
|
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 "),
|
|
!isSingle.value ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [createBaseVNode("span", {
|
|
class: normalizeClass(arrowPrevKls.value),
|
|
onClick: prev
|
|
}, [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(arrow_left_default))]),
|
|
_: 1
|
|
})], 2), createBaseVNode("span", {
|
|
class: normalizeClass(arrowNextKls.value),
|
|
onClick: next
|
|
}, [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(arrow_right_default))]),
|
|
_: 1
|
|
})], 2)], 64)) : createCommentVNode("v-if", true),
|
|
_ctx.$slots.progress || __props.showProgress ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass([unref(ns).e("btn"), unref(ns).e("progress")])
|
|
}, [renderSlot(_ctx.$slots, "progress", {
|
|
activeIndex: activeIndex.value,
|
|
total: __props.urlList.length
|
|
}, () => [createTextVNode(toDisplayString(progress.value), 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: _cache[1] || (_cache[1] = ($event) => handleActions("zoomOut")) }, {
|
|
default: withCtx(() => [createVNode(unref(zoom_out_default))]),
|
|
_: 1
|
|
}),
|
|
createVNode(unref(ElIcon), { onClick: _cache[2] || (_cache[2] = ($event) => handleActions("zoomIn")) }, {
|
|
default: withCtx(() => [createVNode(unref(zoom_in_default))]),
|
|
_: 1
|
|
}),
|
|
createBaseVNode("i", { class: normalizeClass(unref(ns).e("actions__divider")) }, null, 2),
|
|
createVNode(unref(ElIcon), { onClick: toggleMode }, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(mode.value.icon)))]),
|
|
_: 1
|
|
}),
|
|
createBaseVNode("i", { class: normalizeClass(unref(ns).e("actions__divider")) }, null, 2),
|
|
createVNode(unref(ElIcon), { onClick: _cache[3] || (_cache[3] = ($event) => handleActions("anticlockwise")) }, {
|
|
default: withCtx(() => [createVNode(unref(refresh_left_default))]),
|
|
_: 1
|
|
}),
|
|
createVNode(unref(ElIcon), { onClick: _cache[4] || (_cache[4] = ($event) => handleActions("clockwise")) }, {
|
|
default: withCtx(() => [createVNode(unref(refresh_right_default))]),
|
|
_: 1
|
|
})
|
|
])], 2)], 2),
|
|
createCommentVNode(" CANVAS "),
|
|
createBaseVNode("div", { class: normalizeClass(unref(ns).e("canvas")) }, [loadError.value && _ctx.$slots["viewer-error"] ? renderSlot(_ctx.$slots, "viewer-error", {
|
|
key: 0,
|
|
activeIndex: activeIndex.value,
|
|
src: currentImg.value
|
|
}) : (openBlock(), createElementBlock("img", {
|
|
ref_key: "imgRef",
|
|
ref: imgRef,
|
|
key: currentImg.value,
|
|
src: currentImg.value,
|
|
style: normalizeStyle(imgStyle.value),
|
|
class: normalizeClass(unref(ns).e("img")),
|
|
crossorigin: __props.crossorigin,
|
|
onLoad: handleImgLoad,
|
|
onError: handleImgError,
|
|
onMousedown: handleMouseDown,
|
|
onTouchstart: handleTouchStart
|
|
}, null, 46, _hoisted_146))], 2),
|
|
renderSlot(_ctx.$slots, "default")
|
|
]),
|
|
_: 3
|
|
}, 8, ["focus-trap-el"])], 6)]),
|
|
_: 3
|
|
})]),
|
|
_: 3
|
|
}, 8, ["disabled"]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/image-viewer/src/image-viewer2.mjs
|
|
var image_viewer_default = image_viewer_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/image-viewer/index.mjs
|
|
var ElImageViewer = withInstall(image_viewer_default);
|
|
|
|
// node_modules/element-plus/es/components/image/src/image.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_147 = [
|
|
"src",
|
|
"loading",
|
|
"crossorigin"
|
|
];
|
|
var _hoisted_224 = { key: 0 };
|
|
var image_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElImage",
|
|
inheritAttrs: false,
|
|
__name: "image",
|
|
props: imageProps,
|
|
emits: imageEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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(isIntersecting) {
|
|
if (isIntersecting) {
|
|
loadImage();
|
|
removeLazyLoadListener();
|
|
}
|
|
}
|
|
const lazyLoadHandler = useThrottleFn(handleLazyLoad, 200, true);
|
|
async function addLazyLoadListener() {
|
|
var _a;
|
|
if (!isClient)
|
|
return;
|
|
await nextTick();
|
|
const { scrollContainer } = props2;
|
|
if (isElement2(scrollContainer))
|
|
_scrollContainer.value = scrollContainer;
|
|
else if (isString(scrollContainer) && scrollContainer !== "")
|
|
_scrollContainer.value = (_a = document.querySelector(scrollContainer)) != null ? _a : void 0;
|
|
else if (container.value) {
|
|
const scrollContainer2 = getScrollContainer(container.value);
|
|
_scrollContainer.value = isWindow(scrollContainer2) ? void 0 : scrollContainer2;
|
|
}
|
|
const { stop } = useIntersectionObserver(container, ([entry]) => {
|
|
lazyLoadHandler(entry.isIntersecting);
|
|
}, { root: _scrollContainer });
|
|
stopScrollListener = stop;
|
|
}
|
|
function removeLazyLoadListener() {
|
|
if (!isClient || !lazyLoadHandler)
|
|
return;
|
|
stopScrollListener == null ? void 0 : stopScrollListener();
|
|
_scrollContainer.value = void 0;
|
|
stopScrollListener = 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
|
|
}, containerAttrs.value, { 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: __props.loading,
|
|
style: imageStyle.value,
|
|
class: imageKls.value,
|
|
crossorigin: __props.crossorigin,
|
|
onClick: clickHandler,
|
|
onLoad: handleLoad,
|
|
onError: handleError
|
|
}), null, 16, _hoisted_147)) : 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)), preview.value ? (openBlock(), createElementBlock(Fragment, { key: 2 }, [showViewer.value ? (openBlock(), createBlock(unref(ElImageViewer), {
|
|
key: 0,
|
|
"z-index": __props.zIndex,
|
|
"initial-index": imageIndex.value,
|
|
infinite: __props.infinite,
|
|
"zoom-rate": __props.zoomRate,
|
|
"min-scale": __props.minScale,
|
|
"max-scale": __props.maxScale,
|
|
"show-progress": __props.showProgress,
|
|
"url-list": __props.previewSrcList,
|
|
scale: __props.scale,
|
|
crossorigin: __props.crossorigin,
|
|
"hide-on-click-modal": __props.hideOnClickModal,
|
|
teleported: __props.previewTeleported,
|
|
"close-on-press-escape": __props.closeOnPressEscape,
|
|
onClose: closeViewer,
|
|
onSwitch: switchViewer
|
|
}, createSlots({
|
|
toolbar: withCtx((toolbar) => [renderSlot(_ctx.$slots, "toolbar", normalizeProps(guardReactiveProps(toolbar)))]),
|
|
default: withCtx(() => [_ctx.$slots.viewer ? (openBlock(), createElementBlock("div", _hoisted_224, [renderSlot(_ctx.$slots, "viewer")])) : createCommentVNode("v-if", true)]),
|
|
_: 2
|
|
}, [_ctx.$slots.progress ? {
|
|
name: "progress",
|
|
fn: withCtx((progress) => [renderSlot(_ctx.$slots, "progress", normalizeProps(guardReactiveProps(progress)))]),
|
|
key: "0"
|
|
} : void 0, _ctx.$slots["viewer-error"] ? {
|
|
name: "viewer-error",
|
|
fn: withCtx((viewerError) => [renderSlot(_ctx.$slots, "viewer-error", normalizeProps(guardReactiveProps(viewerError)))]),
|
|
key: "1"
|
|
} : void 0]), 1032, [
|
|
"z-index",
|
|
"initial-index",
|
|
"infinite",
|
|
"zoom-rate",
|
|
"min-scale",
|
|
"max-scale",
|
|
"show-progress",
|
|
"url-list",
|
|
"scale",
|
|
"crossorigin",
|
|
"hide-on-click-modal",
|
|
"teleported",
|
|
"close-on-press-escape"
|
|
])) : createCommentVNode("v-if", true)], 64)) : createCommentVNode("v-if", true)], 16);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/image/src/image2.mjs
|
|
var image_default = image_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/image/index.mjs
|
|
var ElImage = withInstall(image_default);
|
|
|
|
// 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.MAX_SAFE_INTEGER
|
|
},
|
|
min: {
|
|
type: Number,
|
|
default: Number.MIN_SAFE_INTEGER
|
|
},
|
|
modelValue: { type: [Number, null] },
|
|
readonly: Boolean,
|
|
disabled: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
size: useSizeProp,
|
|
controls: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
controlsPosition: {
|
|
type: String,
|
|
default: "",
|
|
values: ["", "right"]
|
|
},
|
|
valueOnClear: {
|
|
type: definePropType([
|
|
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"]),
|
|
inputmode: {
|
|
type: definePropType(String),
|
|
default: void 0
|
|
},
|
|
align: {
|
|
type: definePropType(String),
|
|
default: "center"
|
|
},
|
|
disabledScientific: Boolean
|
|
});
|
|
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-number.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_148 = ["aria-label"];
|
|
var _hoisted_225 = ["aria-label"];
|
|
var input_number_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElInputNumber",
|
|
__name: "input-number",
|
|
props: inputNumberProps,
|
|
emits: inputNumberEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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;
|
|
if (!snum.replace(".", "").split("")[pointPos + pre])
|
|
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;
|
|
if (val >= Number.MAX_SAFE_INTEGER && coefficient === 1) {
|
|
debugWarn("InputNumber", "The value has reached the maximum safe integer limit.");
|
|
return val;
|
|
} else if (val <= Number.MIN_SAFE_INTEGER && coefficient === -1) {
|
|
debugWarn("InputNumber", "The value has reached the minimum safe integer limit.");
|
|
return val;
|
|
}
|
|
return toPrecision(val + props2.step * coefficient);
|
|
};
|
|
const handleKeydown = (event) => {
|
|
const code = getEventCode(event);
|
|
const key = getEventKey(event);
|
|
if (props2.disabledScientific && ["e", "E"].includes(key)) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
switch (code) {
|
|
case EVENT_CODE.up:
|
|
event.preventDefault();
|
|
increase();
|
|
break;
|
|
case EVENT_CODE.down:
|
|
event.preventDefault();
|
|
decrease();
|
|
break;
|
|
}
|
|
};
|
|
const increase = () => {
|
|
if (props2.readonly || inputNumberDisabled.value || maxDisabled.value)
|
|
return;
|
|
setCurrentValue(ensurePrecision(Number(displayValue.value) || 0));
|
|
emit(INPUT_EVENT, data.currentValue);
|
|
setCurrentValueToModelValue();
|
|
};
|
|
const decrease = () => {
|
|
if (props2.readonly || inputNumberDisabled.value || minDisabled.value)
|
|
return;
|
|
setCurrentValue(ensurePrecision(Number(displayValue.value) || 0, -1));
|
|
emit(INPUT_EVENT, data.currentValue);
|
|
setCurrentValueToModelValue();
|
|
};
|
|
const verifyValue = (value, update2) => {
|
|
const { max: max4, min: min4, step: step2, 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(toPrecision(newVal / step2)) * step2, 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 _a;
|
|
const oldVal = data.currentValue;
|
|
const newVal = verifyValue(value);
|
|
if (!emitChange) {
|
|
emit(UPDATE_MODEL_EVENT, newVal);
|
|
return;
|
|
}
|
|
data.userInput = null;
|
|
if (oldVal === newVal && value)
|
|
return;
|
|
emit(UPDATE_MODEL_EVENT, newVal);
|
|
if (oldVal !== newVal)
|
|
emit(CHANGE_EVENT, newVal, oldVal);
|
|
if (props2.validateEvent)
|
|
(_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.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 _a, _b;
|
|
(_b = (_a = input.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
|
|
};
|
|
const blur = () => {
|
|
var _a, _b;
|
|
(_b = (_a = input.value) == null ? void 0 : _a.blur) == null ? void 0 : _b.call(_a);
|
|
};
|
|
const handleFocus = (event) => {
|
|
emit("focus", event);
|
|
};
|
|
const handleBlur = (event) => {
|
|
var _a, _b;
|
|
data.userInput = null;
|
|
if (data.currentValue === null && ((_a = input.value) == null ? void 0 : _a.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 });
|
|
watch(() => props2.precision, () => {
|
|
data.currentValue = verifyValue(props2.modelValue);
|
|
});
|
|
onMounted(() => {
|
|
var _a;
|
|
const { min: min4, max: max4, modelValue } = props2;
|
|
const innerInput = (_a = input.value) == null ? void 0 : _a.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 _a, _b, _c;
|
|
(_c = (_a = input.value) == null ? void 0 : _a.input) == null ? void 0 : _c.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", !__props.controls),
|
|
unref(ns).is("controls-right", controlsAtRight.value),
|
|
unref(ns).is(__props.align, !!__props.align)
|
|
]),
|
|
onDragstart: _cache[0] || (_cache[0] = withModifiers(() => {
|
|
}, ["prevent"]))
|
|
}, [
|
|
__props.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", minDisabled.value)]),
|
|
onKeydown: withKeys(decrease, ["enter"])
|
|
}, [renderSlot(_ctx.$slots, "decrease-icon", {}, () => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [controlsAtRight.value ? (openBlock(), createBlock(unref(arrow_down_default), { key: 0 })) : (openBlock(), createBlock(unref(minus_default), { key: 1 }))]),
|
|
_: 1
|
|
})])], 42, _hoisted_148)), [[unref(vRepeatClick), decrease]]) : createCommentVNode("v-if", true),
|
|
__props.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", maxDisabled.value)]),
|
|
onKeydown: withKeys(increase, ["enter"])
|
|
}, [renderSlot(_ctx.$slots, "increase-icon", {}, () => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [controlsAtRight.value ? (openBlock(), createBlock(unref(arrow_up_default), { key: 0 })) : (openBlock(), createBlock(unref(plus_default), { key: 1 }))]),
|
|
_: 1
|
|
})])], 42, _hoisted_225)), [[unref(vRepeatClick), increase]]) : createCommentVNode("v-if", true),
|
|
createVNode(unref(ElInput), {
|
|
id: __props.id,
|
|
ref_key: "input",
|
|
ref: input,
|
|
type: "number",
|
|
step: __props.step,
|
|
"model-value": displayValue.value,
|
|
placeholder: __props.placeholder,
|
|
readonly: __props.readonly,
|
|
disabled: unref(inputNumberDisabled),
|
|
size: unref(inputNumberSize),
|
|
max: __props.max,
|
|
min: __props.min,
|
|
name: __props.name,
|
|
"aria-label": __props.ariaLabel,
|
|
"validate-event": false,
|
|
inputmode: __props.inputmode,
|
|
onKeydown: handleKeydown,
|
|
onBlur: handleBlur,
|
|
onFocus: handleFocus,
|
|
onInput: handleInput,
|
|
onChange: handleInputChange
|
|
}, createSlots({ _: 2 }, [_ctx.$slots.prefix ? {
|
|
name: "prefix",
|
|
fn: withCtx(() => [renderSlot(_ctx.$slots, "prefix")]),
|
|
key: "0"
|
|
} : void 0, _ctx.$slots.suffix ? {
|
|
name: "suffix",
|
|
fn: withCtx(() => [renderSlot(_ctx.$slots, "suffix")]),
|
|
key: "1"
|
|
} : void 0]), 1032, [
|
|
"id",
|
|
"step",
|
|
"model-value",
|
|
"placeholder",
|
|
"readonly",
|
|
"disabled",
|
|
"size",
|
|
"max",
|
|
"min",
|
|
"name",
|
|
"aria-label",
|
|
"inputmode"
|
|
])
|
|
], 34);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/input-number/src/input-number2.mjs
|
|
var input_number_default = input_number_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/input-number/index.mjs
|
|
var ElInputNumber = withInstall(input_number_default);
|
|
|
|
// 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,
|
|
effect: {
|
|
type: definePropType(String),
|
|
default: "light"
|
|
},
|
|
trigger: {
|
|
type: definePropType(String),
|
|
default: EVENT_CODE.enter
|
|
},
|
|
draggable: Boolean,
|
|
delimiter: {
|
|
type: [String, RegExp],
|
|
default: ""
|
|
},
|
|
size: useSizeProp,
|
|
clearable: Boolean,
|
|
clearIcon: {
|
|
type: iconPropType,
|
|
default: circle_close_default
|
|
},
|
|
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: definePropType(String),
|
|
default: "off"
|
|
},
|
|
saveOnBlur: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
collapseTags: Boolean,
|
|
collapseTagsTooltip: Boolean,
|
|
maxCollapseTags: {
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
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) || isArray(value),
|
|
"remove-tag": (value, index) => isString(value) && isNumber2(index),
|
|
"drag-tag": (oldIndex, newIndex, value) => isNumber2(oldIndex) && isNumber2(newIndex) && isString(value),
|
|
focus: (evt) => evt instanceof FocusEvent,
|
|
blur: (evt) => evt instanceof FocusEvent,
|
|
clear: () => true
|
|
};
|
|
|
|
// 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-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-input-tag.mjs
|
|
function useInputTag({ props: props2, emit, formItem }) {
|
|
const disabled = useFormDisabled();
|
|
const size3 = useFormSize();
|
|
const inputRef = shallowRef();
|
|
const inputValue = ref();
|
|
const tagTooltipRef = ref();
|
|
const tagSize = computed(() => {
|
|
return ["small"].includes(size3.value) ? "small" : "default";
|
|
});
|
|
const placeholder = computed(() => {
|
|
var _a;
|
|
return ((_a = props2.modelValue) == null ? void 0 : _a.length) ? void 0 : props2.placeholder;
|
|
});
|
|
const closable = computed(() => !(props2.readonly || disabled.value));
|
|
const inputLimit = computed(() => {
|
|
var _a, _b;
|
|
return isUndefined2(props2.max) ? false : ((_b = (_a = props2.modelValue) == null ? void 0 : _a.length) != null ? _b : 0) >= props2.max;
|
|
});
|
|
const showTagList = computed(() => {
|
|
var _a;
|
|
return props2.collapseTags ? (_a = props2.modelValue) == null ? void 0 : _a.slice(0, props2.maxCollapseTags) : props2.modelValue;
|
|
});
|
|
const collapseTagList = computed(() => {
|
|
var _a;
|
|
return props2.collapseTags ? (_a = props2.modelValue) == null ? void 0 : _a.slice(props2.maxCollapseTags) : [];
|
|
});
|
|
const addTagsEmit = (value) => {
|
|
var _a;
|
|
const list = [...(_a = props2.modelValue) != null ? _a : [], ...castArray_default(value)];
|
|
emit(UPDATE_MODEL_EVENT, list);
|
|
emit(CHANGE_EVENT, list);
|
|
emit("add-tag", value);
|
|
inputValue.value = void 0;
|
|
};
|
|
const getDelimitedTags = (input) => {
|
|
var _a, _b;
|
|
const parts = input.split(props2.delimiter);
|
|
const tags = parts.length > 1 ? parts.map((val) => val.trim()).filter(Boolean) : [];
|
|
if (props2.max) {
|
|
const maxInsert = props2.max - ((_b = (_a = props2.modelValue) == null ? void 0 : _a.length) != null ? _b : 0);
|
|
tags.splice(maxInsert);
|
|
}
|
|
return tags.length === 1 ? tags[0] : tags;
|
|
};
|
|
const handlePaste = (event) => {
|
|
var _a;
|
|
const pasted = (_a = event.clipboardData) == null ? void 0 : _a.getData("text");
|
|
if (props2.readonly || inputLimit.value || !props2.delimiter || !pasted)
|
|
return;
|
|
const { selectionStart = 0, selectionEnd = 0, value } = event.target;
|
|
const nextValue = value.slice(0, selectionStart) + pasted + value.slice(selectionEnd);
|
|
const tags = getDelimitedTags(nextValue);
|
|
if (tags.length) {
|
|
addTagsEmit(tags);
|
|
emit(INPUT_EVENT, nextValue);
|
|
event.preventDefault();
|
|
}
|
|
};
|
|
const handleInput = (event) => {
|
|
if (inputLimit.value) {
|
|
inputValue.value = void 0;
|
|
return;
|
|
}
|
|
if (isComposing.value)
|
|
return;
|
|
if (props2.delimiter && inputValue.value) {
|
|
const tags = getDelimitedTags(inputValue.value);
|
|
if (tags.length)
|
|
addTagsEmit(tags);
|
|
}
|
|
emit(INPUT_EVENT, event.target.value);
|
|
};
|
|
const handleKeydown = (event) => {
|
|
var _a;
|
|
if (isComposing.value)
|
|
return;
|
|
switch (getEventCode(event)) {
|
|
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 && ((_a = props2.modelValue) == null ? void 0 : _a.length)) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
handleRemoveTag(props2.modelValue.length - 1);
|
|
}
|
|
break;
|
|
}
|
|
};
|
|
const handleKeyup = (event) => {
|
|
if (isComposing.value || !isAndroid())
|
|
return;
|
|
switch (getEventCode(event)) {
|
|
case EVENT_CODE.space:
|
|
if (props2.trigger === EVENT_CODE.space) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
handleAddTag();
|
|
}
|
|
break;
|
|
}
|
|
};
|
|
const handleAddTag = () => {
|
|
var _a;
|
|
const value = (_a = inputValue.value) == null ? void 0 : _a.trim();
|
|
if (!value || inputLimit.value)
|
|
return;
|
|
addTagsEmit(value);
|
|
};
|
|
const handleRemoveTag = (index) => {
|
|
var _a;
|
|
const value = ((_a = props2.modelValue) != null ? _a : []).slice();
|
|
const [item] = value.splice(index, 1);
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emit(CHANGE_EVENT, value);
|
|
emit("remove-tag", item, index);
|
|
};
|
|
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 _a;
|
|
const value = ((_a = props2.modelValue) != null ? _a : []).slice();
|
|
const [draggedItem] = value.splice(draggingIndex, 1);
|
|
const step2 = dropIndex > draggingIndex && type4 === "before" ? -1 : dropIndex < draggingIndex && type4 === "after" ? 1 : 0;
|
|
value.splice(dropIndex + step2, 0, draggedItem);
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emit(CHANGE_EVENT, value);
|
|
emit("drag-tag", draggingIndex, dropIndex + step2, draggedItem);
|
|
};
|
|
const focus = () => {
|
|
var _a;
|
|
(_a = inputRef.value) == null ? void 0 : _a.focus();
|
|
};
|
|
const blur = () => {
|
|
var _a;
|
|
(_a = inputRef.value) == null ? void 0 : _a.blur();
|
|
};
|
|
const { wrapperRef, isFocused } = useFocusController(inputRef, {
|
|
disabled,
|
|
beforeBlur(event) {
|
|
var _a;
|
|
return (_a = tagTooltipRef.value) == null ? void 0 : _a.isFocusInsideContent(event);
|
|
},
|
|
afterBlur() {
|
|
var _a;
|
|
if (props2.saveOnBlur)
|
|
handleAddTag();
|
|
else
|
|
inputValue.value = void 0;
|
|
if (props2.validateEvent)
|
|
(_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "blur").catch((err) => debugWarn(err));
|
|
}
|
|
});
|
|
const { isComposing, handleCompositionStart, handleCompositionUpdate, handleCompositionEnd } = useComposition({ afterComposition: handleInput });
|
|
watch(() => props2.modelValue, () => {
|
|
var _a;
|
|
if (props2.validateEvent)
|
|
(_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, CHANGE_EVENT).catch((err) => debugWarn(err));
|
|
});
|
|
return {
|
|
inputRef,
|
|
wrapperRef,
|
|
tagTooltipRef,
|
|
isFocused,
|
|
isComposing,
|
|
inputValue,
|
|
size: size3,
|
|
tagSize,
|
|
placeholder,
|
|
closable,
|
|
disabled,
|
|
inputLimit,
|
|
showTagList,
|
|
collapseTagList,
|
|
handleDragged,
|
|
handlePaste,
|
|
handleInput,
|
|
handleKeydown,
|
|
handleKeyup,
|
|
handleAddTag,
|
|
handleRemoveTag,
|
|
handleClear,
|
|
handleCompositionStart,
|
|
handleCompositionUpdate,
|
|
handleCompositionEnd,
|
|
focus,
|
|
blur
|
|
};
|
|
}
|
|
|
|
// 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 collapseItemRef = ref();
|
|
const innerRef = ref();
|
|
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 _a, _b;
|
|
return [
|
|
ns.e("inner"),
|
|
ns.is("draggable", props2.draggable),
|
|
ns.is("left-space", !((_a = props2.modelValue) == null ? void 0 : _a.length) && !slots.prefix),
|
|
ns.is("right-space", !((_b = props2.modelValue) == null ? void 0 : _b.length) && !showSuffix.value)
|
|
];
|
|
});
|
|
const showClear = computed(() => {
|
|
var _a;
|
|
return props2.clearable && !disabled.value && !props2.readonly && (((_a = props2.modelValue) == null ? void 0 : _a.length) || inputValue.value) && (isFocused.value || hovering.value);
|
|
});
|
|
const showSuffix = computed(() => {
|
|
return slots.suffix || showClear.value || validateState.value && validateIcon.value && needStatusIcon.value;
|
|
});
|
|
const states = reactive({
|
|
innerWidth: 0,
|
|
collapseItemWidth: 0
|
|
});
|
|
const getGapWidth = () => {
|
|
if (!innerRef.value)
|
|
return 0;
|
|
const style = window.getComputedStyle(innerRef.value);
|
|
return Number.parseFloat(style.gap || "6px");
|
|
};
|
|
const resetInnerWidth = () => {
|
|
states.innerWidth = Number.parseFloat(window.getComputedStyle(innerRef.value).width);
|
|
};
|
|
const resetCollapseItemWidth = () => {
|
|
states.collapseItemWidth = collapseItemRef.value.getBoundingClientRect().width;
|
|
};
|
|
const tagStyle = computed(() => {
|
|
if (!props2.collapseTags)
|
|
return {};
|
|
const gapWidth = getGapWidth();
|
|
const inputSlotWidth = gapWidth + MINIMUM_INPUT_WIDTH;
|
|
const maxWidth = collapseItemRef.value && props2.maxCollapseTags === 1 ? states.innerWidth - states.collapseItemWidth - gapWidth - inputSlotWidth : states.innerWidth - inputSlotWidth;
|
|
return { maxWidth: `${Math.max(maxWidth, 0)}px` };
|
|
});
|
|
useResizeObserver(innerRef, resetInnerWidth);
|
|
useResizeObserver(collapseItemRef, resetCollapseItemWidth);
|
|
return {
|
|
ns,
|
|
nsInput,
|
|
containerKls,
|
|
containerStyle,
|
|
innerKls,
|
|
showClear,
|
|
showSuffix,
|
|
tagStyle,
|
|
collapseItemRef,
|
|
innerRef
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/input-tag/src/input-tag.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_149 = [
|
|
"id",
|
|
"minlength",
|
|
"maxlength",
|
|
"disabled",
|
|
"readonly",
|
|
"autocomplete",
|
|
"tabindex",
|
|
"placeholder",
|
|
"autofocus",
|
|
"ariaLabel"
|
|
];
|
|
var _hoisted_226 = ["textContent"];
|
|
var input_tag_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElInputTag",
|
|
inheritAttrs: false,
|
|
__name: "input-tag",
|
|
props: inputTagProps,
|
|
emits: inputTagEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const attrs = useAttrs2();
|
|
const slots = useSlots();
|
|
const { form, formItem } = useFormItem();
|
|
const { inputId } = useFormItemInputId(props2, { formItemContext: formItem });
|
|
const needStatusIcon = computed(() => {
|
|
var _a;
|
|
return (_a = form == null ? void 0 : form.statusIcon) != null ? _a : false;
|
|
});
|
|
const validateState = computed(() => (formItem == null ? void 0 : formItem.validateState) || "");
|
|
const validateIcon = computed(() => {
|
|
return validateState.value && ValidateComponentsMap[validateState.value];
|
|
});
|
|
const { inputRef, wrapperRef, tagTooltipRef, isFocused, inputValue, size: size3, tagSize, placeholder, closable, disabled, showTagList, collapseTagList, handleDragged, handlePaste, handleInput, handleKeydown, handleKeyup, 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, tagStyle, collapseItemRef, innerRef } = 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: _cache[9] || (_cache[9] = (...args) => unref(handleMouseEnter) && unref(handleMouseEnter)(...args)),
|
|
onMouseleave: _cache[10] || (_cache[10] = (...args) => unref(handleMouseLeave) && unref(handleMouseLeave)(...args))
|
|
}, [
|
|
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", {
|
|
ref_key: "innerRef",
|
|
ref: innerRef,
|
|
class: normalizeClass(unref(innerKls))
|
|
}, [
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(showTagList), (item, index) => {
|
|
return openBlock(), createBlock(unref(ElTag), {
|
|
key: index,
|
|
size: unref(tagSize),
|
|
closable: unref(closable),
|
|
type: __props.tagType,
|
|
effect: __props.tagEffect,
|
|
draggable: unref(closable) && __props.draggable,
|
|
style: normalizeStyle(unref(tagStyle)),
|
|
"disable-transitions": "",
|
|
onClose: ($event) => unref(handleRemoveTag)(index),
|
|
onDragstart: (event) => unref(handleDragStart)(event, index),
|
|
onDragover: (event) => unref(handleDragOver)(event, index),
|
|
onDragend: unref(handleDragEnd),
|
|
onDrop: _cache[0] || (_cache[0] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}, {
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "tag", {
|
|
value: item,
|
|
index
|
|
}, () => [createTextVNode(toDisplayString(item), 1)])]),
|
|
_: 2
|
|
}, 1032, [
|
|
"size",
|
|
"closable",
|
|
"type",
|
|
"effect",
|
|
"draggable",
|
|
"style",
|
|
"onClose",
|
|
"onDragstart",
|
|
"onDragover",
|
|
"onDragend"
|
|
]);
|
|
}), 128)),
|
|
__props.collapseTags && __props.modelValue && __props.modelValue.length > __props.maxCollapseTags ? (openBlock(), createBlock(unref(ElTooltip), {
|
|
key: 0,
|
|
ref_key: "tagTooltipRef",
|
|
ref: tagTooltipRef,
|
|
disabled: !__props.collapseTagsTooltip,
|
|
"fallback-placements": [
|
|
"bottom",
|
|
"top",
|
|
"right",
|
|
"left"
|
|
],
|
|
effect: __props.effect,
|
|
placement: "bottom"
|
|
}, {
|
|
default: withCtx(() => [createBaseVNode("div", {
|
|
ref_key: "collapseItemRef",
|
|
ref: collapseItemRef,
|
|
class: normalizeClass(unref(ns).e("collapse-tag"))
|
|
}, [createVNode(unref(ElTag), {
|
|
closable: false,
|
|
size: unref(tagSize),
|
|
type: __props.tagType,
|
|
effect: __props.tagEffect,
|
|
"disable-transitions": ""
|
|
}, {
|
|
default: withCtx(() => [createTextVNode(" + " + toDisplayString(__props.modelValue.length - __props.maxCollapseTags), 1)]),
|
|
_: 1
|
|
}, 8, [
|
|
"size",
|
|
"type",
|
|
"effect"
|
|
])], 2)]),
|
|
content: withCtx(() => [createBaseVNode("div", { class: normalizeClass(unref(ns).e("input-tag-list")) }, [(openBlock(true), createElementBlock(Fragment, null, renderList(unref(collapseTagList), (item, index) => {
|
|
return openBlock(), createBlock(unref(ElTag), {
|
|
key: index,
|
|
size: unref(tagSize),
|
|
closable: unref(closable),
|
|
type: __props.tagType,
|
|
effect: __props.tagEffect,
|
|
"disable-transitions": "",
|
|
onClose: ($event) => unref(handleRemoveTag)(index + __props.maxCollapseTags)
|
|
}, {
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "tag", {
|
|
value: item,
|
|
index: index + __props.maxCollapseTags
|
|
}, () => [createTextVNode(toDisplayString(item), 1)])]),
|
|
_: 2
|
|
}, 1032, [
|
|
"size",
|
|
"closable",
|
|
"type",
|
|
"effect",
|
|
"onClose"
|
|
]);
|
|
}), 128))], 2)]),
|
|
_: 3
|
|
}, 8, ["disabled", "effect"])) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", { class: normalizeClass(unref(ns).e("input-wrapper")) }, [withDirectives(createBaseVNode("input", mergeProps({
|
|
id: unref(inputId),
|
|
ref_key: "inputRef",
|
|
ref: inputRef,
|
|
"onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => isRef(inputValue) ? inputValue.value = $event : null)
|
|
}, unref(attrs), {
|
|
type: "text",
|
|
minlength: __props.minlength,
|
|
maxlength: __props.maxlength,
|
|
disabled: unref(disabled),
|
|
readonly: __props.readonly,
|
|
autocomplete: __props.autocomplete,
|
|
tabindex: __props.tabindex,
|
|
placeholder: unref(placeholder),
|
|
autofocus: __props.autofocus,
|
|
ariaLabel: __props.ariaLabel,
|
|
class: unref(ns).e("input"),
|
|
style: unref(inputStyle),
|
|
onCompositionstart: _cache[2] || (_cache[2] = (...args) => unref(handleCompositionStart) && unref(handleCompositionStart)(...args)),
|
|
onCompositionupdate: _cache[3] || (_cache[3] = (...args) => unref(handleCompositionUpdate) && unref(handleCompositionUpdate)(...args)),
|
|
onCompositionend: _cache[4] || (_cache[4] = (...args) => unref(handleCompositionEnd) && unref(handleCompositionEnd)(...args)),
|
|
onPaste: _cache[5] || (_cache[5] = (...args) => unref(handlePaste) && unref(handlePaste)(...args)),
|
|
onInput: _cache[6] || (_cache[6] = (...args) => unref(handleInput) && unref(handleInput)(...args)),
|
|
onKeydown: _cache[7] || (_cache[7] = (...args) => unref(handleKeydown) && unref(handleKeydown)(...args)),
|
|
onKeyup: _cache[8] || (_cache[8] = (...args) => unref(handleKeyup) && unref(handleKeyup)(...args))
|
|
}), null, 16, _hoisted_149), [[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, _hoisted_226)], 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(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.clearIcon)))]),
|
|
_: 1
|
|
}, 8, [
|
|
"class",
|
|
"onMousedown",
|
|
"onClick"
|
|
])) : createCommentVNode("v-if", true),
|
|
validateState.value && validateIcon.value && needStatusIcon.value ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 1,
|
|
class: normalizeClass([
|
|
unref(nsInput).e("icon"),
|
|
unref(nsInput).e("validateIcon"),
|
|
unref(nsInput).is("loading", validateState.value === "validating")
|
|
])
|
|
}, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(validateIcon.value)))]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true)
|
|
], 2)) : createCommentVNode("v-if", true)
|
|
], 38);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/input-tag/src/input-tag2.mjs
|
|
var input_tag_default = input_tag_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/input-tag/index.mjs
|
|
var ElInputTag = withInstall(input_tag_default);
|
|
|
|
// 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/link.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_150 = ["href", "target"];
|
|
var link_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElLink",
|
|
__name: "link",
|
|
props: linkProps,
|
|
emits: linkEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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 _a, _b, _c;
|
|
return [
|
|
ns.b(),
|
|
ns.m((_c = (_b = props2.type) != null ? _b : (_a = globalConfig2.value) == null ? void 0 : _a.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 _a, _b, _c;
|
|
if (isBoolean2(props2.underline))
|
|
return props2.underline ? "hover" : "never";
|
|
else
|
|
return (_c = (_b = props2.underline) != null ? _b : (_a = globalConfig2.value) == null ? void 0 : _a.underline) != null ? _c : "hover";
|
|
});
|
|
function handleClick(event) {
|
|
if (!props2.disabled)
|
|
emit("click", event);
|
|
}
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("a", {
|
|
class: normalizeClass(linkKls.value),
|
|
href: __props.disabled || !__props.href ? void 0 : __props.href,
|
|
target: __props.disabled || !__props.href ? void 0 : __props.target,
|
|
onClick: handleClick
|
|
}, [
|
|
__props.icon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.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, _hoisted_150);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/link/src/link2.mjs
|
|
var link_default = link_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/link/index.mjs
|
|
var ElLink = withInstall(link_default);
|
|
|
|
// node_modules/element-plus/es/components/menu/src/tokens.mjs
|
|
var MENU_INJECTION_KEY = "rootMenu";
|
|
var SUB_MENU_INJECTION_KEY = "subMenu:";
|
|
|
|
// 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;
|
|
});
|
|
return {
|
|
parentMenu: computed(() => {
|
|
let parent2 = instance.parent;
|
|
while (parent2 && !["ElMenu", "ElSubMenu"].includes(parent2.type.name))
|
|
parent2 = parent2.parent;
|
|
return parent2;
|
|
}),
|
|
indexPath
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/menu/src/use-menu-color.mjs
|
|
function useMenuColor(props2) {
|
|
return computed(() => {
|
|
const color = props2.backgroundColor;
|
|
return color ? new TinyColor(color).shade(20).toString() : "";
|
|
});
|
|
}
|
|
|
|
// 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,
|
|
popperStyle: { type: definePropType([String, Object]) },
|
|
disabled: Boolean,
|
|
teleported: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
popperOffset: Number,
|
|
expandCloseIcon: { type: iconPropType },
|
|
expandOpenIcon: { type: iconPropType },
|
|
collapseCloseIcon: { type: iconPropType },
|
|
collapseOpenIcon: { type: iconPropType }
|
|
});
|
|
var COMPONENT_NAME15 = "ElSubMenu";
|
|
var sub_menu_default = defineComponent({
|
|
name: COMPONENT_NAME15,
|
|
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(MENU_INJECTION_KEY);
|
|
if (!rootMenu)
|
|
throwError(COMPONENT_NAME15, "can not inject root menu");
|
|
const subMenu = inject(`${SUB_MENU_INJECTION_KEY}${parentMenu.value.uid}`);
|
|
if (!subMenu)
|
|
throwError(COMPONENT_NAME15, "can not inject sub menu");
|
|
const items = ref({});
|
|
const subMenus = ref({});
|
|
let timeout;
|
|
const mouseInChild = ref(false);
|
|
const verticalTitleRef = ref();
|
|
const vPopper = ref();
|
|
const isFirstLevel = computed(() => subMenu.level === 0);
|
|
const currentPlacement = computed(() => mode.value === "horizontal" && isFirstLevel.value ? "bottom-start" : "right-start");
|
|
const subMenuTitleIcon = computed(() => {
|
|
if (mode.value === "horizontal" && isFirstLevel.value || mode.value === "vertical" && !rootMenu.props.collapse) {
|
|
if (props2.expandCloseIcon && props2.expandOpenIcon)
|
|
return opened.value ? props2.expandOpenIcon : props2.expandCloseIcon;
|
|
return arrow_down_default;
|
|
} else {
|
|
if (props2.collapseCloseIcon && props2.collapseOpenIcon)
|
|
return opened.value ? props2.collapseOpenIcon : props2.collapseCloseIcon;
|
|
return arrow_right_default;
|
|
}
|
|
});
|
|
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 _a;
|
|
return (_a = props2.popperOffset) != null ? _a : rootMenu.props.popperOffset;
|
|
});
|
|
const subMenuPopperClass = computed(() => {
|
|
var _a;
|
|
return (_a = props2.popperClass) != null ? _a : rootMenu.props.popperClass;
|
|
});
|
|
const subMenuPopperStyle = computed(() => {
|
|
var _a;
|
|
return (_a = props2.popperStyle) != null ? _a : rootMenu.props.popperStyle;
|
|
});
|
|
const subMenuShowTimeout = computed(() => {
|
|
var _a;
|
|
return (_a = props2.showTimeout) != null ? _a : rootMenu.props.showTimeout;
|
|
});
|
|
const subMenuHideTimeout = computed(() => {
|
|
var _a;
|
|
return (_a = props2.hideTimeout) != null ? _a : rootMenu.props.hideTimeout;
|
|
});
|
|
const doDestroy = () => {
|
|
var _a, _b, _c;
|
|
return (_c = (_b = (_a = vPopper.value) == null ? void 0 : _a.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 _a;
|
|
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)
|
|
(_a = parentMenu.value.vnode.el) == null ? void 0 : _a.dispatchEvent(new MouseEvent("mouseenter"));
|
|
if (event.type === "mouseenter" && event.target)
|
|
nextTick(() => {
|
|
focusElement(event.target, { preventScroll: true });
|
|
});
|
|
};
|
|
const handleMouseleave = (deepDispatch = false) => {
|
|
var _a;
|
|
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)
|
|
(_a = subMenu.handleMouseleave) == null ? void 0 : _a.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(`${SUB_MENU_INJECTION_KEY}${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 _a;
|
|
const titleTag = [(_a = slots.title) == null ? void 0 : _a.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,
|
|
popperStyle: subMenuPopperStyle.value,
|
|
placement: currentPlacement.value,
|
|
teleported: appendToBody.value,
|
|
fallbackPlacements: fallbackPlacements.value,
|
|
transition: menuTransitionName.value,
|
|
gpuAcceleration: false
|
|
}, {
|
|
content: () => {
|
|
var _a2;
|
|
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
|
|
}, [(_a2 = slots.default) == null ? void 0 : _a2.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 _a2;
|
|
return withDirectives(h("ul", {
|
|
role: "menu",
|
|
class: [nsMenu.b(), nsMenu.m("inline")],
|
|
style: ulStyle.value
|
|
}, [(_a2 = slots.default) == null ? void 0 : _a2.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 SubMenu = 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) => {
|
|
const code = getEventCode(event);
|
|
let prevDef = false;
|
|
switch (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 SubMenu(this, menuChild);
|
|
this.addListeners();
|
|
}
|
|
addListeners() {
|
|
this.domNode.addEventListener("keydown", (event) => {
|
|
const code = getEventCode(event);
|
|
let prevDef = false;
|
|
switch (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.vue_vue_type_script_setup_true_lang.mjs
|
|
var menu_collapse_transition_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElMenuCollapseTransition",
|
|
__name: "menu-collapse-transition",
|
|
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" }, listeners), {
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
|
|
_: 3
|
|
}, 16);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/menu/src/menu-collapse-transition.mjs
|
|
var menu_collapse_transition_default = menu_collapse_transition_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// 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,
|
|
popperStyle: { type: definePropType([String, Object]) },
|
|
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 DEFAULT_MORE_ITEM_WIDTH = 64;
|
|
var menu_default2 = 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 subMenu = ref();
|
|
const nsMenu = useNamespace("menu");
|
|
const nsSubMenu = useNamespace("sub-menu");
|
|
let moreItemWidth = DEFAULT_MORE_ITEM_WIDTH;
|
|
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;
|
|
activeItem.indexPath.forEach((index) => {
|
|
const subMenu2 = subMenus.value[index];
|
|
subMenu2 && openMenu(index, subMenu2.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 }) => {
|
|
openedMenus.value.includes(index) ? 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 _a, _b;
|
|
const itemsInData = items.value;
|
|
activeIndex.value = (_b = (_a = itemsInData[val] || activeIndex.value && itemsInData[activeIndex.value] || itemsInData[props2.defaultActive]) == null ? void 0 : _a.index) != null ? _b : 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 = () => {
|
|
if (!menu.value)
|
|
return -1;
|
|
const items2 = Array.from(menu.value.childNodes).filter((item) => item.nodeName !== "#comment" && (item.nodeName !== "#text" || item.nodeValue));
|
|
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) => {
|
|
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 timer;
|
|
return () => {
|
|
timer && clearTimeout(timer);
|
|
timer = setTimeout(() => {
|
|
fn2();
|
|
}, wait);
|
|
};
|
|
};
|
|
let isFirstTimeRender = true;
|
|
const handleResize = () => {
|
|
const el = unrefElement(subMenu);
|
|
if (el)
|
|
moreItemWidth = calcMenuItemWidth(el) || DEFAULT_MORE_ITEM_WIDTH;
|
|
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(MENU_INJECTION_KEY, reactive({
|
|
props: props2,
|
|
openedMenus,
|
|
items,
|
|
subMenus,
|
|
activeIndex,
|
|
isMenuPopup,
|
|
addMenuItem,
|
|
removeMenuItem,
|
|
addSubMenu,
|
|
removeSubMenu,
|
|
openMenu,
|
|
closeMenu,
|
|
handleMenuItemClick,
|
|
handleSubMenuClick
|
|
}));
|
|
provide(`${SUB_MENU_INJECTION_KEY}${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 _a, _b;
|
|
let slot = (_b = (_a = slots.default) == null ? void 0 : _a.call(slots)) != null ? _b : [];
|
|
const vShowMore = [];
|
|
if (props2.mode === "horizontal" && menu.value) {
|
|
const originalSlot = flattedChildren(slot).filter((vnode) => {
|
|
return (vnode == null ? void 0 : vnode.shapeFlag) !== 8;
|
|
});
|
|
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(sub_menu_default, {
|
|
ref: 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(menu_collapse_transition_default, () => 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-item.vue_vue_type_script_setup_true_lang.mjs
|
|
var COMPONENT_NAME16 = "ElMenuItem";
|
|
var menu_item_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: COMPONENT_NAME16,
|
|
__name: "menu-item",
|
|
props: menuItemProps,
|
|
emits: menuItemEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
isPropAbsent(props2.index) && debugWarn(COMPONENT_NAME16, 'Missing required prop: "index"');
|
|
const instance = getCurrentInstance();
|
|
const rootMenu = inject(MENU_INJECTION_KEY);
|
|
const nsMenu = useNamespace("menu");
|
|
const nsMenuItem = useNamespace("menu-item");
|
|
if (!rootMenu)
|
|
throwError(COMPONENT_NAME16, "can not inject root menu");
|
|
const { parentMenu, indexPath } = useMenu(instance, toRef(props2, "index"));
|
|
const subMenu = inject(`${SUB_MENU_INJECTION_KEY}${parentMenu.value.uid}`);
|
|
if (!subMenu)
|
|
throwError(COMPONENT_NAME16, "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", active.value),
|
|
unref(nsMenuItem).is("disabled", __props.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"],
|
|
"popper-class": unref(rootMenu).props.popperClass,
|
|
"popper-style": unref(rootMenu).props.popperStyle,
|
|
persistent: unref(rootMenu).props.persistent,
|
|
"focus-on-target": ""
|
|
}, {
|
|
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",
|
|
"popper-class",
|
|
"popper-style",
|
|
"persistent"
|
|
])) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [renderSlot(_ctx.$slots, "default"), renderSlot(_ctx.$slots, "title")], 64))], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/menu/src/menu-item2.mjs
|
|
var menu_item_default = menu_item_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/menu/src/menu-item-group.vue_vue_type_script_setup_true_lang.mjs
|
|
var menu_item_group_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElMenuItemGroup",
|
|
__name: "menu-item-group",
|
|
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(__props.title), 1)], 64)) : renderSlot(_ctx.$slots, "title", { key: 1 })], 2), createBaseVNode("ul", null, [renderSlot(_ctx.$slots, "default")])], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/menu/src/menu-item-group2.mjs
|
|
var menu_item_group_default = menu_item_group_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/menu/index.mjs
|
|
var ElMenu = withInstall(menu_default2, {
|
|
MenuItem: menu_item_default,
|
|
MenuItemGroup: menu_item_group_default,
|
|
SubMenu: sub_menu_default
|
|
});
|
|
var ElMenuItem = withNoopInstall(menu_item_default);
|
|
var ElMenuItemGroup = withNoopInstall(menu_item_group_default);
|
|
var ElSubMenu = withNoopInstall(sub_menu_default);
|
|
|
|
// 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-header.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_151 = ["aria-label"];
|
|
var page_header_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElPageHeader",
|
|
__name: "page-header",
|
|
props: pageHeaderProps,
|
|
emits: pageHeaderEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const emit = __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).is("contentful", !!_ctx.$slots.default),
|
|
{
|
|
[unref(ns).m("has-breadcrumb")]: !!_ctx.$slots.breadcrumb,
|
|
[unref(ns).m("has-extra")]: !!_ctx.$slots.extra
|
|
}
|
|
]) }, [
|
|
_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
|
|
}, [__props.icon || _ctx.$slots.icon ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
"aria-label": __props.title || unref(t)("el.pageHeader.title"),
|
|
class: normalizeClass(unref(ns).e("icon"))
|
|
}, [renderSlot(_ctx.$slots, "icon", {}, () => [__props.icon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.icon)))]),
|
|
_: 1
|
|
})) : createCommentVNode("v-if", true)])], 10, _hoisted_151)) : createCommentVNode("v-if", true), createBaseVNode("div", { class: normalizeClass(unref(ns).e("title")) }, [renderSlot(_ctx.$slots, "title", {}, () => [createTextVNode(toDisplayString(__props.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(__props.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);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/page-header/src/page-header2.mjs
|
|
var page_header_default = page_header_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/page-header/index.mjs
|
|
var ElPageHeader = withInstall(page_header_default);
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/constants.mjs
|
|
var elPaginationKey = Symbol("elPaginationKey");
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/prev.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.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_153 = [
|
|
"disabled",
|
|
"aria-label",
|
|
"aria-disabled"
|
|
];
|
|
var _hoisted_227 = { key: 0 };
|
|
var prev_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElPaginationPrev",
|
|
__name: "prev",
|
|
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: internalDisabled.value,
|
|
"aria-label": _ctx.prevText || unref(t)("el.pagination.prev"),
|
|
"aria-disabled": internalDisabled.value,
|
|
onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("click", $event))
|
|
}, [_ctx.prevText ? (openBlock(), createElementBlock("span", _hoisted_227, toDisplayString(_ctx.prevText), 1)) : (openBlock(), createBlock(unref(ElIcon), { key: 1 }, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(_ctx.prevIcon)))]),
|
|
_: 1
|
|
}))], 8, _hoisted_153);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/prev2.mjs
|
|
var prev_default = prev_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// 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/next.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_154 = [
|
|
"disabled",
|
|
"aria-label",
|
|
"aria-disabled"
|
|
];
|
|
var _hoisted_228 = { key: 0 };
|
|
var next_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElPaginationNext",
|
|
__name: "next",
|
|
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: internalDisabled.value,
|
|
"aria-label": _ctx.nextText || unref(t)("el.pagination.next"),
|
|
"aria-disabled": internalDisabled.value,
|
|
onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("click", $event))
|
|
}, [_ctx.nextText ? (openBlock(), createElementBlock("span", _hoisted_228, toDisplayString(_ctx.nextText), 1)) : (openBlock(), createBlock(unref(ElIcon), { key: 1 }, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(_ctx.nextIcon)))]),
|
|
_: 1
|
|
}))], 8, _hoisted_154);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/next2.mjs
|
|
var next_default2 = next_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// 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 },
|
|
popperStyle: { type: definePropType([String, Object]) },
|
|
disabled: Boolean,
|
|
teleported: Boolean,
|
|
size: {
|
|
type: String,
|
|
values: componentSizes
|
|
},
|
|
appendSizeTo: String
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/sizes.vue_vue_type_script_setup_true_lang.mjs
|
|
var sizes_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElPaginationSizes",
|
|
__name: "sizes",
|
|
props: paginationSizesProps,
|
|
emits: ["page-size-change"],
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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))
|
|
emit("page-size-change", newVal.includes(props2.pageSize) ? props2.pageSize : props2.pageSizes[0]);
|
|
});
|
|
watch(() => props2.pageSize, (newVal) => {
|
|
innerPageSize.value = newVal;
|
|
});
|
|
const innerPageSizes = computed(() => props2.pageSizes);
|
|
function handleChange(val) {
|
|
var _a;
|
|
if (val !== innerPageSize.value) {
|
|
innerPageSize.value = val;
|
|
(_a = pagination.handleSizeChange) == null ? void 0 : _a.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,
|
|
"popper-style": _ctx.popperStyle,
|
|
size: _ctx.size,
|
|
teleported: _ctx.teleported,
|
|
"validate-event": false,
|
|
"append-to": _ctx.appendSizeTo,
|
|
onChange: handleChange
|
|
}, {
|
|
default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(innerPageSizes.value, (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",
|
|
"popper-style",
|
|
"size",
|
|
"teleported",
|
|
"append-to"
|
|
])], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/sizes2.mjs
|
|
var sizes_default = sizes_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// 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/jumper.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_155 = ["disabled"];
|
|
var jumper_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElPaginationJumper",
|
|
__name: "jumper",
|
|
props: paginationJumperProps,
|
|
setup(__props) {
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("pagination");
|
|
const { pageCount, disabled, currentPage, changeEvent } = usePagination();
|
|
const userInput = ref();
|
|
const innerValue = computed(() => {
|
|
var _a;
|
|
return (_a = userInput.value) != null ? _a : 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": innerValue.value,
|
|
"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, _hoisted_155);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/jumper2.mjs
|
|
var jumper_default = jumper_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// 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/total.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_156 = ["disabled"];
|
|
var total_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElPaginationTotal",
|
|
__name: "total",
|
|
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, _hoisted_156);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/total2.mjs
|
|
var total_default = total_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// 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/pager.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_157 = [
|
|
"aria-current",
|
|
"aria-label",
|
|
"tabindex"
|
|
];
|
|
var _hoisted_229 = ["tabindex", "aria-label"];
|
|
var _hoisted_312 = [
|
|
"aria-current",
|
|
"aria-label",
|
|
"tabindex"
|
|
];
|
|
var _hoisted_48 = ["tabindex", "aria-label"];
|
|
var _hoisted_57 = [
|
|
"aria-current",
|
|
"aria-label",
|
|
"tabindex"
|
|
];
|
|
var pager_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElPaginationPager",
|
|
__name: "pager",
|
|
props: paginationPagerProps,
|
|
emits: [CHANGE_EVENT],
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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);
|
|
watch(() => [
|
|
props2.pageCount,
|
|
props2.pagerCount,
|
|
props2.currentPage
|
|
], ([pageCount, pagerCount, currentPage]) => {
|
|
const halfPagerCount = (pagerCount - 1) / 2;
|
|
let showPrev = false;
|
|
let showNext = false;
|
|
if (pageCount > pagerCount) {
|
|
showPrev = currentPage > pagerCount - halfPagerCount;
|
|
showNext = currentPage < pageCount - halfPagerCount;
|
|
}
|
|
quickPrevHover.value && (quickPrevHover.value = showPrev);
|
|
quickNextHover.value && (quickNextHover.value = showNext);
|
|
showPrevMore.value = showPrev;
|
|
showNextMore.value = showNext;
|
|
}, { immediate: 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: tabindex.value
|
|
}, " 1 ", 10, _hoisted_157)) : createCommentVNode("v-if", true),
|
|
showPrevMore.value ? (openBlock(), createElementBlock("li", {
|
|
key: 1,
|
|
class: normalizeClass(prevMoreKls.value),
|
|
tabindex: tabindex.value,
|
|
"aria-label": unref(t)("el.pagination.prevPages", { pager: _ctx.pagerCount - 2 }),
|
|
onMouseenter: _cache[0] || (_cache[0] = ($event) => onMouseEnter(true)),
|
|
onMouseleave: _cache[1] || (_cache[1] = ($event) => quickPrevHover.value = false),
|
|
onFocus: _cache[2] || (_cache[2] = ($event) => onFocus(true)),
|
|
onBlur: _cache[3] || (_cache[3] = ($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, _hoisted_229)) : createCommentVNode("v-if", true),
|
|
(openBlock(true), createElementBlock(Fragment, null, renderList(pagers.value, (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: tabindex.value
|
|
}, toDisplayString(pager), 11, _hoisted_312);
|
|
}), 128)),
|
|
showNextMore.value ? (openBlock(), createElementBlock("li", {
|
|
key: 2,
|
|
class: normalizeClass(nextMoreKls.value),
|
|
tabindex: tabindex.value,
|
|
"aria-label": unref(t)("el.pagination.nextPages", { pager: _ctx.pagerCount - 2 }),
|
|
onMouseenter: _cache[4] || (_cache[4] = ($event) => onMouseEnter()),
|
|
onMouseleave: _cache[5] || (_cache[5] = ($event) => quickNextHover.value = false),
|
|
onFocus: _cache[6] || (_cache[6] = ($event) => onFocus()),
|
|
onBlur: _cache[7] || (_cache[7] = ($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, _hoisted_48)) : 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: tabindex.value
|
|
}, toDisplayString(_ctx.pageCount), 11, _hoisted_57)) : createCommentVNode("v-if", true)
|
|
], 34);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/pagination/src/components/pager2.mjs
|
|
var pager_default = pager_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// 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: ""
|
|
},
|
|
popperStyle: { type: definePropType([String, Object]) },
|
|
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_default = 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 _a;
|
|
return props2.small ? "small" : (_a = props2.size) != null ? _a : _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 _a, _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_default, {
|
|
disabled: props2.disabled,
|
|
currentPage: currentPageBridge.value,
|
|
prevText: props2.prevText,
|
|
prevIcon: props2.prevIcon,
|
|
onClick: prev
|
|
}),
|
|
jumper: h(jumper_default, { size: _size.value }),
|
|
pager: h(pager_default, {
|
|
currentPage: currentPageBridge.value,
|
|
pageCount: pageCountBridge.value,
|
|
pagerCount: props2.pagerCount,
|
|
onChange: handleCurrentChange2,
|
|
disabled: props2.disabled
|
|
}),
|
|
next: h(next_default2, {
|
|
disabled: props2.disabled,
|
|
currentPage: currentPageBridge.value,
|
|
pageCount: pageCountBridge.value,
|
|
nextText: props2.nextText,
|
|
nextIcon: props2.nextIcon,
|
|
onClick: next
|
|
}),
|
|
sizes: h(sizes_default, {
|
|
pageSize: pageSizeBridge.value,
|
|
pageSizes: props2.pageSizes,
|
|
popperClass: props2.popperClass,
|
|
popperStyle: props2.popperStyle,
|
|
disabled: props2.disabled,
|
|
teleported: props2.teleported,
|
|
size: _size.value,
|
|
appendSizeTo: props2.appendSizeTo
|
|
}),
|
|
slot: (_b = (_a = slots == null ? void 0 : slots.default) == null ? void 0 : _a.call(slots)) != null ? _b : null,
|
|
total: h(total_default, { 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_default);
|
|
|
|
// node_modules/element-plus/es/components/popconfirm/src/popconfirm.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: Boolean,
|
|
hideAfter: {
|
|
type: Number,
|
|
default: 200
|
|
},
|
|
effect: {
|
|
...useTooltipContentProps.effect,
|
|
default: "light"
|
|
},
|
|
teleported: useTooltipContentProps.teleported,
|
|
persistent: useTooltipContentProps.persistent,
|
|
width: {
|
|
type: [String, Number],
|
|
default: 150
|
|
},
|
|
virtualTriggering: useTooltipTriggerProps.virtualTriggering,
|
|
virtualRef: useTooltipTriggerProps.virtualRef
|
|
});
|
|
var popconfirmEmits = {
|
|
confirm: (e) => e instanceof MouseEvent,
|
|
cancel: (e) => e instanceof MouseEvent
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/popconfirm/src/popconfirm.vue_vue_type_script_setup_true_lang.mjs
|
|
var popconfirm_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElPopconfirm",
|
|
__name: "popconfirm",
|
|
props: popconfirmProps,
|
|
emits: popconfirmEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("popconfirm");
|
|
const tooltipRef = ref();
|
|
const rootRef = ref();
|
|
const popperRef = computed(() => {
|
|
var _a;
|
|
return (_a = unref(tooltipRef)) == null ? void 0 : _a.popperRef;
|
|
});
|
|
const showPopper = () => {
|
|
var _a, _b;
|
|
(_b = (_a = rootRef.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
|
|
};
|
|
const hidePopper = () => {
|
|
var _a, _b;
|
|
(_b = (_a = tooltipRef.value) == null ? void 0 : _a.onClose) == null ? void 0 : _b.call(_a);
|
|
};
|
|
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"));
|
|
__expose({
|
|
popperRef,
|
|
hide: hidePopper
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElTooltip), mergeProps({
|
|
ref_key: "tooltipRef",
|
|
ref: tooltipRef,
|
|
trigger: "click",
|
|
effect: __props.effect
|
|
}, _ctx.$attrs, {
|
|
"virtual-triggering": __props.virtualTriggering,
|
|
"virtual-ref": __props.virtualRef,
|
|
"popper-class": `${unref(ns).namespace.value}-popover`,
|
|
"popper-style": style.value,
|
|
teleported: __props.teleported,
|
|
"fallback-placements": [
|
|
"bottom",
|
|
"top",
|
|
"right",
|
|
"left"
|
|
],
|
|
"hide-after": __props.hideAfter,
|
|
persistent: __props.persistent,
|
|
loop: "",
|
|
onShow: showPopper
|
|
}), {
|
|
content: withCtx(() => [createBaseVNode("div", {
|
|
ref_key: "rootRef",
|
|
ref: rootRef,
|
|
tabindex: "-1",
|
|
class: normalizeClass(unref(ns).b())
|
|
}, [createBaseVNode("div", { class: normalizeClass(unref(ns).e("main")) }, [!__props.hideIcon && __props.icon ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("icon")),
|
|
style: normalizeStyle({ color: __props.iconColor })
|
|
}, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.icon)))]),
|
|
_: 1
|
|
}, 8, ["class", "style"])) : createCommentVNode("v-if", true), createTextVNode(" " + toDisplayString(__props.title), 1)], 2), createBaseVNode("div", { class: normalizeClass(unref(ns).e("action")) }, [renderSlot(_ctx.$slots, "actions", {
|
|
confirm,
|
|
cancel
|
|
}, () => [createVNode(unref(ElButton), {
|
|
size: "small",
|
|
type: __props.cancelButtonType === "text" ? "" : __props.cancelButtonType,
|
|
text: __props.cancelButtonType === "text",
|
|
onClick: cancel
|
|
}, {
|
|
default: withCtx(() => [createTextVNode(toDisplayString(finalCancelButtonText.value), 1)]),
|
|
_: 1
|
|
}, 8, ["type", "text"]), createVNode(unref(ElButton), {
|
|
size: "small",
|
|
type: __props.confirmButtonType === "text" ? "" : __props.confirmButtonType,
|
|
text: __props.confirmButtonType === "text",
|
|
onClick: confirm
|
|
}, {
|
|
default: withCtx(() => [createTextVNode(toDisplayString(finalConfirmButtonText.value), 1)]),
|
|
_: 1
|
|
}, 8, ["type", "text"])])], 2)], 2)]),
|
|
default: withCtx(() => [_ctx.$slots.reference ? renderSlot(_ctx.$slots, "reference", { key: 0 }) : createCommentVNode("v-if", true)]),
|
|
_: 3
|
|
}, 16, [
|
|
"effect",
|
|
"virtual-triggering",
|
|
"virtual-ref",
|
|
"popper-class",
|
|
"popper-style",
|
|
"teleported",
|
|
"hide-after",
|
|
"persistent"
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/popconfirm/src/popconfirm2.mjs
|
|
var popconfirm_default = popconfirm_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/popconfirm/index.mjs
|
|
var ElPopconfirm = withInstall(popconfirm_default);
|
|
|
|
// node_modules/element-plus/es/components/popover/src/popover.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
|
|
};
|
|
var popoverPropsDefaults = {
|
|
trigger: "hover",
|
|
triggerKeys: () => [
|
|
EVENT_CODE.enter,
|
|
EVENT_CODE.numpadEnter,
|
|
EVENT_CODE.space
|
|
],
|
|
placement: "bottom",
|
|
visible: null,
|
|
popperOptions: () => ({}),
|
|
tabindex: 0,
|
|
content: "",
|
|
popperStyle: void 0,
|
|
enterable: true,
|
|
effect: "light",
|
|
teleported: true,
|
|
width: 150,
|
|
offset: void 0,
|
|
showAfter: 0,
|
|
hideAfter: 200,
|
|
autoClose: 0,
|
|
showArrow: true,
|
|
persistent: true
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/popover/src/popover.vue_vue_type_script_setup_true_lang.mjs
|
|
var updateEventKeyRaw = `onUpdate:visible`;
|
|
var popover_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElPopover",
|
|
__name: "popover",
|
|
props: popoverProps,
|
|
emits: popoverEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const onUpdateVisible = computed(() => {
|
|
return props2[updateEventKeyRaw];
|
|
});
|
|
const ns = useNamespace("popover");
|
|
const tooltipRef = ref();
|
|
const popperRef = computed(() => {
|
|
var _a;
|
|
return (_a = unref(tooltipRef)) == null ? void 0 : _a.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 _a;
|
|
(_a = tooltipRef.value) == null ? void 0 : _a.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: __props.trigger,
|
|
"trigger-keys": __props.triggerKeys,
|
|
placement: __props.placement,
|
|
disabled: __props.disabled,
|
|
visible: __props.visible,
|
|
transition: __props.transition,
|
|
"popper-options": __props.popperOptions,
|
|
tabindex: __props.tabindex,
|
|
content: __props.content,
|
|
offset: __props.offset,
|
|
"show-after": __props.showAfter,
|
|
"hide-after": __props.hideAfter,
|
|
"auto-close": __props.autoClose,
|
|
"show-arrow": __props.showArrow,
|
|
"aria-label": __props.title,
|
|
effect: __props.effect,
|
|
enterable: __props.enterable,
|
|
"popper-class": kls.value,
|
|
"popper-style": style.value,
|
|
teleported: __props.teleported,
|
|
"append-to": __props.appendTo,
|
|
persistent: __props.persistent,
|
|
"gpu-acceleration": gpuAcceleration.value,
|
|
"onUpdate:visible": onUpdateVisible.value,
|
|
onBeforeShow: beforeEnter,
|
|
onBeforeHide: beforeLeave,
|
|
onShow: afterEnter,
|
|
onHide: afterLeave
|
|
}), {
|
|
content: withCtx(() => [__props.title ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("title")),
|
|
role: "title"
|
|
}, toDisplayString(__props.title), 3)) : createCommentVNode("v-if", true), renderSlot(_ctx.$slots, "default", { hide: hide2 }, () => [createTextVNode(toDisplayString(__props.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"
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/popover/src/popover2.mjs
|
|
var popover_default = popover_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/popover/src/directive.mjs
|
|
var attachEvents = (el, binding) => {
|
|
var _a;
|
|
const popover = (_a = binding.arg || binding.value) == null ? void 0 : _a.popperRef;
|
|
if (popover)
|
|
popover.triggerRef = el;
|
|
};
|
|
var directive_default = {
|
|
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(directive_default, VPopover);
|
|
var ElPopover = withInstall(popover_default, { 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/progress.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_158 = ["aria-valuenow"];
|
|
var _hoisted_230 = { viewBox: "0 0 100 100" };
|
|
var _hoisted_313 = [
|
|
"d",
|
|
"stroke",
|
|
"stroke-linecap",
|
|
"stroke-width"
|
|
];
|
|
var _hoisted_49 = [
|
|
"d",
|
|
"stroke",
|
|
"opacity",
|
|
"stroke-linecap",
|
|
"stroke-width"
|
|
];
|
|
var _hoisted_58 = { key: 0 };
|
|
var progress_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElProgress",
|
|
__name: "progress",
|
|
props: progressProps,
|
|
setup(__props) {
|
|
const STATUS_COLOR_MAP = {
|
|
success: "#13ce66",
|
|
exception: "#ff4949",
|
|
warning: "#e6a23c",
|
|
default: "#20a0ff"
|
|
};
|
|
const props2 = __props;
|
|
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(() => {
|
|
return `${-1 * perimeter.value * (1 - rate.value) / 2}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;
|
|
return color.map((seriesColor, index) => {
|
|
if (isString(seriesColor))
|
|
return {
|
|
color: seriesColor,
|
|
percentage: (index + 1) * span
|
|
};
|
|
return seriesColor;
|
|
}).sort((a2, b2) => a2.percentage - b2.percentage);
|
|
}
|
|
const getCurrentColor = (percentage) => {
|
|
var _a;
|
|
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 (_a = colors[colors.length - 1]) == null ? void 0 : _a.color;
|
|
}
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([
|
|
unref(ns).b(),
|
|
unref(ns).m(__props.type),
|
|
unref(ns).is(__props.status),
|
|
{
|
|
[unref(ns).m("without-text")]: !__props.showText,
|
|
[unref(ns).m("text-inside")]: __props.textInside
|
|
}
|
|
]),
|
|
role: "progressbar",
|
|
"aria-valuenow": __props.percentage,
|
|
"aria-valuemin": "0",
|
|
"aria-valuemax": "100"
|
|
}, [__props.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: `${__props.strokeWidth}px` })
|
|
}, [createBaseVNode("div", {
|
|
class: normalizeClass([
|
|
unref(ns).be("bar", "inner"),
|
|
{ [unref(ns).bem("bar", "inner", "indeterminate")]: __props.indeterminate },
|
|
{ [unref(ns).bem("bar", "inner", "striped")]: __props.striped },
|
|
{ [unref(ns).bem("bar", "inner", "striped-flow")]: __props.stripedFlow }
|
|
]),
|
|
style: normalizeStyle(barStyle.value)
|
|
}, [(__props.showText || _ctx.$slots.default) && __props.textInside ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).be("bar", "innerText"))
|
|
}, [renderSlot(_ctx.$slots, "default", { percentage: __props.percentage }, () => [createBaseVNode("span", null, toDisplayString(content.value), 1)])], 2)) : createCommentVNode("v-if", true)], 6)], 6)], 2)) : (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).b("circle")),
|
|
style: normalizeStyle({
|
|
height: `${__props.width}px`,
|
|
width: `${__props.width}px`
|
|
})
|
|
}, [(openBlock(), createElementBlock("svg", _hoisted_230, [createBaseVNode("path", {
|
|
class: normalizeClass(unref(ns).be("circle", "track")),
|
|
d: trackPath.value,
|
|
stroke: `var(${unref(ns).cssVarName("fill-color-light")}, #e5e9f2)`,
|
|
"stroke-linecap": __props.strokeLinecap,
|
|
"stroke-width": relativeStrokeWidth.value,
|
|
fill: "none",
|
|
style: normalizeStyle(trailPathStyle.value)
|
|
}, null, 14, _hoisted_313), createBaseVNode("path", {
|
|
class: normalizeClass(unref(ns).be("circle", "path")),
|
|
d: trackPath.value,
|
|
stroke: stroke.value,
|
|
fill: "none",
|
|
opacity: __props.percentage ? 1 : 0,
|
|
"stroke-linecap": __props.strokeLinecap,
|
|
"stroke-width": relativeStrokeWidth.value,
|
|
style: normalizeStyle(circlePathStyle.value)
|
|
}, null, 14, _hoisted_49)]))], 6)), (__props.showText || _ctx.$slots.default) && !__props.textInside ? (openBlock(), createElementBlock("div", {
|
|
key: 2,
|
|
class: normalizeClass(unref(ns).e("text")),
|
|
style: normalizeStyle({ fontSize: `${progressTextSize.value}px` })
|
|
}, [renderSlot(_ctx.$slots, "default", { percentage: __props.percentage }, () => [!__props.status ? (openBlock(), createElementBlock("span", _hoisted_58, toDisplayString(content.value), 1)) : (openBlock(), createBlock(unref(ElIcon), { key: 1 }, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(statusIcon.value)))]),
|
|
_: 1
|
|
}))])], 6)) : createCommentVNode("v-if", true)], 10, _hoisted_158);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/progress/src/progress2.mjs
|
|
var progress_default = progress_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/progress/index.mjs
|
|
var ElProgress = withInstall(progress_default);
|
|
|
|
// 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: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
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/rate.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_159 = [
|
|
"id",
|
|
"aria-label",
|
|
"aria-labelledby",
|
|
"aria-valuenow",
|
|
"aria-valuetext",
|
|
"aria-valuemax",
|
|
"tabindex",
|
|
"aria-disabled"
|
|
];
|
|
var _hoisted_231 = ["onMousemove", "onClick"];
|
|
var rate_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElRate",
|
|
__name: "rate",
|
|
props: rateProps,
|
|
emits: rateEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
function getValueFromMap(value, map2) {
|
|
const isExcludedObject = (val) => isObject(val);
|
|
const matchedValue = map2[Object.keys(map2).map((key) => +key).filter((key) => {
|
|
const val = map2[key];
|
|
return (isExcludedObject(val) ? val.excluded : false) ? value < key : value <= key;
|
|
}).sort((a2, b2) => a2 - b2)[0]];
|
|
return isExcludedObject(matchedValue) && matchedValue.value || matchedValue;
|
|
}
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const formItemContext = inject(formItemContextKey, void 0);
|
|
const rateSize = useFormSize();
|
|
const ns = useNamespace("rate");
|
|
const { inputId, isLabeledByFormItem } = useFormItemInputId(props2, { formItemContext });
|
|
const currentValue = ref(clamp_default(props2.modelValue, 0, props2.max));
|
|
const hoverIndex = ref(-1);
|
|
const pointerAtLeftHalf = ref(true);
|
|
const iconRefs = ref([]);
|
|
const iconClientWidths = computed(() => iconRefs.value.map((icon) => icon.$el.clientWidth));
|
|
const rateClasses = computed(() => [ns.b(), ns.m(rateSize.value)]);
|
|
const rateDisabled = useFormDisabled();
|
|
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;
|
|
const code = getEventCode(e);
|
|
const step2 = props2.allowHalf ? 0.5 : 1;
|
|
let _currentValue = currentValue.value;
|
|
switch (code) {
|
|
case EVENT_CODE.up:
|
|
case EVENT_CODE.right:
|
|
_currentValue += step2;
|
|
break;
|
|
case EVENT_CODE.left:
|
|
case EVENT_CODE.down:
|
|
_currentValue -= step2;
|
|
break;
|
|
}
|
|
_currentValue = clamp_default(_currentValue, 0, props2.max);
|
|
if (_currentValue === currentValue.value)
|
|
return;
|
|
e.stopPropagation();
|
|
e.preventDefault();
|
|
emit(UPDATE_MODEL_EVENT, _currentValue);
|
|
emit(CHANGE_EVENT, _currentValue);
|
|
return _currentValue;
|
|
}
|
|
function setCurrentValue(value, event) {
|
|
if (rateDisabled.value)
|
|
return;
|
|
if (props2.allowHalf && event) {
|
|
pointerAtLeftHalf.value = event.offsetX * 2 <= iconClientWidths.value[value - 1];
|
|
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 = clamp_default(props2.modelValue, 0, props2.max);
|
|
hoverIndex.value = -1;
|
|
}
|
|
watch(() => props2.modelValue, (val) => {
|
|
currentValue.value = clamp_default(val, 0, props2.max);
|
|
pointerAtLeftHalf.value = props2.modelValue !== Math.floor(props2.modelValue);
|
|
});
|
|
if (!props2.modelValue)
|
|
emit(UPDATE_MODEL_EVENT, 0);
|
|
__expose({
|
|
setCurrentValue,
|
|
resetCurrentValue
|
|
});
|
|
return (_ctx, _cache) => {
|
|
var _a;
|
|
return openBlock(), createElementBlock("div", {
|
|
id: unref(inputId),
|
|
class: normalizeClass([rateClasses.value, unref(ns).is("disabled", unref(rateDisabled))]),
|
|
role: "slider",
|
|
"aria-label": !unref(isLabeledByFormItem) ? __props.ariaLabel || "rating" : void 0,
|
|
"aria-labelledby": unref(isLabeledByFormItem) ? (_a = unref(formItemContext)) == null ? void 0 : _a.labelId : void 0,
|
|
"aria-valuenow": currentValue.value,
|
|
"aria-valuetext": text.value || void 0,
|
|
"aria-valuemin": "0",
|
|
"aria-valuemax": __props.max,
|
|
style: normalizeStyle(rateStyles.value),
|
|
tabindex: unref(rateDisabled) ? void 0 : 0,
|
|
"aria-disabled": unref(rateDisabled),
|
|
onKeydown: handleKey
|
|
}, [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.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), {
|
|
ref_for: true,
|
|
ref_key: "iconRefs",
|
|
ref: iconRefs,
|
|
class: normalizeClass([
|
|
unref(ns).e("icon"),
|
|
{ hover: hoverIndex.value === item },
|
|
unref(ns).is("active", item <= currentValue.value),
|
|
unref(ns).is("focus-visible", item === Math.ceil(currentValue.value || 1))
|
|
])
|
|
}, {
|
|
default: withCtx(() => [
|
|
withDirectives((openBlock(), createBlock(resolveDynamicComponent(activeComponent.value), null, null, 512)), [[vShow, !showDecimalIcon(item) && item <= currentValue.value]]),
|
|
withDirectives((openBlock(), createBlock(resolveDynamicComponent(voidComponent.value), null, null, 512)), [[vShow, !showDecimalIcon(item) && item > currentValue.value]]),
|
|
withDirectives((openBlock(), createBlock(resolveDynamicComponent(voidComponent.value), { class: normalizeClass([unref(ns).em("decimal", "box")]) }, null, 8, ["class"])), [[vShow, showDecimalIcon(item)]]),
|
|
withDirectives(createVNode(unref(ElIcon), {
|
|
style: normalizeStyle(decimalStyle.value),
|
|
class: normalizeClass([unref(ns).e("icon"), unref(ns).e("decimal")])
|
|
}, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(decimalIconComponent.value)))]),
|
|
_: 1
|
|
}, 8, ["style", "class"]), [[vShow, showDecimalIcon(item)]])
|
|
]),
|
|
_: 2
|
|
}, 1032, ["class"])], 42, _hoisted_231);
|
|
}), 128)), __props.showText || __props.showScore ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("text")),
|
|
style: normalizeStyle({ color: __props.textColor })
|
|
}, toDisplayString(text.value), 7)) : createCommentVNode("v-if", true)], 46, _hoisted_159);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/rate/src/rate2.mjs
|
|
var rate_default = rate_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/rate/index.mjs
|
|
var ElRate = withInstall(rate_default);
|
|
|
|
// 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/result.vue_vue_type_script_setup_true_lang.mjs
|
|
var result_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElResult",
|
|
__name: "result",
|
|
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";
|
|
return {
|
|
class: iconClass,
|
|
component: IconComponentMap[iconClass] || IconComponentMap["icon-info"]
|
|
};
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", { class: normalizeClass(unref(ns).b()) }, [
|
|
createBaseVNode("div", { class: normalizeClass(unref(ns).e("icon")) }, [renderSlot(_ctx.$slots, "icon", {}, () => [resultIcon.value.component ? (openBlock(), createBlock(resolveDynamicComponent(resultIcon.value.component), {
|
|
key: 0,
|
|
class: normalizeClass(resultIcon.value.class)
|
|
}, null, 8, ["class"])) : createCommentVNode("v-if", true)])], 2),
|
|
__props.title || _ctx.$slots.title ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("title"))
|
|
}, [renderSlot(_ctx.$slots, "title", {}, () => [createBaseVNode("p", null, toDisplayString(__props.title), 1)])], 2)) : createCommentVNode("v-if", true),
|
|
__props.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(__props.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);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/result/src/result2.mjs
|
|
var result_default2 = result_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/result/index.mjs
|
|
var ElResult = withInstall(result_default2);
|
|
|
|
// 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"
|
|
},
|
|
innerProps: {
|
|
type: definePropType(Object),
|
|
default: () => ({})
|
|
},
|
|
style: { type: definePropType([
|
|
Object,
|
|
String,
|
|
Array
|
|
]) },
|
|
useIsScrolling: Boolean,
|
|
width: {
|
|
type: [Number, String],
|
|
required: false
|
|
},
|
|
perfMode: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
scrollbarAlwaysOn: Boolean
|
|
});
|
|
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/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 isRTL2 = (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/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 props2 = getCurrentInstance().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 useWheel = ({ atEndEdge, atStartEdge, layout: layout2 }, onWheelDelta) => {
|
|
let frameHandle;
|
|
let offset3 = 0;
|
|
const hasReachedEdge = (offset4) => {
|
|
return offset4 < 0 && atStartEdge.value || offset4 > 0 && atEndEdge.value;
|
|
};
|
|
const onWheel = (e) => {
|
|
cAF(frameHandle);
|
|
let { deltaX, deltaY } = e;
|
|
if (e.shiftKey && deltaY !== 0) {
|
|
deltaX = deltaY;
|
|
deltaY = 0;
|
|
}
|
|
const newOffset = layout2.value === HORIZONTAL ? deltaX : deltaY;
|
|
if (hasReachedEdge(newOffset))
|
|
return;
|
|
offset3 += newOffset;
|
|
if (!isFirefox() && newOffset !== 0)
|
|
e.preventDefault();
|
|
frameHandle = rAF(() => {
|
|
onWheelDelta(offset3);
|
|
offset3 = 0;
|
|
});
|
|
};
|
|
return {
|
|
hasReachedEdge,
|
|
onWheel
|
|
};
|
|
};
|
|
|
|
// 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 / 100, SCROLLBAR_MIN_SIZE), SCROLLBAR_MAX_SIZE));
|
|
});
|
|
const thumbStyle = computed(() => {
|
|
if (!Number.isFinite(thumbSize.value))
|
|
return { display: "none" };
|
|
const thumb = `${thumbSize.value}px`;
|
|
return renderThumbStyle2({
|
|
bar: bar.value,
|
|
size: thumb,
|
|
move: state.traveled
|
|
}, props2.layout);
|
|
});
|
|
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 distance = (trackRef.value.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) * -1 - (thumbRef.value[bar.value.offset] - prevPage);
|
|
frameHandle = rAF(() => {
|
|
state.traveled = Math.max(0, Math.min(distance, totalSteps.value));
|
|
emit("scroll", distance, totalSteps.value);
|
|
});
|
|
};
|
|
const clickTrackHandler = (e) => {
|
|
const distance = Math.abs(e.target.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) - thumbRef.value[bar.value.offset] / 2;
|
|
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%",
|
|
margin: 0,
|
|
boxSizing: "border-box"
|
|
};
|
|
});
|
|
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 _a, _b;
|
|
(_b = (_a = scrollbarRef.value).onMouseUp) == null ? void 0 : _b.call(_a);
|
|
scrollTo2(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;
|
|
scrollTo2(Math.min(estimatedTotalSize.value - clientSize.value, offset3));
|
|
};
|
|
const scrollTo2 = (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));
|
|
scrollTo2(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: scrollTo2,
|
|
scrollToItem,
|
|
resetScrollTop
|
|
};
|
|
expose({
|
|
windowRef,
|
|
innerRef,
|
|
getItemStyleCache,
|
|
scrollTo: scrollTo2,
|
|
scrollToItem,
|
|
resetScrollTop,
|
|
states
|
|
});
|
|
return api;
|
|
},
|
|
render(ctx) {
|
|
var _a;
|
|
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 Container = resolveDynamicComponent(containerElement);
|
|
const Inner = resolveDynamicComponent(innerElement);
|
|
const children = [];
|
|
if (total2 > 0)
|
|
for (let i = start; i <= end; i++)
|
|
children.push(h(Fragment, { key: i }, (_a = $slots.default) == null ? void 0 : _a.call($slots, {
|
|
data,
|
|
index: i,
|
|
isScrolling: useIsScrolling ? states.isScrolling : void 0,
|
|
style: getItemStyle(i)
|
|
})));
|
|
const InnerNode = [h(Inner, mergeProps(ctx.innerProps, {
|
|
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,
|
|
alwaysOn: states.scrollbarAlwaysOn
|
|
});
|
|
const listContainer = h(Container, {
|
|
class: [ns.e("window"), className],
|
|
style: windowStyle,
|
|
onScroll,
|
|
ref: "windowRef",
|
|
key: 0
|
|
}, !isString(Container) ? { 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() {
|
|
},
|
|
clearCache: true,
|
|
validateProps() {
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/virtual-list/src/components/dynamic-size-list.mjs
|
|
var SCOPE8 = "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;
|
|
if ((lastVisitedIndex > 0 ? items[lastVisitedIndex].offset : 0) >= 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 totalSizeOfUnmeasuredItems = (total2 - lastVisitedIndex - 1) * 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 _a, _b;
|
|
cache2.lastVisitedIndex = Math.min(cache2.lastVisitedIndex, index - 1);
|
|
(_a = instance.exposed) == null ? void 0 : _a.getItemStyleCache(-1);
|
|
if (forceUpdate)
|
|
(_b = instance.proxy) == null ? void 0 : _b.$forceUpdate();
|
|
};
|
|
return cache2;
|
|
},
|
|
clearCache: false,
|
|
validateProps: ({ itemSize: itemSize3 }) => {
|
|
if (typeof itemSize3 !== "function")
|
|
throwError(SCOPE8, `
|
|
itemSize is required as function, but the given value was ${typeof itemSize3}
|
|
`);
|
|
}
|
|
});
|
|
|
|
// 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(x2, y)) {
|
|
if (e.deltaX !== 0 && x2 === 0)
|
|
e.preventDefault();
|
|
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/hooks/use-grid-touch.mjs
|
|
var useGridTouch = (windowRef, states, scrollTo2, estimatedTotalWidth, estimatedTotalHeight, parsedWidth, parsedHeight) => {
|
|
const touchStartX = ref(0);
|
|
const touchStartY = ref(0);
|
|
let frameHandle;
|
|
let deltaX = 0;
|
|
let deltaY = 0;
|
|
const handleTouchStart = (event) => {
|
|
cAF(frameHandle);
|
|
touchStartX.value = event.touches[0].clientX;
|
|
touchStartY.value = event.touches[0].clientY;
|
|
deltaX = 0;
|
|
deltaY = 0;
|
|
};
|
|
const handleTouchMove = (event) => {
|
|
event.preventDefault();
|
|
cAF(frameHandle);
|
|
deltaX += touchStartX.value - event.touches[0].clientX;
|
|
deltaY += touchStartY.value - event.touches[0].clientY;
|
|
touchStartX.value = event.touches[0].clientX;
|
|
touchStartY.value = event.touches[0].clientY;
|
|
frameHandle = rAF(() => {
|
|
const maxScrollLeft = estimatedTotalWidth.value - unref(parsedWidth);
|
|
const maxScrollTop = estimatedTotalHeight.value - unref(parsedHeight);
|
|
scrollTo2({
|
|
scrollLeft: Math.min(states.value.scrollLeft + deltaX, maxScrollLeft),
|
|
scrollTop: Math.min(states.value.scrollTop + deltaY, maxScrollTop)
|
|
});
|
|
deltaX = 0;
|
|
deltaY = 0;
|
|
});
|
|
};
|
|
useEventListener(windowRef, "touchstart", handleTouchStart, { passive: true });
|
|
useEventListener(windowRef, "touchmove", handleTouchMove, { passive: false });
|
|
return {
|
|
touchStartX,
|
|
touchStartY,
|
|
handleTouchStart,
|
|
handleTouchMove
|
|
};
|
|
};
|
|
|
|
// 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();
|
|
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 _a;
|
|
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
|
|
},
|
|
(_a = props2.style) != null ? _a : {}
|
|
];
|
|
});
|
|
const innerStyle = computed(() => {
|
|
const width = `${unref(estimatedTotalWidth)}px`;
|
|
return {
|
|
height: `${unref(estimatedTotalHeight)}px`,
|
|
pointerEvents: unref(states).isScrolling ? "none" : void 0,
|
|
width,
|
|
margin: 0,
|
|
boxSizing: "border-box"
|
|
};
|
|
});
|
|
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 (isRTL2(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;
|
|
scrollTo2({ scrollTop: Math.min(estimatedTotalHeight.value - height, offset3) });
|
|
};
|
|
const onHorizontalScroll = (distance, totalSteps) => {
|
|
const width = unref(parsedWidth);
|
|
const offset3 = (estimatedTotalWidth.value - width) / totalSteps * distance;
|
|
scrollTo2({ 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 _a, _b, _c, _d;
|
|
(_b = (_a = hScrollbar.value) == null ? void 0 : _a.onMouseUp) == null ? void 0 : _b.call(_a);
|
|
(_d = (_c = vScrollbar.value) == null ? void 0 : _c.onMouseUp) == null ? void 0 : _d.call(_c);
|
|
const width = unref(parsedWidth);
|
|
const height = unref(parsedHeight);
|
|
scrollTo2({
|
|
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 scrollTo2 = ({ 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 { touchStartX, touchStartY, handleTouchStart, handleTouchMove } = useGridTouch(windowRef, states, scrollTo2, estimatedTotalWidth, estimatedTotalHeight, parsedWidth, parsedHeight);
|
|
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);
|
|
scrollTo2({
|
|
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 = isRTL2(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,
|
|
touchStartX,
|
|
touchStartY,
|
|
handleTouchStart,
|
|
handleTouchMove,
|
|
scrollTo: scrollTo2,
|
|
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);
|
|
return {
|
|
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
|
|
}),
|
|
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
|
|
})
|
|
};
|
|
};
|
|
const renderItems = () => {
|
|
var _a;
|
|
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 }, (_a = slots.default) == null ? void 0 : _a.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, mergeProps(props2.innerProps, {
|
|
style: unref(innerStyle),
|
|
ref: innerRef
|
|
}), !isString(Inner) ? { default: () => children } : children)];
|
|
};
|
|
const renderWindow = () => {
|
|
const Container = resolveDynamicComponent(props2.containerElement);
|
|
const { horizontalScrollbar, verticalScrollbar } = renderScrollbars();
|
|
const Inner = renderInner();
|
|
return h("div", {
|
|
key: 0,
|
|
class: ns.e("wrapper"),
|
|
role: props2.role
|
|
}, [
|
|
h(Container, {
|
|
class: props2.className,
|
|
style: unref(windowStyle),
|
|
onScroll,
|
|
ref: windowRef
|
|
}, !isString(Container) ? { default: () => Inner } : Inner),
|
|
horizontalScrollbar,
|
|
verticalScrollbar
|
|
]);
|
|
};
|
|
return renderWindow;
|
|
}
|
|
});
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/virtual-list/src/components/fixed-size-grid.mjs
|
|
var SCOPE9 = "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 (!isNumber2(columnWidth))
|
|
throwError(SCOPE9, `
|
|
"columnWidth" must be passed as number,
|
|
instead ${typeof columnWidth} was given.
|
|
`);
|
|
if (!isNumber2(rowHeight))
|
|
throwError(SCOPE9, `
|
|
"columnWidth" must be passed as number,
|
|
instead ${typeof rowHeight} was given.
|
|
`);
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/virtual-list/src/components/dynamic-size-grid.mjs
|
|
var { max: max3, min: min3, floor: floor3 } = Math;
|
|
var SCOPE10 = "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 + floor3((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 max3(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, floor3(idx / 2), min3(idx, total2 - 1), offset3, type4);
|
|
};
|
|
var findItem2 = (props2, gridCache, offset3, type4) => {
|
|
const [cache2, lastVisitedIndex] = [gridCache[type4], gridCache[ACCESS_LAST_VISITED_KEY_MAP[type4]]];
|
|
if ((lastVisitedIndex > 0 ? cache2[lastVisitedIndex].offset : 0) >= offset3)
|
|
return bs2(props2, gridCache, 0, lastVisitedIndex, offset3, type4);
|
|
return es2(props2, gridCache, max3(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 sizeOfUnvisitedItems = (totalRow - lastVisitedRowIndex - 1) * 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 sizeOfUnvisitedItems = (totalColumn - lastVisitedColumnIndex - 1) * estimatedColumnWidth;
|
|
return sizeOfVisitedColumns + sizeOfUnvisitedItems;
|
|
};
|
|
var ACCESS_ESTIMATED_SIZE_KEY_MAP = {
|
|
column: getEstimatedTotalWidth,
|
|
row: getEstimatedTotalHeight
|
|
};
|
|
var getOffset = (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 maxOffset = max3(0, min3(estimatedSizeAssociates(props2, cache2) - size3, item.offset));
|
|
const minOffset = max3(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) => getOffset(props2, columnIndex, alignment, scrollLeft, cache2, "column", scrollBarWidth2),
|
|
getRowOffset: (props2, rowIndex, alignment, scrollTop, cache2, scrollBarWidth2) => getOffset(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 _a, _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);
|
|
(_a = instance.exposed) == null ? void 0 : _a.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 }) => {
|
|
return {
|
|
column: {},
|
|
estimatedColumnWidth,
|
|
estimatedRowHeight,
|
|
lastVisitedColumnIndex: -1,
|
|
lastVisitedRowIndex: -1,
|
|
row: {}
|
|
};
|
|
},
|
|
clearCache: false,
|
|
validateProps: ({ columnWidth, rowHeight }) => {
|
|
if (!isFunction(columnWidth))
|
|
throwError(SCOPE10, `
|
|
"columnWidth" must be passed as function,
|
|
instead ${typeof columnWidth} was given.
|
|
`);
|
|
if (!isFunction(rowHeight))
|
|
throwError(SCOPE10, `
|
|
"rowHeight" must be passed as function,
|
|
instead ${typeof rowHeight} was given.
|
|
`);
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/select-v2/src/token.mjs
|
|
var selectV2InjectionKey = Symbol("ElSelectV2Injection");
|
|
|
|
// node_modules/element-plus/es/components/select-v2/src/defaults.mjs
|
|
var selectV2Props = 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,
|
|
tagTooltip: {
|
|
type: definePropType(Object),
|
|
default: () => ({})
|
|
},
|
|
maxCollapseTags: {
|
|
type: Number,
|
|
default: 1
|
|
},
|
|
defaultFirstOption: Boolean,
|
|
disabled: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
estimatedOptionHeight: {
|
|
type: Number,
|
|
default: void 0
|
|
},
|
|
filterable: Boolean,
|
|
filterMethod: { type: definePropType(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
|
|
]),
|
|
default: void 0
|
|
},
|
|
multiple: Boolean,
|
|
multipleLimit: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
name: String,
|
|
noDataText: String,
|
|
noMatchText: String,
|
|
remoteMethod: { type: definePropType(Function) },
|
|
reserveKeyword: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
options: {
|
|
type: definePropType(Array),
|
|
required: true
|
|
},
|
|
placeholder: { type: String },
|
|
teleported: useTooltipContentProps.teleported,
|
|
persistent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
popperClass: useTooltipContentProps.popperClass,
|
|
popperStyle: useTooltipContentProps.popperStyle,
|
|
popperOptions: {
|
|
type: definePropType(Object),
|
|
default: () => ({})
|
|
},
|
|
remote: Boolean,
|
|
debounce: {
|
|
type: Number,
|
|
default: 300
|
|
},
|
|
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
|
|
},
|
|
remoteShowSuffix: Boolean,
|
|
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 optionV2Props = buildProps({
|
|
data: Array,
|
|
disabled: Boolean,
|
|
hovering: Boolean,
|
|
item: {
|
|
type: definePropType(Object),
|
|
required: true
|
|
},
|
|
index: Number,
|
|
style: Object,
|
|
selected: Boolean,
|
|
created: Boolean
|
|
});
|
|
var selectV2Emits = {
|
|
[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 optionV2Emits = {
|
|
hover: (index) => isNumber2(index),
|
|
select: (val, index) => true
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/select-v2/src/group-item.vue_vue_type_script_lang.mjs
|
|
var group_item_vue_vue_type_script_lang_default = defineComponent({
|
|
props: {
|
|
item: {
|
|
type: Object,
|
|
required: true
|
|
},
|
|
style: { type: Object },
|
|
height: Number
|
|
},
|
|
setup() {
|
|
return { ns: useNamespace("select") };
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/select-v2/src/group-item.mjs
|
|
function _sfc_render15(_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 group_item_default = _plugin_vue_export_helper_default(group_item_vue_vue_type_script_lang_default, [["render", _sfc_render15]]);
|
|
|
|
// 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/option-item.vue_vue_type_script_lang.mjs
|
|
var option_item_vue_vue_type_script_lang_default = defineComponent({
|
|
props: optionV2Props,
|
|
emits: optionV2Emits,
|
|
setup(props2, { emit }) {
|
|
const select = inject(selectV2InjectionKey);
|
|
const ns = useNamespace("select");
|
|
const { hoverItem, selectOptionClick } = useOption2(props2, { emit });
|
|
const { getLabel } = useProps(select.props);
|
|
const contentId = select.contentId;
|
|
const handleMousedown = (event) => {
|
|
let target2 = event.target;
|
|
const currentTarget = event.currentTarget;
|
|
while (target2 && target2 !== currentTarget) {
|
|
if (isFocusable(target2))
|
|
return;
|
|
target2 = target2.parentElement;
|
|
}
|
|
event.preventDefault();
|
|
};
|
|
return {
|
|
ns,
|
|
contentId,
|
|
hoverItem,
|
|
handleMousedown,
|
|
selectOptionClick,
|
|
getLabel
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/select-v2/src/option-item.mjs
|
|
var _hoisted_160 = [
|
|
"id",
|
|
"aria-selected",
|
|
"aria-disabled"
|
|
];
|
|
function _sfc_render16(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return openBlock(), createElementBlock("li", {
|
|
id: `${_ctx.contentId}-${_ctx.index}`,
|
|
role: "option",
|
|
"aria-selected": _ctx.selected,
|
|
"aria-disabled": _ctx.disabled || void 0,
|
|
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: _cache[0] || (_cache[0] = (...args) => _ctx.hoverItem && _ctx.hoverItem(...args)),
|
|
onMousedown: _cache[1] || (_cache[1] = (...args) => _ctx.handleMousedown && _ctx.handleMousedown(...args)),
|
|
onClick: _cache[2] || (_cache[2] = withModifiers((...args) => _ctx.selectOptionClick && _ctx.selectOptionClick(...args), ["stop"]))
|
|
}, [renderSlot(_ctx.$slots, "default", {
|
|
item: _ctx.item,
|
|
index: _ctx.index,
|
|
disabled: _ctx.disabled
|
|
}, () => [createBaseVNode("span", null, toDisplayString(_ctx.getLabel(_ctx.item)), 1)])], 46, _hoisted_160);
|
|
}
|
|
var option_item_default = _plugin_vue_export_helper_default(option_item_vue_vue_type_script_lang_default, [["render", _sfc_render16]]);
|
|
|
|
// 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,
|
|
id: String,
|
|
ariaLabel: String
|
|
};
|
|
var select_dropdown_default2 = 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 _a, _b;
|
|
(_b = (_a = select.tooltipRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
|
|
});
|
|
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();
|
|
};
|
|
expose({
|
|
listRef,
|
|
isSized,
|
|
isItemDisabled,
|
|
isItemHovering,
|
|
isItemSelected,
|
|
scrollToItem,
|
|
resetScrollTop
|
|
});
|
|
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(group_item_default, {
|
|
"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(option_item_default, mergeProps(itemProps, {
|
|
"selected": isSelected,
|
|
"disabled": getDisabled(item) || isDisabled,
|
|
"created": !!item.created,
|
|
"hovering": isHovering,
|
|
"item": item,
|
|
"onSelect": onSelect,
|
|
"onHover": onHover
|
|
}), { default: (props3) => {
|
|
var _a;
|
|
return ((_a = slots.default) == null ? void 0 : _a.call(slots, props3)) || createVNode("span", null, [getLabel(item)]);
|
|
} });
|
|
};
|
|
const { onKeyboardNavigate, onKeyboardSelect } = select;
|
|
const onForward = () => {
|
|
onKeyboardNavigate("forward");
|
|
};
|
|
const onBackward = () => {
|
|
onKeyboardNavigate("backward");
|
|
};
|
|
const onEscOrTab = () => {
|
|
};
|
|
const onKeydown = (e) => {
|
|
const code = getEventCode(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:
|
|
onEscOrTab();
|
|
break;
|
|
case down:
|
|
onForward();
|
|
break;
|
|
case up:
|
|
onBackward();
|
|
break;
|
|
case enter:
|
|
case numpadEnter:
|
|
onKeyboardSelect();
|
|
break;
|
|
}
|
|
};
|
|
return () => {
|
|
var _a, _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` }
|
|
}, [
|
|
(_a = slots.header) == null ? void 0 : _a.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,
|
|
"innerElement": "ul",
|
|
"innerProps": {
|
|
id: props2.id,
|
|
role: "listbox",
|
|
"aria-label": props2.ariaLabel,
|
|
"aria-orientation": "vertical"
|
|
},
|
|
"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;
|
|
});
|
|
watch(() => props2.options, (options) => {
|
|
const optionLabelsSet = new Set(options.map((option) => getLabel(option)));
|
|
states.createdOptions = states.createdOptions.filter((createdOption) => !optionLabelsSet.has(getLabel(createdOption)));
|
|
});
|
|
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)) {
|
|
states.createdOptions = states.createdOptions.filter((createdOption) => getLabel(createdOption) !== states.previousQuery);
|
|
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 slots = useSlots();
|
|
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 debouncing = ref(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 { isComposing, handleCompositionStart, handleCompositionEnd, handleCompositionUpdate } = useComposition({ afterComposition: (e) => onInput(e) });
|
|
const selectDisabled = useFormDisabled();
|
|
const { wrapperRef, isFocused, handleBlur } = useFocusController(inputRef, {
|
|
disabled: selectDisabled,
|
|
afterFocus() {
|
|
if (props2.automaticDropdown && !expanded.value) {
|
|
expanded.value = true;
|
|
states.menuVisibleOnFocus = true;
|
|
}
|
|
},
|
|
beforeBlur(event) {
|
|
var _a, _b;
|
|
return ((_a = tooltipRef.value) == null ? void 0 : _a.isFocusInsideContent(event)) || ((_b = tagTooltipRef.value) == null ? void 0 : _b.isFocusInsideContent(event));
|
|
},
|
|
afterBlur() {
|
|
var _a;
|
|
expanded.value = false;
|
|
states.menuVisibleOnFocus = false;
|
|
if (props2.validateEvent)
|
|
(_a = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a.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 needStatusIcon = computed(() => {
|
|
var _a;
|
|
return (_a = elForm == null ? void 0 : elForm.statusIcon) != null ? _a : 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 && hasModelValue.value && (isFocused.value || states.inputHovering);
|
|
});
|
|
const iconComponent = computed(() => props2.remote && props2.filterable && !props2.remoteShowSuffix ? "" : 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 debounce2 = computed(() => props2.remote ? props2.debounce : 0);
|
|
const isRemoteSearchEmpty = computed(() => props2.remote && !states.inputValue && !hasOptions.value);
|
|
const emptyText = computed(() => {
|
|
if (props2.loading)
|
|
return props2.loadingText || t("el.select.loading");
|
|
else {
|
|
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 isFilterMethodValid = computed(() => props2.filterable && isFunction(props2.filterMethod));
|
|
const isRemoteMethodValid = computed(() => props2.filterable && props2.remote && isFunction(props2.remoteMethod));
|
|
const filterOptions = (query) => {
|
|
const regexp4 = new RegExp(escapeStringRegexp(query), "i");
|
|
const isValidOption = (o2) => {
|
|
if (isFilterMethodValid.value || isRemoteMethodValid.value)
|
|
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 = /* @__PURE__ */ new Map();
|
|
allOptions.value.forEach((option, index) => {
|
|
valueMap.set(getValueKey(getValue3(option)), {
|
|
option,
|
|
index
|
|
});
|
|
});
|
|
return valueMap;
|
|
});
|
|
const filteredOptionsValueMap = computed(() => {
|
|
const valueMap = /* @__PURE__ */ 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(() => "small" === selectSize.value ? "small" : "default");
|
|
const calculatePopperSize = () => {
|
|
var _a;
|
|
if (isNumber2(props2.fitInputWidth)) {
|
|
popperSize.value = props2.fitInputWidth;
|
|
return;
|
|
}
|
|
const width = ((_a = selectRef.value) == null ? void 0 : _a.offsetWidth) || 200;
|
|
if (!props2.fitInputWidth && hasOptions.value)
|
|
nextTick(() => {
|
|
popperSize.value = Math.max(width, calculateLabelMaxWidth());
|
|
});
|
|
else
|
|
popperSize.value = width;
|
|
};
|
|
const calculateLabelMaxWidth = () => {
|
|
var _a, _b;
|
|
const ctx = document.createElement("canvas").getContext("2d");
|
|
const selector = nsSelect.be("dropdown", "item");
|
|
const dropdownItemEl = (((_b = (_a = menuRef.value) == null ? void 0 : _a.listRef) == null ? void 0 : _b.innerRef) || document).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`), "")}`;
|
|
return filteredOptions.value.reduce((max4, option) => {
|
|
const metrics = ctx.measureText(getLabel(option));
|
|
return Math.max(metrics.width, max4);
|
|
}, 0) + 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 inputSlotWidth = props2.filterable ? gapWidth + MINIMUM_INPUT_WIDTH : 0;
|
|
return { maxWidth: `${collapseItemRef.value && props2.maxCollapseTags === 1 ? states.selectionWidth - states.collapseItemWidth - gapWidth - inputSlotWidth : states.selectionWidth - inputSlotWidth}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 _a;
|
|
const _placeholder = (_a = props2.placeholder) != null ? _a : t("el.select.placeholder");
|
|
return props2.multiple || !hasModelValue.value ? _placeholder : states.selectedLabel;
|
|
});
|
|
const popperRef = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = tooltipRef.value) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.contentRef;
|
|
});
|
|
const indexRef = computed(() => {
|
|
if (props2.multiple) {
|
|
const len = props2.modelValue.length;
|
|
if (len > 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 && (props2.loading || !isRemoteSearchEmpty.value || props2.remote && !!slots.empty) && (!debouncing.value || !isEmpty2(states.previousQuery) || hasOptions.value);
|
|
},
|
|
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 = (event) => {
|
|
var _a;
|
|
if (selectDisabled.value || props2.filterable && expanded.value && event && !((_a = suffixRef.value) == null ? void 0 : _a.contains(event.target)))
|
|
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);
|
|
nextTick(() => {
|
|
handleQueryChange(states.inputValue);
|
|
});
|
|
};
|
|
const debouncedOnInputChange = useDebounceFn(() => {
|
|
onInputChange();
|
|
debouncing.value = false;
|
|
}, debounce2);
|
|
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 _a, _b;
|
|
(_b = (_a = tooltipRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
|
|
};
|
|
const updateTagTooltip = () => {
|
|
var _a, _b;
|
|
(_b = (_a = tagTooltipRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
|
|
};
|
|
const onSelect = (option) => {
|
|
const optionValue = getValue3(option);
|
|
if (props2.multiple) {
|
|
let selectedOptions = props2.modelValue.slice();
|
|
const index = getValueIndex(selectedOptions, optionValue);
|
|
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, optionValue];
|
|
states.cachedOptions.push(option);
|
|
selectNewOption(option);
|
|
}
|
|
update2(selectedOptions);
|
|
if (option.created)
|
|
handleQueryChange("");
|
|
if (props2.filterable && (option.created || !props2.reserveKeyword))
|
|
states.inputValue = "";
|
|
} else {
|
|
states.selectedLabel = getLabel(option);
|
|
!isEqual_default(props2.modelValue, optionValue) && update2(optionValue);
|
|
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 _a;
|
|
(_a = inputRef.value) == null ? void 0 : _a.focus();
|
|
};
|
|
const blur = () => {
|
|
var _a;
|
|
if (expanded.value) {
|
|
expanded.value = false;
|
|
nextTick(() => {
|
|
var _a2;
|
|
return (_a2 = inputRef.value) == null ? void 0 : _a2.blur();
|
|
});
|
|
return;
|
|
}
|
|
(_a = inputRef.value) == null ? void 0 : _a.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) => {
|
|
const code = getEventCode(e);
|
|
if (!props2.multiple)
|
|
return;
|
|
if (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 {
|
|
const length = props2.modelValue.length;
|
|
if (length > 0) {
|
|
const lastValue = props2.modelValue[length - 1];
|
|
states.hoveringIndex = filteredOptions.value.findIndex((item) => getValueKey(lastValue) === getValueKey(getValue3(item)));
|
|
} else
|
|
states.hoveringIndex = -1;
|
|
}
|
|
};
|
|
const onInput = (event) => {
|
|
states.inputValue = event.target.value;
|
|
if (props2.remote) {
|
|
debouncing.value = true;
|
|
debouncedOnInputChange();
|
|
} else
|
|
return onInputChange();
|
|
};
|
|
const handleClickOutside = (event) => {
|
|
expanded.value = false;
|
|
if (isFocused.value)
|
|
handleBlur(new FocusEvent("blur", event));
|
|
};
|
|
const handleMenuEnter = () => {
|
|
states.isBeforeHide = false;
|
|
return nextTick(() => {
|
|
if (~indexRef.value)
|
|
scrollToItem(indexRef.value);
|
|
});
|
|
};
|
|
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 getIndex = (option) => {
|
|
var _a, _b;
|
|
return (_b = (_a = allOptionsValueMap.value.get(getValue3(option))) == null ? void 0 : _a.index) != null ? _b : -1;
|
|
};
|
|
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;
|
|
states.menuVisibleOnFocus = false;
|
|
createNewOption("");
|
|
}
|
|
});
|
|
watch(() => props2.modelValue, (val, oldVal) => {
|
|
var _a;
|
|
if (!val || isArray(val) && val.length === 0 || props2.multiple && !isEqual_default(val.toString(), states.previousValue) || !props2.multiple && getValueKey(val) !== getValueKey(states.previousValue))
|
|
initStates(true);
|
|
if (!isEqual_default(val, oldVal) && props2.validateEvent)
|
|
(_a = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a.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 = /* @__PURE__ */ 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(wrapperRef, updateTooltip);
|
|
useResizeObserver(tagMenuRef, updateTagTooltip);
|
|
useResizeObserver(collapseItemRef, resetCollapseItemWidth);
|
|
let stop;
|
|
watch(() => dropdownMenuVisible.value, (newVal) => {
|
|
if (newVal)
|
|
stop = useResizeObserver(menuRef, updateTooltip).stop;
|
|
else {
|
|
stop == null ? void 0 : stop();
|
|
stop = void 0;
|
|
}
|
|
emit("visible-change", newVal);
|
|
});
|
|
return {
|
|
inputId,
|
|
collapseTagSize,
|
|
currentPlaceholder,
|
|
expanded,
|
|
emptyText,
|
|
popupHeight,
|
|
debounce: debounce2,
|
|
allOptions,
|
|
allOptionsValueMap,
|
|
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,
|
|
getIndex,
|
|
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.vue_vue_type_script_lang.mjs
|
|
var select_vue_vue_type_script_lang_default2 = defineComponent({
|
|
name: "ElSelectV2",
|
|
components: {
|
|
ElSelectMenu: select_dropdown_default2,
|
|
ElTag,
|
|
ElTooltip,
|
|
ElIcon
|
|
},
|
|
directives: { ClickOutside },
|
|
props: selectV2Props,
|
|
emits: selectV2Emits,
|
|
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();
|
|
const contentId = useId();
|
|
provide(selectV2InjectionKey, {
|
|
props: reactive({
|
|
...toRefs(props2),
|
|
height: API.popupHeight,
|
|
modelValue
|
|
}),
|
|
expanded: API.expanded,
|
|
tooltipRef: API.tooltipRef,
|
|
contentId,
|
|
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) => API.getLabel(i));
|
|
});
|
|
return {
|
|
...API,
|
|
modelValue,
|
|
selectedLabel,
|
|
calculatorRef,
|
|
inputStyle,
|
|
contentId,
|
|
BORDER_HORIZONTAL_WIDTH
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/select-v2/src/select.mjs
|
|
var _hoisted_161 = [
|
|
"id",
|
|
"value",
|
|
"autocomplete",
|
|
"tabindex",
|
|
"aria-expanded",
|
|
"aria-label",
|
|
"disabled",
|
|
"aria-controls",
|
|
"aria-activedescendant",
|
|
"readonly",
|
|
"name"
|
|
];
|
|
var _hoisted_233 = ["textContent"];
|
|
var _hoisted_314 = { key: 1 };
|
|
function _sfc_render17(_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: _cache[15] || (_cache[15] = ($event) => _ctx.states.inputHovering = true),
|
|
onMouseleave: _cache[16] || (_cache[16] = ($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],
|
|
"popper-style": _ctx.popperStyle,
|
|
"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: _cache[14] || (_cache[14] = ($event) => _ctx.states.isBeforeHide = false)
|
|
}, {
|
|
default: withCtx(() => {
|
|
var _a, _b;
|
|
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: _cache[11] || (_cache[11] = withModifiers((...args) => _ctx.toggleMenu && _ctx.toggleMenu(...args), ["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,
|
|
data: _ctx.states.cachedOptions,
|
|
deleteTag: _ctx.deleteTag,
|
|
selectDisabled: _ctx.selectDisabled
|
|
}, () => {
|
|
var _a2, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t2, _u;
|
|
return [(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", {
|
|
index: _ctx.getIndex(item),
|
|
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.states.cachedOptions.length > _ctx.maxCollapseTags ? (openBlock(), createBlock(_component_el_tooltip, {
|
|
key: 0,
|
|
ref: "tagTooltipRef",
|
|
disabled: _ctx.dropdownMenuVisible || !_ctx.collapseTagsTooltip,
|
|
"fallback-placements": (_b2 = (_a2 = _ctx.tagTooltip) == null ? void 0 : _a2.fallbackPlacements) != null ? _b2 : [
|
|
"bottom",
|
|
"top",
|
|
"right",
|
|
"left"
|
|
],
|
|
effect: (_d = (_c = _ctx.tagTooltip) == null ? void 0 : _c.effect) != null ? _d : _ctx.effect,
|
|
placement: (_f = (_e = _ctx.tagTooltip) == null ? void 0 : _e.placement) != null ? _f : "bottom",
|
|
"popper-class": (_h = (_g = _ctx.tagTooltip) == null ? void 0 : _g.popperClass) != null ? _h : _ctx.popperClass,
|
|
"popper-style": (_j = (_i = _ctx.tagTooltip) == null ? void 0 : _i.popperStyle) != null ? _j : _ctx.popperStyle,
|
|
teleported: (_l = (_k = _ctx.tagTooltip) == null ? void 0 : _k.teleported) != null ? _l : _ctx.teleported,
|
|
"append-to": (_n = (_m = _ctx.tagTooltip) == null ? void 0 : _m.appendTo) != null ? _n : _ctx.appendTo,
|
|
"popper-options": (_p = (_o = _ctx.tagTooltip) == null ? void 0 : _o.popperOptions) != null ? _p : _ctx.popperOptions,
|
|
transition: (_q = _ctx.tagTooltip) == null ? void 0 : _q.transition,
|
|
"show-after": (_r = _ctx.tagTooltip) == null ? void 0 : _r.showAfter,
|
|
"hide-after": (_s = _ctx.tagTooltip) == null ? void 0 : _s.hideAfter,
|
|
"auto-close": (_t2 = _ctx.tagTooltip) == null ? void 0 : _t2.autoClose,
|
|
offset: (_u = _ctx.tagTooltip) == null ? void 0 : _u.offset
|
|
}, {
|
|
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.states.cachedOptions.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", {
|
|
index: _ctx.getIndex(selected),
|
|
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",
|
|
"fallback-placements",
|
|
"effect",
|
|
"placement",
|
|
"popper-class",
|
|
"popper-style",
|
|
"teleported",
|
|
"append-to",
|
|
"popper-options",
|
|
"transition",
|
|
"show-after",
|
|
"hide-after",
|
|
"auto-close",
|
|
"offset"
|
|
])) : 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 || _ctx.selectDisabled || !_ctx.states.inputValue && !_ctx.isFocused)
|
|
]) }, [createBaseVNode("input", {
|
|
id: _ctx.inputId,
|
|
ref: "inputRef",
|
|
value: _ctx.states.inputValue,
|
|
style: normalizeStyle(_ctx.inputStyle),
|
|
autocomplete: _ctx.autocomplete,
|
|
tabindex: _ctx.tabindex,
|
|
"aria-autocomplete": "none",
|
|
"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",
|
|
"aria-controls": _ctx.contentId,
|
|
"aria-activedescendant": _ctx.states.hoveringIndex >= 0 ? `${_ctx.contentId}-${_ctx.states.hoveringIndex}` : "",
|
|
readonly: !_ctx.filterable,
|
|
spellcheck: "false",
|
|
type: "text",
|
|
name: _ctx.name,
|
|
onInput: _cache[0] || (_cache[0] = (...args) => _ctx.onInput && _ctx.onInput(...args)),
|
|
onChange: _cache[1] || (_cache[1] = withModifiers(() => {
|
|
}, ["stop"])),
|
|
onCompositionstart: _cache[2] || (_cache[2] = (...args) => _ctx.handleCompositionStart && _ctx.handleCompositionStart(...args)),
|
|
onCompositionupdate: _cache[3] || (_cache[3] = (...args) => _ctx.handleCompositionUpdate && _ctx.handleCompositionUpdate(...args)),
|
|
onCompositionend: _cache[4] || (_cache[4] = (...args) => _ctx.handleCompositionEnd && _ctx.handleCompositionEnd(...args)),
|
|
onKeydown: [
|
|
_cache[5] || (_cache[5] = withKeys(withModifiers(($event) => _ctx.onKeyboardNavigate("backward"), ["stop", "prevent"]), ["up"])),
|
|
_cache[6] || (_cache[6] = withKeys(withModifiers(($event) => _ctx.onKeyboardNavigate("forward"), ["stop", "prevent"]), ["down"])),
|
|
_cache[7] || (_cache[7] = withKeys(withModifiers((...args) => _ctx.onKeyboardSelect && _ctx.onKeyboardSelect(...args), ["stop", "prevent"]), ["enter"])),
|
|
_cache[8] || (_cache[8] = withKeys(withModifiers((...args) => _ctx.handleEsc && _ctx.handleEsc(...args), ["stop", "prevent"]), ["esc"])),
|
|
_cache[9] || (_cache[9] = withKeys(withModifiers((...args) => _ctx.handleDel && _ctx.handleDel(...args), ["stop"]), ["delete"]))
|
|
],
|
|
onClick: _cache[10] || (_cache[10] = withModifiers((...args) => _ctx.toggleMenu && _ctx.toggleMenu(...args), ["stop"]))
|
|
}, null, 46, _hoisted_161), _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, _hoisted_233)) : 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,
|
|
index: (_b = (_a = _ctx.allOptionsValueMap.get(_ctx.modelValue)) == null ? void 0 : _a.index) != null ? _b : -1,
|
|
label: _ctx.currentPlaceholder,
|
|
value: _ctx.modelValue
|
|
}, () => [createBaseVNode("span", null, toDisplayString(_ctx.currentPlaceholder), 1)]) : (openBlock(), createElementBlock("span", _hoisted_314, 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)
|
|
], 2)];
|
|
}),
|
|
content: withCtx(() => [createVNode(_component_el_select_menu, {
|
|
id: _ctx.contentId,
|
|
ref: "menuRef",
|
|
data: _ctx.filteredOptions,
|
|
width: _ctx.popperSize - _ctx.BORDER_HORIZONTAL_WIDTH,
|
|
"hovering-index": _ctx.states.hoveringIndex,
|
|
"scrollbar-always-on": _ctx.scrollbarAlwaysOn,
|
|
"aria-label": _ctx.ariaLabel
|
|
}, 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")),
|
|
onClick: _cache[12] || (_cache[12] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}, [renderSlot(_ctx.$slots, "header")], 2)]),
|
|
key: "0"
|
|
} : 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)]),
|
|
key: "1"
|
|
} : _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)]),
|
|
key: "2"
|
|
} : void 0,
|
|
_ctx.$slots.footer ? {
|
|
name: "footer",
|
|
fn: withCtx(() => [createBaseVNode("div", {
|
|
class: normalizeClass(_ctx.nsSelect.be("dropdown", "footer")),
|
|
onClick: _cache[13] || (_cache[13] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}, [renderSlot(_ctx.$slots, "footer")], 2)]),
|
|
key: "3"
|
|
} : void 0
|
|
]), 1032, [
|
|
"id",
|
|
"data",
|
|
"width",
|
|
"hovering-index",
|
|
"scrollbar-always-on",
|
|
"aria-label"
|
|
])]),
|
|
_: 3
|
|
}, 8, [
|
|
"visible",
|
|
"teleported",
|
|
"popper-class",
|
|
"popper-style",
|
|
"popper-options",
|
|
"fallback-placements",
|
|
"effect",
|
|
"placement",
|
|
"transition",
|
|
"persistent",
|
|
"append-to",
|
|
"show-arrow",
|
|
"offset",
|
|
"onBeforeShow"
|
|
])], 34)), [[
|
|
_directive_click_outside,
|
|
_ctx.handleClickOutside,
|
|
_ctx.popperRef
|
|
]]);
|
|
}
|
|
var select_default2 = _plugin_vue_export_helper_default(select_vue_vue_type_script_lang_default2, [["render", _sfc_render17]]);
|
|
|
|
// node_modules/element-plus/es/components/select-v2/index.mjs
|
|
var ElSelectV2 = withInstall(select_default2);
|
|
|
|
// node_modules/element-plus/es/components/skeleton/src/skeleton.mjs
|
|
var skeletonProps = buildProps({
|
|
animated: Boolean,
|
|
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/components/skeleton/src/skeleton-item.vue_vue_type_script_setup_true_lang.mjs
|
|
var skeleton_item_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElSkeletonItem",
|
|
__name: "skeleton-item",
|
|
props: skeletonItemProps,
|
|
setup(__props) {
|
|
const ns = useNamespace("skeleton");
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", { class: normalizeClass([unref(ns).e("item"), unref(ns).e(__props.variant)]) }, [__props.variant === "image" ? (openBlock(), createBlock(unref(picture_filled_default), { key: 0 })) : createCommentVNode("v-if", true)], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/skeleton/src/skeleton-item2.mjs
|
|
var skeleton_item_default = skeleton_item_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/skeleton/src/skeleton.vue_vue_type_script_setup_true_lang.mjs
|
|
var skeleton_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElSkeleton",
|
|
__name: "skeleton",
|
|
props: skeletonProps,
|
|
setup(__props, { expose: __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", __props.animated)]
|
|
}, _ctx.$attrs), [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.count, (i) => {
|
|
return openBlock(), createElementBlock(Fragment, { key: i }, [unref(uiLoading) ? renderSlot(_ctx.$slots, "template", { key: i }, () => [createVNode(skeleton_item_default, {
|
|
class: normalizeClass(unref(ns).is("first")),
|
|
variant: "p"
|
|
}, null, 8, ["class"]), (openBlock(true), createElementBlock(Fragment, null, renderList(__props.rows, (item) => {
|
|
return openBlock(), createBlock(skeleton_item_default, {
|
|
key: item,
|
|
class: normalizeClass([unref(ns).e("paragraph"), unref(ns).is("last", item === __props.rows && __props.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)));
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/skeleton/src/skeleton2.mjs
|
|
var skeleton_default = skeleton_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/skeleton/index.mjs
|
|
var ElSkeleton = withInstall(skeleton_default, { SkeletonItem: skeleton_item_default });
|
|
var ElSkeletonItem = withNoopInstall(skeleton_item_default);
|
|
|
|
// 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: definePropType([Number, String]),
|
|
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: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
range: Boolean,
|
|
vertical: Boolean,
|
|
height: String,
|
|
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/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/composables/use-marks.mjs
|
|
var useMarks = (props2) => {
|
|
const markList = computed(() => {
|
|
if (!props2.marks)
|
|
return [];
|
|
return Object.keys(props2.marks).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]
|
|
}));
|
|
});
|
|
watchEffect(() => {
|
|
if (props2.step === "mark" && !props2.marks)
|
|
debugWarn("ElSlider", "marks prop must be provided when step is mark");
|
|
if (props2.marks) {
|
|
const keys3 = Object.keys(props2.marks);
|
|
const validPoints = markList.value.map((m2) => m2.point);
|
|
const invalidKeys = keys3.filter((key) => {
|
|
const parsed = Number.parseFloat(key);
|
|
return Number.isNaN(parsed) || !validPoints.includes(parsed);
|
|
});
|
|
if (invalidKeys.length > 0)
|
|
debugWarn("ElSlider", `Some marks keys are invalid (not a number or out of [min, max]): [${invalidKeys.map((k) => `'${k}'`).join(", ")}] and will be ignored.`);
|
|
}
|
|
});
|
|
return markList;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/slider/src/composables/use-slide.mjs
|
|
var useSlide = (props2, initData, emit) => {
|
|
const { formItem: elFormItem } = useFormItem();
|
|
const slider = shallowRef();
|
|
const firstButton = ref();
|
|
const secondButton = ref();
|
|
const buttonRefs = {
|
|
firstButton,
|
|
secondButton
|
|
};
|
|
const sliderDisabled = useFormDisabled();
|
|
const minValue3 = computed(() => {
|
|
return Math.min(initData.firstValue, initData.secondValue);
|
|
});
|
|
const maxValue3 = computed(() => {
|
|
return Math.max(initData.firstValue, initData.secondValue);
|
|
});
|
|
const barSize = computed(() => {
|
|
return props2.range ? `${100 * (maxValue3.value - minValue3.value) / (props2.max - props2.min)}%` : `${100 * (initData.firstValue - props2.min) / (props2.max - props2.min)}%`;
|
|
});
|
|
const barStart = computed(() => {
|
|
return props2.range ? `${100 * (minValue3.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.getBoundingClientRect()[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(minValue3.value - targetValue) < Math.abs(maxValue3.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 ? [minValue3.value, maxValue3.value] : firstValue != null ? firstValue : props2.min);
|
|
};
|
|
const setSecondValue = (secondValue) => {
|
|
initData.secondValue = secondValue;
|
|
if (props2.range)
|
|
_emit([minValue3.value, maxValue3.value]);
|
|
};
|
|
const _emit = (val) => {
|
|
emit(UPDATE_MODEL_EVENT, val);
|
|
emit(INPUT_EVENT, val);
|
|
};
|
|
const emitChange = async () => {
|
|
await nextTick();
|
|
emit(CHANGE_EVENT, props2.range ? [minValue3.value, maxValue3.value] : props2.modelValue);
|
|
};
|
|
const handleSliderPointerEvent = (event) => {
|
|
var _a, _b, _c, _d, _e, _f;
|
|
if (sliderDisabled.value || initData.dragging)
|
|
return;
|
|
resetSize();
|
|
let newPercent = 0;
|
|
if (props2.vertical) {
|
|
const clientY = (_c = (_b = (_a = event.touches) == null ? void 0 : _a.item(0)) == null ? void 0 : _b.clientY) != null ? _c : event.clientY;
|
|
newPercent = (slider.value.getBoundingClientRect().bottom - clientY) / initData.sliderSize * 100;
|
|
} else
|
|
newPercent = (((_f = (_e = (_d = event.touches) == null ? void 0 : _d.item(0)) == null ? void 0 : _e.clientX) != null ? _f : event.clientX) - slider.value.getBoundingClientRect().left) / initData.sliderSize * 100;
|
|
if (newPercent < 0 || newPercent > 100)
|
|
return;
|
|
return setPosition(newPercent);
|
|
};
|
|
const onSliderWrapperPrevent = (event) => {
|
|
var _a, _b;
|
|
if (((_a = buttonRefs["firstButton"].value) == null ? void 0 : _a.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) => {
|
|
if (handleSliderPointerEvent(event))
|
|
emitChange();
|
|
};
|
|
const onSliderMarkerDown = (position) => {
|
|
if (sliderDisabled.value || initData.dragging)
|
|
return;
|
|
if (setPosition(position))
|
|
emitChange();
|
|
};
|
|
return {
|
|
elFormItem,
|
|
slider,
|
|
firstButton,
|
|
secondButton,
|
|
sliderDisabled,
|
|
minValue: minValue3,
|
|
maxValue: maxValue3,
|
|
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, minValue3, maxValue3) => {
|
|
const stops = computed(() => {
|
|
if (!props2.showStops || props2.min > props2.max)
|
|
return [];
|
|
if (props2.step === "mark" || props2.step === 0) {
|
|
if (props2.step === 0)
|
|
debugWarn("ElSlider", "step should not be 0.");
|
|
return [];
|
|
}
|
|
const stopCount = Math.ceil((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((step2) => {
|
|
return step2 < 100 * (minValue3.value - props2.min) / (props2.max - props2.min) || step2 > 100 * (maxValue3.value - props2.min) / (props2.max - props2.min);
|
|
});
|
|
else
|
|
return result2.filter((step2) => step2 > 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-watch.mjs
|
|
var useWatch = (props2, initData, minValue3, maxValue3, emit, elFormItem) => {
|
|
const _emit = (val) => {
|
|
emit(UPDATE_MODEL_EVENT, val);
|
|
emit(INPUT_EVENT, val);
|
|
};
|
|
const valueChanged = () => {
|
|
if (props2.range)
|
|
return ![minValue3.value, maxValue3.value].every((item, index) => item === initData.oldValue[index]);
|
|
else
|
|
return props2.modelValue !== initData.oldValue;
|
|
};
|
|
const setValues = () => {
|
|
var _a, _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)
|
|
(_a = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a.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-slider-button.mjs
|
|
var useTooltip = (props2, formatTooltip, showTooltip) => {
|
|
const tooltip = ref();
|
|
const tooltipVisible = ref(false);
|
|
const enableFormat = computed(() => {
|
|
return formatTooltip.value instanceof Function;
|
|
});
|
|
return {
|
|
tooltip,
|
|
tooltipVisible,
|
|
formatValue: computed(() => {
|
|
return enableFormat.value && formatTooltip.value(props2.modelValue) || props2.modelValue;
|
|
}),
|
|
displayTooltip: debounce_default(() => {
|
|
showTooltip.value && (tooltipVisible.value = true);
|
|
}, 50),
|
|
hideTooltip: debounce_default(() => {
|
|
showTooltip.value && (tooltipVisible.value = false);
|
|
}, 50)
|
|
};
|
|
};
|
|
var useSliderButton = (props2, initData, emit) => {
|
|
const { disabled, min: min4, max: max4, step: step2, showTooltip, persistent, precision, sliderSize, formatTooltip, emitChange, resetSize, updateDragging, markList } = 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 shouldMoveToMark = computed(() => {
|
|
return step2.value === "mark" && markList.value.length > 0;
|
|
});
|
|
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 moveToMark = (amount) => {
|
|
if (disabled.value || !markList.value.length)
|
|
return;
|
|
const current = props2.modelValue;
|
|
const epsilon = Number.EPSILON;
|
|
const stride = Math.abs(amount);
|
|
let target2;
|
|
if (amount > 0) {
|
|
const startIndex = markList.value.findIndex((m2) => m2.point > current + epsilon);
|
|
if (startIndex !== -1) {
|
|
const targetIndex = Math.min(startIndex + stride - 1, markList.value.length - 1);
|
|
target2 = markList.value[targetIndex].point;
|
|
}
|
|
} else {
|
|
let startIndex = -1;
|
|
for (let i = markList.value.length - 1; i >= 0; i--)
|
|
if (markList.value[i].point < current - epsilon) {
|
|
startIndex = i;
|
|
break;
|
|
}
|
|
if (startIndex !== -1) {
|
|
const targetIndex = Math.max(startIndex - (stride - 1), 0);
|
|
target2 = markList.value[targetIndex].point;
|
|
}
|
|
}
|
|
if (target2 !== void 0 && target2 !== current) {
|
|
setPosition((target2 - min4.value) / (max4.value - min4.value) * 100);
|
|
emitChange();
|
|
}
|
|
};
|
|
const onLeftKeyDown = () => {
|
|
if (shouldMoveToMark.value)
|
|
moveToMark(-1);
|
|
else if (isNumber2(step2.value))
|
|
incrementPosition(-step2.value);
|
|
};
|
|
const onRightKeyDown = () => {
|
|
if (shouldMoveToMark.value)
|
|
moveToMark(1);
|
|
else if (isNumber2(step2.value))
|
|
incrementPosition(step2.value);
|
|
};
|
|
const onPageDownKeyDown = () => {
|
|
if (shouldMoveToMark.value)
|
|
moveToMark(-4);
|
|
else if (isNumber2(step2.value))
|
|
incrementPosition(-step2.value * 4);
|
|
};
|
|
const onPageUpKeyDown = () => {
|
|
if (shouldMoveToMark.value)
|
|
moveToMark(4);
|
|
else if (isNumber2(step2.value))
|
|
incrementPosition(step2.value * 4);
|
|
};
|
|
const onHomeKeyDown = () => {
|
|
if (disabled.value)
|
|
return;
|
|
setPosition(0);
|
|
emitChange();
|
|
};
|
|
const onEndKeyDown = () => {
|
|
if (disabled.value)
|
|
return;
|
|
setPosition(100);
|
|
emitChange();
|
|
};
|
|
const onKeyDown = (event) => {
|
|
const code = getEventCode(event);
|
|
let isPreventDefault = true;
|
|
switch (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;
|
|
newPosition = clamp_default(newPosition, 0, 100);
|
|
let value;
|
|
if (step2.value === "mark")
|
|
if (markList.value.length === 0)
|
|
value = newPosition <= 50 ? min4.value : max4.value;
|
|
else
|
|
value = markList.value.reduce((prev, curr) => {
|
|
return Math.abs(curr.position - newPosition) < Math.abs(prev.position - newPosition) ? curr : prev;
|
|
}).point;
|
|
else {
|
|
const fullSteps = Math.floor((max4.value - min4.value) / step2.value);
|
|
const fullRangePercentage = fullSteps * step2.value / (max4.value - min4.value) * 100;
|
|
const threshold = fullRangePercentage + (100 - fullRangePercentage) / 2;
|
|
if (newPosition < fullRangePercentage) {
|
|
const valueBetween = fullRangePercentage / fullSteps;
|
|
const steps = Math.round(newPosition / valueBetween);
|
|
value = min4.value + steps * step2.value;
|
|
} else if (newPosition < threshold)
|
|
value = min4.value + fullSteps * step2.value;
|
|
else
|
|
value = max4.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/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/button.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_163 = ["tabindex"];
|
|
var button_vue_vue_type_script_setup_true_lang_default2 = defineComponent({
|
|
name: "ElSliderButton",
|
|
__name: "button",
|
|
props: sliderButtonProps,
|
|
emits: sliderButtonEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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) ? void 0 : 0,
|
|
onMouseenter: _cache[0] || (_cache[0] = (...args) => unref(handleMouseEnter) && unref(handleMouseEnter)(...args)),
|
|
onMouseleave: _cache[1] || (_cache[1] = (...args) => unref(handleMouseLeave) && unref(handleMouseLeave)(...args)),
|
|
onMousedown: _cache[2] || (_cache[2] = (...args) => unref(onButtonDown) && unref(onButtonDown)(...args)),
|
|
onFocus: _cache[3] || (_cache[3] = (...args) => unref(handleMouseEnter) && unref(handleMouseEnter)(...args)),
|
|
onBlur: _cache[4] || (_cache[4] = (...args) => unref(handleMouseLeave) && unref(handleMouseLeave)(...args)),
|
|
onKeydown: _cache[5] || (_cache[5] = (...args) => unref(onKeyDown) && unref(onKeyDown)(...args))
|
|
}, [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: tooltipPersistent.value
|
|
}, {
|
|
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, _hoisted_163);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/slider/src/button2.mjs
|
|
var button_default2 = button_vue_vue_type_script_setup_true_lang_default2;
|
|
|
|
// node_modules/element-plus/es/components/slider/src/marker.mjs
|
|
var sliderMarkerProps = buildProps({ mark: {
|
|
type: definePropType([String, Object]),
|
|
default: void 0
|
|
} });
|
|
var marker_default = 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/slider.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_164 = [
|
|
"id",
|
|
"role",
|
|
"aria-label",
|
|
"aria-labelledby"
|
|
];
|
|
var _hoisted_234 = { key: 1 };
|
|
var slider_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElSlider",
|
|
__name: "slider",
|
|
props: sliderProps,
|
|
emits: sliderEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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: minValue3, maxValue: maxValue3, runwayStyle, barStyle, resetSize, emitChange, onSliderWrapperPrevent, onSliderClick, onSliderDown, onSliderMarkerDown, setFirstValue, setSecondValue } = useSlide(props2, initData, emit);
|
|
const { stops, getStopStyle } = useStops(props2, initData, minValue3, maxValue3);
|
|
const { inputId, isLabeledByFormItem } = useFormItemInputId(props2, { formItemContext: elFormItem });
|
|
const sliderWrapperSize = useFormSize();
|
|
const sliderInputSize = computed(() => props2.inputSize || sliderWrapperSize.value);
|
|
const renderInput = computed(() => {
|
|
return props2.showInput && !props2.range && props2.step !== "mark";
|
|
});
|
|
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")]: renderInput.value }
|
|
]);
|
|
const markList = useMarks(props2);
|
|
useWatch(props2, initData, minValue3, maxValue3, emit, elFormItem);
|
|
const sliderInputStep = computed(() => {
|
|
return isNumber2(props2.step) ? props2.step : 1;
|
|
});
|
|
const precision = computed(() => {
|
|
const stepValue = isNumber2(props2.step) ? props2.step : 1;
|
|
const precisions = [
|
|
props2.min,
|
|
props2.max,
|
|
stepValue
|
|
].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,
|
|
markList,
|
|
emitChange,
|
|
resetSize,
|
|
updateDragging
|
|
});
|
|
__expose({ onSliderClick });
|
|
return (_ctx, _cache) => {
|
|
var _a, _b;
|
|
return openBlock(), createElementBlock("div", {
|
|
id: _ctx.range ? unref(inputId) : void 0,
|
|
ref_key: "sliderWrapper",
|
|
ref: sliderWrapper,
|
|
class: normalizeClass(sliderKls.value),
|
|
role: _ctx.range ? "group" : void 0,
|
|
"aria-label": _ctx.range && !unref(isLabeledByFormItem) ? groupLabel.value : void 0,
|
|
"aria-labelledby": _ctx.range && unref(isLabeledByFormItem) ? (_a = unref(elFormItem)) == null ? void 0 : _a.labelId : void 0
|
|
}, [createBaseVNode("div", {
|
|
ref_key: "slider",
|
|
ref: slider,
|
|
class: normalizeClass([
|
|
unref(ns).e("runway"),
|
|
{ "show-input": renderInput.value },
|
|
unref(ns).is("disabled", unref(sliderDisabled))
|
|
]),
|
|
style: normalizeStyle(unref(runwayStyle)),
|
|
onMousedown: _cache[0] || (_cache[0] = (...args) => unref(onSliderDown) && unref(onSliderDown)(...args)),
|
|
onTouchstartPassive: _cache[1] || (_cache[1] = (...args) => unref(onSliderDown) && unref(onSliderDown)(...args))
|
|
}, [
|
|
createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("bar")),
|
|
style: normalizeStyle(unref(barStyle))
|
|
}, null, 6),
|
|
createVNode(button_default2, {
|
|
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) ? firstButtonLabel.value : 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": firstValueText.value,
|
|
"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(button_default2, {
|
|
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": secondButtonLabel.value,
|
|
"aria-valuemin": unref(firstValue),
|
|
"aria-valuemax": _ctx.max,
|
|
"aria-valuenow": unref(secondValue),
|
|
"aria-valuetext": secondValueText.value,
|
|
"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", _hoisted_234, [(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(marker_default), {
|
|
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)
|
|
], 38), renderInput.value ? (openBlock(), createBlock(unref(ElInputNumber), {
|
|
key: 0,
|
|
ref: "input",
|
|
"model-value": unref(firstValue),
|
|
class: normalizeClass(unref(ns).e("input")),
|
|
step: sliderInputStep.value,
|
|
disabled: unref(sliderDisabled),
|
|
controls: _ctx.showInputControls,
|
|
min: _ctx.min,
|
|
max: _ctx.max,
|
|
precision: precision.value,
|
|
size: sliderInputSize.value,
|
|
"onUpdate:modelValue": unref(setFirstValue),
|
|
onChange: unref(emitChange)
|
|
}, null, 8, [
|
|
"model-value",
|
|
"class",
|
|
"step",
|
|
"disabled",
|
|
"controls",
|
|
"min",
|
|
"max",
|
|
"precision",
|
|
"size",
|
|
"onUpdate:modelValue",
|
|
"onChange"
|
|
])) : createCommentVNode("v-if", true)], 10, _hoisted_164);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/slider/src/slider2.mjs
|
|
var slider_default = slider_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/slider/index.mjs
|
|
var ElSlider = withInstall(slider_default);
|
|
|
|
// 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(() => {
|
|
return [
|
|
props2.wrap || props2.fill ? { flexWrap: "wrap" } : {},
|
|
{ alignItems: props2.alignment },
|
|
{
|
|
rowGap: `${verticalSize.value}px`,
|
|
columnGap: `${horizontalSize.value}px`
|
|
},
|
|
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 if (isVNode(nested) && (nested == null ? void 0 : nested.type) === Comment)
|
|
extractedChildren.push(nested);
|
|
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 _a;
|
|
const { spacer, direction: direction2 } = props2;
|
|
const children = renderSlot(slots, "default", { key: 0 }, () => []);
|
|
if (((_a = children.children) != null ? _a : []).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/statistic.vue_vue_type_script_setup_true_lang.mjs
|
|
var statistic_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElStatistic",
|
|
__name: "statistic",
|
|
props: statisticProps,
|
|
setup(__props, { expose: __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 || __props.title ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("head"))
|
|
}, [renderSlot(_ctx.$slots, "title", {}, () => [createTextVNode(toDisplayString(__props.title), 1)])], 2)) : createCommentVNode("v-if", true), createBaseVNode("div", { class: normalizeClass(unref(ns).e("content")) }, [
|
|
_ctx.$slots.prefix || __props.prefix ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("prefix"))
|
|
}, [renderSlot(_ctx.$slots, "prefix", {}, () => [createBaseVNode("span", null, toDisplayString(__props.prefix), 1)])], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(ns).e("number")),
|
|
style: normalizeStyle(__props.valueStyle)
|
|
}, toDisplayString(displayValue.value), 7),
|
|
_ctx.$slots.suffix || __props.suffix ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("suffix"))
|
|
}, [renderSlot(_ctx.$slots, "suffix", {}, () => [createBaseVNode("span", null, toDisplayString(__props.suffix), 1)])], 2)) : createCommentVNode("v-if", true)
|
|
], 2)], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/statistic/src/statistic2.mjs
|
|
var statistic_default = statistic_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/statistic/index.mjs
|
|
var ElStatistic = withInstall(statistic_default);
|
|
|
|
// 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;
|
|
return 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).replace(/\[([^\]]*)]/g, "$1");
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/countdown/src/countdown.vue_vue_type_script_setup_true_lang.mjs
|
|
var countdown_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElCountdown",
|
|
__name: "countdown",
|
|
props: countdownProps,
|
|
emits: countdownEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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: __props.title,
|
|
prefix: __props.prefix,
|
|
suffix: __props.suffix,
|
|
"value-style": __props.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"
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/countdown/src/countdown2.mjs
|
|
var countdown_default = countdown_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/countdown/index.mjs
|
|
var ElCountdown = withInstall(countdown_default);
|
|
|
|
// 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/tokens.mjs
|
|
var STEPS_INJECTION_KEY = "ElSteps";
|
|
|
|
// 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/steps.vue_vue_type_script_setup_true_lang.mjs
|
|
var steps_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElSteps",
|
|
__name: "steps",
|
|
props: stepsProps,
|
|
emits: stepsEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const ns = useNamespace("steps");
|
|
const { children: steps, addChild: addStep, removeChild: removeStep, ChildrenSorter: StepsSorter } = useOrderedChildren(getCurrentInstance(), "ElStep");
|
|
watch(steps, () => {
|
|
steps.value.forEach((instance, index) => {
|
|
instance.setIndex(index);
|
|
});
|
|
});
|
|
provide(STEPS_INJECTION_KEY, {
|
|
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(__props.simple ? "simple" : __props.direction)]) }, [renderSlot(_ctx.$slots, "default"), createVNode(unref(StepsSorter))], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/steps/src/steps2.mjs
|
|
var steps_default = steps_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/steps/src/item.vue_vue_type_script_setup_true_lang.mjs
|
|
var item_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElStep",
|
|
__name: "item",
|
|
props: stepProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const ns = useNamespace("step");
|
|
const index = ref(-1);
|
|
const lineStyle = ref({});
|
|
const internalStatus = ref("");
|
|
const parent2 = inject(STEPS_INJECTION_KEY);
|
|
const currentInstance = getCurrentInstance();
|
|
let stepDiff = 0;
|
|
let beforeActive = 0;
|
|
onMounted(() => {
|
|
watch([
|
|
() => parent2.props.active,
|
|
() => parent2.props.processStatus,
|
|
() => parent2.props.finishStatus
|
|
], ([active], [oldActive]) => {
|
|
beforeActive = oldActive || 0;
|
|
stepDiff = active - beforeActive;
|
|
updateStatus(active);
|
|
}, { immediate: true });
|
|
});
|
|
const currentStatus = computed(() => {
|
|
return props2.status || internalStatus.value;
|
|
});
|
|
const prevInternalStatus = computed(() => {
|
|
const prevStep = parent2.steps.value[index.value - 1];
|
|
return prevStep ? prevStep.internalStatus.value : "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 _a;
|
|
return ((_a = parent2.steps.value[stepsCount.value - 1]) == null ? void 0 : _a.uid) === 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: `${Math.abs(stepDiff) === 1 ? 0 : stepDiff > 0 ? (index.value + 1 - beforeActive) * 150 : -(index.value + 1 - parent2.props.active) * 150}ms` };
|
|
const step2 = status === parent2.props.processStatus || isWait ? 0 : 100;
|
|
style2.borderWidth = step2 && !isSimple.value ? "1px" : 0;
|
|
style2[parent2.props.direction === "vertical" ? "height" : "width"] = `${step2}%`;
|
|
lineStyle.value = style2;
|
|
};
|
|
const updateStatus = (activeIndex) => {
|
|
if (activeIndex > index.value)
|
|
internalStatus.value = parent2.props.finishStatus;
|
|
else if (activeIndex === index.value && prevInternalStatus.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 = {
|
|
uid: currentInstance.uid,
|
|
getVnode: () => currentInstance.vnode,
|
|
currentStatus,
|
|
internalStatus,
|
|
setIndex,
|
|
calcProgress
|
|
};
|
|
parent2.addStep(stepItemState);
|
|
onBeforeUnmount(() => {
|
|
parent2.removeStep(stepItemState);
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
style: normalizeStyle(style.value),
|
|
class: normalizeClass(containerKls.value)
|
|
}, [
|
|
createCommentVNode(" icon & line "),
|
|
createBaseVNode("div", { class: normalizeClass([unref(ns).e("head"), unref(ns).is(currentStatus.value)]) }, [!isSimple.value ? (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(__props.icon || _ctx.$slots.icon ? "icon" : "text")]) }, [renderSlot(_ctx.$slots, "icon", {}, () => [__props.icon ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("icon-inner"))
|
|
}, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.icon)))]),
|
|
_: 1
|
|
}, 8, ["class"])) : currentStatus.value === "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"])) : currentStatus.value === "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"])) : !isSimple.value ? (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(currentStatus.value)]) }, [renderSlot(_ctx.$slots, "title", {}, () => [createTextVNode(toDisplayString(__props.title), 1)])], 2), isSimple.value ? (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(currentStatus.value)])
|
|
}, [renderSlot(_ctx.$slots, "description", {}, () => [createTextVNode(toDisplayString(__props.description), 1)])], 2))], 2)
|
|
], 6);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/steps/src/item2.mjs
|
|
var item_default = item_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/steps/index.mjs
|
|
var ElSteps = withInstall(steps_default, { Step: item_default });
|
|
var ElStep = withNoopInstall(item_default);
|
|
|
|
// 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: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
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/switch.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_165 = [
|
|
"id",
|
|
"aria-checked",
|
|
"aria-disabled",
|
|
"aria-label",
|
|
"name",
|
|
"true-value",
|
|
"false-value",
|
|
"disabled",
|
|
"tabindex"
|
|
];
|
|
var _hoisted_235 = ["aria-hidden"];
|
|
var _hoisted_315 = { key: 1 };
|
|
var _hoisted_410 = { key: 1 };
|
|
var _hoisted_59 = ["aria-hidden"];
|
|
var COMPONENT_NAME17 = "ElSwitch";
|
|
var switch_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: COMPONENT_NAME17,
|
|
__name: "switch",
|
|
props: switchProps,
|
|
emits: switchEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const { formItem } = useFormItem();
|
|
const switchSize = useFormSize();
|
|
const ns = useNamespace("switch");
|
|
const { inputId } = useFormItemInputId(props2, { formItemContext: formItem });
|
|
const switchDisabled = useFormDisabled(computed(() => {
|
|
if (props2.loading)
|
|
return true;
|
|
}));
|
|
const isControlled = ref(props2.modelValue !== false);
|
|
const input = shallowRef();
|
|
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 _a;
|
|
input.value.checked = val;
|
|
if (props2.validateEvent)
|
|
(_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.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();
|
|
if (![isPromise(shouldChange), isBoolean2(shouldChange)].includes(true))
|
|
throwError(COMPONENT_NAME17, "beforeChange must return type `Promise<boolean>` or `boolean`");
|
|
if (isPromise(shouldChange))
|
|
shouldChange.then((result2) => {
|
|
if (result2)
|
|
handleChange();
|
|
}).catch((e) => {
|
|
debugWarn(COMPONENT_NAME17, `some error occurred: ${e}`);
|
|
});
|
|
else if (shouldChange)
|
|
handleChange();
|
|
};
|
|
const focus = () => {
|
|
var _a, _b;
|
|
(_b = (_a = input.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
|
|
};
|
|
onMounted(() => {
|
|
input.value.checked = checked.value;
|
|
});
|
|
__expose({
|
|
focus,
|
|
checked
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass(switchKls.value),
|
|
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": checked.value,
|
|
"aria-disabled": unref(switchDisabled),
|
|
"aria-label": __props.ariaLabel,
|
|
name: __props.name,
|
|
"true-value": __props.activeValue,
|
|
"false-value": __props.inactiveValue,
|
|
disabled: unref(switchDisabled),
|
|
tabindex: __props.tabindex,
|
|
onChange: handleChange,
|
|
onKeydown: withKeys(switchValue, ["enter"])
|
|
}, null, 42, _hoisted_165),
|
|
!__props.inlinePrompt && (__props.inactiveIcon || __props.inactiveText || _ctx.$slots.inactive) ? (openBlock(), createElementBlock("span", {
|
|
key: 0,
|
|
class: normalizeClass(labelLeftKls.value)
|
|
}, [renderSlot(_ctx.$slots, "inactive", {}, () => [__props.inactiveIcon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.inactiveIcon)))]),
|
|
_: 1
|
|
})) : createCommentVNode("v-if", true), !__props.inactiveIcon && __props.inactiveText ? (openBlock(), createElementBlock("span", {
|
|
key: 1,
|
|
"aria-hidden": checked.value
|
|
}, toDisplayString(__props.inactiveText), 9, _hoisted_235)) : createCommentVNode("v-if", true)])], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("span", {
|
|
class: normalizeClass(unref(ns).e("core")),
|
|
style: normalizeStyle(coreStyle.value)
|
|
}, [__props.inlinePrompt ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("inner"))
|
|
}, [!checked.value ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("inner-wrapper"))
|
|
}, [renderSlot(_ctx.$slots, "inactive", {}, () => [__props.inactiveIcon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.inactiveIcon)))]),
|
|
_: 1
|
|
})) : createCommentVNode("v-if", true), !__props.inactiveIcon && __props.inactiveText ? (openBlock(), createElementBlock("span", _hoisted_315, toDisplayString(__props.inactiveText), 1)) : createCommentVNode("v-if", true)])], 2)) : (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("inner-wrapper"))
|
|
}, [renderSlot(_ctx.$slots, "active", {}, () => [__props.activeIcon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.activeIcon)))]),
|
|
_: 1
|
|
})) : createCommentVNode("v-if", true), !__props.activeIcon && __props.activeText ? (openBlock(), createElementBlock("span", _hoisted_410, toDisplayString(__props.activeText), 1)) : createCommentVNode("v-if", true)])], 2))], 2)) : createCommentVNode("v-if", true), createBaseVNode("div", { class: normalizeClass(unref(ns).e("action")) }, [__props.loading ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).is("loading"))
|
|
}, {
|
|
default: withCtx(() => [createVNode(unref(loading_default))]),
|
|
_: 1
|
|
}, 8, ["class"])) : checked.value ? renderSlot(_ctx.$slots, "active-action", { key: 1 }, () => [__props.activeActionIcon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.activeActionIcon)))]),
|
|
_: 1
|
|
})) : createCommentVNode("v-if", true)]) : !checked.value ? renderSlot(_ctx.$slots, "inactive-action", { key: 2 }, () => [__props.inactiveActionIcon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.inactiveActionIcon)))]),
|
|
_: 1
|
|
})) : createCommentVNode("v-if", true)]) : createCommentVNode("v-if", true)], 2)], 6),
|
|
!__props.inlinePrompt && (__props.activeIcon || __props.activeText || _ctx.$slots.active) ? (openBlock(), createElementBlock("span", {
|
|
key: 1,
|
|
class: normalizeClass(labelRightKls.value)
|
|
}, [renderSlot(_ctx.$slots, "active", {}, () => [__props.activeIcon ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.activeIcon)))]),
|
|
_: 1
|
|
})) : createCommentVNode("v-if", true), !__props.activeIcon && __props.activeText ? (openBlock(), createElementBlock("span", {
|
|
key: 1,
|
|
"aria-hidden": !checked.value
|
|
}, toDisplayString(__props.activeText), 9, _hoisted_59)) : createCommentVNode("v-if", true)])], 2)) : createCommentVNode("v-if", true)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/switch/src/switch2.mjs
|
|
var switch_default = switch_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/switch/index.mjs
|
|
var ElSwitch = withInstall(switch_default);
|
|
|
|
// node_modules/element-plus/es/components/table/src/util.mjs
|
|
var getCell = function(event) {
|
|
var _a;
|
|
return (_a = event.target) == null ? void 0 : _a.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)
|
|
return flatMap_default(castArray_default(sortBy2), (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) ? sortKey ? get_default(value, sortKey) : null : value];
|
|
};
|
|
const compare = function(a2, b2) {
|
|
var _a, _b, _c, _d, _e, _f;
|
|
if (sortMethod)
|
|
return sortMethod(a2.value, b2.value);
|
|
for (let i = 0, len = (_b = (_a = a2.key) == null ? void 0 : _a.length) != null ? _b : 0; i < len; i++) {
|
|
if (((_c = a2.key) == null ? void 0 : _c[i]) < ((_d = b2.key) == null ? void 0 : _d[i]))
|
|
return -1;
|
|
if (((_e = a2.key) == null ? void 0 : _e[i]) > ((_f = b2.key) == null ? void 0 : _f[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);
|
|
return "";
|
|
};
|
|
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, rowKey2) {
|
|
let _rowIndex = rowIndex != null ? rowIndex : 0;
|
|
let changed = false;
|
|
const getIndex = () => {
|
|
if (!rowKey2)
|
|
return statusArr.indexOf(row);
|
|
const id = getRowIdentity(row, rowKey2);
|
|
return statusArr.findIndex((item) => getRowIdentity(item, rowKey2) === id);
|
|
};
|
|
const index = getIndex();
|
|
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, rowKey2);
|
|
_rowIndex += getChildrenCount(item) + 1;
|
|
if (childChanged)
|
|
changed = childChanged;
|
|
});
|
|
return changed;
|
|
}
|
|
function walkTreeNode(root2, cb, childrenKey = "children", lazyKey = "hasChildren", lazy = false) {
|
|
const isNil2 = (array4) => !(isArray(array4) && array4.length);
|
|
function _walker(parent2, children, level) {
|
|
cb(parent2, children, level);
|
|
children.forEach((item) => {
|
|
if (item[lazyKey] && lazy) {
|
|
cb(item, null, level + 1);
|
|
return;
|
|
}
|
|
const children2 = item[childrenKey];
|
|
if (!isNil2(children2))
|
|
_walker(item, children2, level + 1);
|
|
});
|
|
}
|
|
root2.forEach((item) => {
|
|
if (item[lazyKey] && lazy) {
|
|
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 == null ? void 0 : 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) {
|
|
var _a;
|
|
const tableOverflowTooltipProps = getTableOverflowTooltipProps(props2, popperContent, row, column2);
|
|
const mergedProps = {
|
|
...tableOverflowTooltipProps,
|
|
slotContent: void 0
|
|
};
|
|
if ((removePopper == null ? void 0 : removePopper.trigger) === trigger) {
|
|
const comp = (_a = removePopper.vm) == null ? void 0 : _a.component;
|
|
merge_default(comp == null ? void 0 : comp.props, mergedProps);
|
|
if (comp && 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 = () => {
|
|
var _a2, _b;
|
|
if ((_b = (_a2 = vm.component) == null ? void 0 : _a2.exposed) == null ? void 0 : _b.onClose)
|
|
vm.component.exposed.onClose();
|
|
render(null, container);
|
|
const currentRemovePopper = removePopper;
|
|
scrollContainer == null ? void 0 : scrollContainer.removeEventListener("scroll", currentRemovePopper);
|
|
currentRemovePopper.trigger = void 0;
|
|
currentRemovePopper.vm = void 0;
|
|
removePopper = null;
|
|
};
|
|
removePopper.trigger = trigger != null ? trigger : void 0;
|
|
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]);
|
|
start = columns2.slice(0, columns2.indexOf(curColumns[0])).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 getOffset2(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(getOffset2, 0);
|
|
else
|
|
styles.right = columns2.slice(after2 + 1).reverse().reduce(getOffset2, 0);
|
|
return styles;
|
|
};
|
|
var ensurePosition = (style, key) => {
|
|
if (!style)
|
|
return;
|
|
if (!Number.isNaN(style[key]))
|
|
style[key] = `${style[key]}px`;
|
|
};
|
|
function ensureValidVNode(vnodes) {
|
|
return vnodes.some((child) => {
|
|
if (!isVNode(child))
|
|
return true;
|
|
if (child.type === Comment)
|
|
return false;
|
|
if (child.type === Fragment && !ensureValidVNode(child.children))
|
|
return false;
|
|
return true;
|
|
}) ? vnodes : null;
|
|
}
|
|
|
|
// 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 canRowExpand = (row, index) => {
|
|
var _a;
|
|
const expandableFn = instance.store.states.rowExpandable.value;
|
|
return (_a = expandableFn == null ? void 0 : expandableFn(row, index)) != null ? _a : true;
|
|
};
|
|
const updateExpandRows = () => {
|
|
const data = watcherData.data.value || [];
|
|
const rowKey2 = watcherData.rowKey.value;
|
|
if (defaultExpandAll.value)
|
|
expandRows.value = instance.store.states.rowExpandable.value ? data.filter(canRowExpand) : data.slice();
|
|
else if (rowKey2) {
|
|
const expandRowsMap = getKeysMap(expandRows.value, rowKey2);
|
|
expandRows.value = data.filter((row, index) => {
|
|
return !!expandRowsMap[getRowIdentity(row, rowKey2)] && canRowExpand(row, index);
|
|
});
|
|
} else
|
|
expandRows.value = [];
|
|
};
|
|
const toggleRowExpansion = (row, expanded) => {
|
|
const rowIndex = (watcherData.data.value || []).indexOf(row);
|
|
if (rowIndex > -1 && !canRowExpand(row, rowIndex))
|
|
return;
|
|
if (toggleRowStatus(expandRows.value, row, expanded, void 0, void 0, void 0, watcherData.rowKey.value))
|
|
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 && canRowExpand(info.row, info.index))
|
|
prev.push(info.row);
|
|
return prev;
|
|
}, []);
|
|
};
|
|
const isRowExpanded = (row) => {
|
|
const rowKey2 = watcherData.rowKey.value;
|
|
if (rowKey2)
|
|
return !!getKeysMap(expandRows.value, rowKey2)[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) => {
|
|
var _a;
|
|
const { data, rowKey: rowKey2 } = watcherData;
|
|
const oldCurrentRow = currentRow.value;
|
|
let _currentRow = null;
|
|
if (rowKey2.value)
|
|
_currentRow = (_a = (unref(data) || []).find((item) => getRowIdentity(item, rowKey2.value) === key)) != null ? _a : null;
|
|
currentRow.value = _currentRow != null ? _currentRow : null;
|
|
instance.emit("current-change", currentRow.value, oldCurrentRow);
|
|
};
|
|
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 (oldCurrentRow && !data.includes(oldCurrentRow))
|
|
if (rowKey2)
|
|
setCurrentRowByKey(getRowIdentity(oldCurrentRow, rowKey2));
|
|
else {
|
|
currentRow.value = null;
|
|
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 {};
|
|
return normalize(watcherData.data.value || []);
|
|
});
|
|
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, lazy.value);
|
|
return res;
|
|
};
|
|
const updateTreeData = (ifChangeExpandRowKeys = false, ifExpandAll) => {
|
|
var _a, _b;
|
|
ifExpandAll || (ifExpandAll = (_a = instance.store) == null ? void 0 : _a.states.defaultExpandAll.value);
|
|
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) => {
|
|
var _a2;
|
|
const oldValue = oldTreeData[key];
|
|
const lazyNodeChildren = normalizedLazyNode_[key].children;
|
|
if (rootLazyRowKeys.includes(key)) {
|
|
if (((_a2 = newTreeData[key].children) == null ? void 0 : _a2.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: void 0
|
|
};
|
|
}
|
|
});
|
|
}
|
|
treeData.value = newTreeData;
|
|
(_b = instance.store) == null ? void 0 : _b.updateTableScrollY();
|
|
};
|
|
watch(() => expandRowKeys.value, () => {
|
|
updateTreeData(true);
|
|
}, { deep: 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);
|
|
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 _a;
|
|
const instance = getCurrentInstance();
|
|
const { size: tableSize } = toRefs((_a = instance.proxy) == null ? void 0 : _a.$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 rowExpandable = 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 _a2;
|
|
if (instance.state) {
|
|
scheduleLayout(false);
|
|
if (instance.props.tableLayout === "auto")
|
|
(_a2 = instance.refs.tableHeaderRef) == null ? void 0 : _a2.updateFixedColumnStyle();
|
|
}
|
|
}, { deep: true });
|
|
const assertRowKey = () => {
|
|
if (!rowKey2.value)
|
|
throw new Error("[ElTable] prop row-key is required");
|
|
};
|
|
const updateChildFixed = (column2) => {
|
|
var _a2;
|
|
(_a2 = column2.children) == null ? void 0 : _a2.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)) {
|
|
if (_columns.value.indexOf(selectColumn) === 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 = Array.from(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 = Array.from(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 _a2, _b;
|
|
let deleted;
|
|
if (rowKey2.value) {
|
|
deleted = [];
|
|
const childrenKey = (_b = (_a2 = instance == null ? void 0 : instance.store) == null ? void 0 : _a2.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 _a2, _b, _c, _d;
|
|
const treeProps3 = {
|
|
children: (_b = (_a2 = instance == null ? void 0 : instance.store) == null ? void 0 : _a2.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
|
|
};
|
|
if (toggleRowStatus(selection.value, row, selected, treeProps3, ignoreSelectable ? void 0 : selectable.value, data.value.indexOf(row), rowKey2.value)) {
|
|
const newSelection = (selection.value || []).slice();
|
|
if (emitChange)
|
|
instance.emit("select", newSelection, row);
|
|
instance.emit("selection-change", newSelection);
|
|
}
|
|
};
|
|
const _toggleAllSelection = () => {
|
|
var _a2, _b;
|
|
const value = selectOnIndeterminate.value ? !isAllSelected.value : !(isAllSelected.value || selection.value.length);
|
|
isAllSelected.value = value;
|
|
let selectionChanged = false;
|
|
let childrenCount = 0;
|
|
const rowKey3 = (_b = (_a2 = instance == null ? void 0 : instance.store) == null ? void 0 : _a2.states) == null ? void 0 : _b.rowKey.value;
|
|
const { childrenColumnName } = instance.store.states;
|
|
const treeProps3 = {
|
|
children: childrenColumnName.value,
|
|
checkStrictly: false
|
|
};
|
|
data.value.forEach((row, index) => {
|
|
const rowIndex = index + childrenCount;
|
|
if (toggleRowStatus(selection.value, row, value, treeProps3, selectable.value, rowIndex, rowKey3))
|
|
selectionChanged = true;
|
|
childrenCount += getChildrenCount(getRowIdentity(row, rowKey3));
|
|
});
|
|
if (selectionChanged)
|
|
instance.emit("selection-change", selection.value ? selection.value.slice() : []);
|
|
instance.emit("select-all", (selection.value || []).slice());
|
|
};
|
|
const updateAllSelected = () => {
|
|
var _a2;
|
|
if (((_a2 = data.value) == null ? void 0 : _a2.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 = (rowKey3) => {
|
|
var _a2;
|
|
if (!instance || !instance.store)
|
|
return 0;
|
|
const { treeData } = instance.store.states;
|
|
let count = 0;
|
|
const children = (_a2 = treeData.value[rowKey3]) == null ? void 0 : _a2.children;
|
|
if (children) {
|
|
count += children.length;
|
|
children.forEach((childKey) => {
|
|
count += getChildrenCount(childKey);
|
|
});
|
|
}
|
|
return count;
|
|
};
|
|
const updateFilters = (column2, values2) => {
|
|
const filters_ = {};
|
|
castArray_default(column2).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 = () => {
|
|
var _a2;
|
|
data.value = sortData((_a2 = filteredData.value) != null ? _a2 : [], {
|
|
sortingColumn: sortingColumn.value,
|
|
sortProp: sortProp.value,
|
|
sortOrder: sortOrder.value
|
|
});
|
|
};
|
|
const execQuery = (ignore = void 0) => {
|
|
if (!(ignore == null ? void 0 : 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) => {
|
|
if (columns2.value.some(({ type: type4 }) => type4 === "expand"))
|
|
toggleRowExpansion(row, expanded);
|
|
else
|
|
toggleTreeExpansion(row, expanded);
|
|
};
|
|
return {
|
|
assertRowKey,
|
|
updateColumns,
|
|
scheduleLayout,
|
|
isSelected,
|
|
clearSelection,
|
|
cleanSelection,
|
|
getSelectionRows,
|
|
toggleRowSelection,
|
|
_toggleAllSelection,
|
|
toggleAllSelection: null,
|
|
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,
|
|
rowExpandable,
|
|
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 _a;
|
|
if (item.id === column2.id)
|
|
return column2;
|
|
else if ((_a = item.children) == null ? void 0 : _a.length)
|
|
item.children = replaceColumn(item.children, column2);
|
|
return item;
|
|
});
|
|
}
|
|
function sortColumn(array4) {
|
|
array4.forEach((item) => {
|
|
var _a, _b;
|
|
item.no = (_a = item.getColumnIndex) == null ? void 0 : _a.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 { t } = useLocale();
|
|
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();
|
|
else if (dataInstanceChanged)
|
|
instance.store.clearSelection();
|
|
else
|
|
instance.store.cleanSelection();
|
|
instance.store.updateAllSelected();
|
|
if (instance.$ready)
|
|
instance.store.scheduleLayout();
|
|
},
|
|
insertColumn(states, column2, parent2, updateColumnOrder) {
|
|
var _a;
|
|
const array4 = unref(states._columns);
|
|
let newColumns = [];
|
|
if (!parent2) {
|
|
array4.push(column2);
|
|
newColumns = array4;
|
|
} else {
|
|
if (parent2 && !parent2.children)
|
|
parent2.children = [];
|
|
(_a = parent2.children) == null ? void 0 : _a.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 _a;
|
|
if (((_a = column2.getColumnIndex) == null ? void 0 : _a.call(column2)) === column2.no)
|
|
return;
|
|
sortColumn(states._columns.value);
|
|
if (instance.$ready)
|
|
instance.store.updateColumns();
|
|
},
|
|
removeColumn(states, column2, parent2, updateColumnOrder) {
|
|
var _a;
|
|
const array4 = unref(states._columns) || [];
|
|
if (parent2) {
|
|
(_a = parent2.children) == null ? void 0 : _a.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((column3) => column3.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;
|
|
}
|
|
instance.store.execQuery({ filter: true });
|
|
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() {
|
|
var _a, _b;
|
|
(_b = (_a = instance.store).toggleAllSelection) == null ? void 0 : _b.call(_a);
|
|
},
|
|
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, ...args]);
|
|
else
|
|
throw new Error(`Action not found: ${name}`);
|
|
};
|
|
const updateTableScrollY = function() {
|
|
nextTick(() => instance.layout.updateScrollY.apply(instance.layout));
|
|
};
|
|
return {
|
|
ns,
|
|
t,
|
|
...watcher,
|
|
mutations,
|
|
commit,
|
|
updateTableScrollY
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/store/helper.mjs
|
|
var InitialStateMap = {
|
|
rowKey: "rowKey",
|
|
defaultExpandAll: "defaultExpandAll",
|
|
rowExpandable: "rowExpandable",
|
|
selectOnIndeterminate: "selectOnIndeterminate",
|
|
indent: "indent",
|
|
lazy: "lazy",
|
|
["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(storeKey)) {
|
|
newVal = newVal || storeKey.default;
|
|
storeKey = storeKey.key;
|
|
}
|
|
store.states[storeKey].value = newVal;
|
|
}
|
|
function getArrKeysValue(props2, key) {
|
|
if (key.includes(".")) {
|
|
const keyList = key.split(".");
|
|
let value = props2;
|
|
keyList.forEach((k) => {
|
|
value = value[k];
|
|
});
|
|
return value;
|
|
} else
|
|
return props2[key];
|
|
}
|
|
|
|
// 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)) {
|
|
nextTick(() => this.setHeight(value, prop));
|
|
return;
|
|
}
|
|
if (el && isNumber2(value)) {
|
|
el.style[prop] = `${value}px`;
|
|
this.updateElsHeight();
|
|
} else if (el && isString(value)) {
|
|
el.style[prop] = value;
|
|
this.updateElsHeight();
|
|
}
|
|
}
|
|
setMaxHeight(value) {
|
|
this.setHeight(value, "max-height");
|
|
}
|
|
getFlattenColumns() {
|
|
const flattenColumns = [];
|
|
this.table.store.states.columns.value.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() {
|
|
var _a;
|
|
if (!isClient)
|
|
return;
|
|
const fit = this.fit;
|
|
const bodyWidth = (_a = this.table.vnode.el) == null ? void 0 : _a.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 flexWidthPerPixel = totalFlexWidth / flexColumns.reduce((prev, column2) => prev + Number(column2.minWidth || 80), 0);
|
|
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) {
|
|
this.observers.forEach((observer) => {
|
|
var _a, _b;
|
|
switch (event) {
|
|
case "columns":
|
|
(_a = observer.state) == null ? void 0 : _a.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/tokens.mjs
|
|
var TABLE_INJECTION_KEY = Symbol("ElTable");
|
|
|
|
// 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([]);
|
|
getAllColumns(originColumns).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/filter-panel.vue_vue_type_script_lang.mjs
|
|
var filter_panel_vue_vue_type_script_lang_default = defineComponent({
|
|
name: "ElTableFilterPanel",
|
|
components: {
|
|
ElCheckbox,
|
|
ElCheckboxGroup,
|
|
ElScrollbar,
|
|
ElTooltip,
|
|
ElIcon,
|
|
ArrowDown: arrow_down_default,
|
|
ArrowUp: arrow_up_default
|
|
},
|
|
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 (props2.column && !parent2.filterPanels.value[props2.column.id])
|
|
parent2.filterPanels.value[props2.column.id] = instance;
|
|
const tooltipRef = ref(null);
|
|
const rootRef = ref(null);
|
|
const checkedIndex = ref(0);
|
|
const filters = computed(() => {
|
|
return props2.column && props2.column.filters;
|
|
});
|
|
const filterClassName = computed(() => {
|
|
if (props2.column && props2.column.filterClassName)
|
|
return `${ns.b()} ${props2.column.filterClassName}`;
|
|
return ns.b();
|
|
});
|
|
const filterValue = computed({
|
|
get: () => {
|
|
var _a;
|
|
return (((_a = props2.column) == null ? void 0 : _a.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) {
|
|
var _a;
|
|
if (props2.column)
|
|
(_a = props2.upDataColumn) == null ? void 0 : _a.call(props2, "filteredValue", value);
|
|
}
|
|
});
|
|
const multiple = computed(() => {
|
|
if (props2.column)
|
|
return props2.column.filterMultiple;
|
|
return true;
|
|
});
|
|
const isActive = (filter2) => {
|
|
return filter2.value === filterValue.value;
|
|
};
|
|
const hidden = () => {
|
|
var _a;
|
|
(_a = tooltipRef.value) == null ? void 0 : _a.onClose();
|
|
};
|
|
const handleConfirm = () => {
|
|
confirmFilter(filteredValue.value);
|
|
hidden();
|
|
};
|
|
const handleReset = () => {
|
|
filteredValue.value = [];
|
|
confirmFilter(filteredValue.value);
|
|
hidden();
|
|
};
|
|
const handleSelect = (_filterValue, index) => {
|
|
filterValue.value = _filterValue;
|
|
checkedIndex.value = index;
|
|
if (!isPropAbsent(_filterValue))
|
|
confirmFilter(filteredValue.value);
|
|
else
|
|
confirmFilter([]);
|
|
hidden();
|
|
};
|
|
const confirmFilter = (filteredValue2) => {
|
|
var _a, _b;
|
|
(_a = props2.store) == null ? void 0 : _a.commit("filterChange", {
|
|
column: props2.column,
|
|
values: filteredValue2
|
|
});
|
|
(_b = props2.store) == null ? void 0 : _b.updateAllSelected();
|
|
};
|
|
const handleShowTooltip = () => {
|
|
var _a, _b;
|
|
(_a = rootRef.value) == null ? void 0 : _a.focus();
|
|
!multiple.value && initCheckedIndex();
|
|
if (props2.column)
|
|
(_b = props2.upDataColumn) == null ? void 0 : _b.call(props2, "filterOpened", true);
|
|
};
|
|
const handleHideTooltip = () => {
|
|
var _a;
|
|
if (props2.column)
|
|
(_a = props2.upDataColumn) == null ? void 0 : _a.call(props2, "filterOpened", false);
|
|
};
|
|
const initCheckedIndex = () => {
|
|
if (isPropAbsent(filterValue)) {
|
|
checkedIndex.value = 0;
|
|
return;
|
|
}
|
|
const idx = (filters.value || []).findIndex((item) => {
|
|
return item.value === filterValue.value;
|
|
});
|
|
checkedIndex.value = idx >= 0 ? idx + 1 : 0;
|
|
};
|
|
const handleKeydown = (event) => {
|
|
var _a, _b;
|
|
const code = getEventCode(event);
|
|
const len = (filters.value ? filters.value.length : 0) + 1;
|
|
let index = checkedIndex.value;
|
|
let isPreventDefault = true;
|
|
switch (code) {
|
|
case EVENT_CODE.down:
|
|
case EVENT_CODE.right:
|
|
index = (index + 1) % len;
|
|
break;
|
|
case EVENT_CODE.up:
|
|
case EVENT_CODE.left:
|
|
index = (index - 1 + len) % len;
|
|
break;
|
|
case EVENT_CODE.tab:
|
|
hidden();
|
|
isPreventDefault = false;
|
|
break;
|
|
case EVENT_CODE.enter:
|
|
case EVENT_CODE.space:
|
|
if (index === 0)
|
|
handleSelect(null, 0);
|
|
else {
|
|
const item = (filters.value || [])[index - 1];
|
|
item.value && handleSelect(item.value, index);
|
|
}
|
|
break;
|
|
default:
|
|
isPreventDefault = false;
|
|
break;
|
|
}
|
|
isPreventDefault && event.preventDefault();
|
|
checkedIndex.value = index;
|
|
(_b = (_a = rootRef.value) == null ? void 0 : _a.querySelector(`.${ns.e("list-item")}:nth-child(${index + 1})`)) == null ? void 0 : _b.focus();
|
|
};
|
|
return {
|
|
multiple,
|
|
filterClassName,
|
|
filteredValue,
|
|
filterValue,
|
|
filters,
|
|
handleConfirm,
|
|
handleReset,
|
|
handleSelect,
|
|
isPropAbsent,
|
|
isActive,
|
|
t,
|
|
ns,
|
|
tooltipRef,
|
|
rootRef,
|
|
checkedIndex,
|
|
handleShowTooltip,
|
|
handleHideTooltip,
|
|
handleKeydown
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table/src/filter-panel.mjs
|
|
var _hoisted_166 = ["disabled"];
|
|
var _hoisted_236 = ["tabindex", "aria-checked"];
|
|
var _hoisted_316 = [
|
|
"tabindex",
|
|
"aria-checked",
|
|
"onClick"
|
|
];
|
|
var _hoisted_411 = ["aria-label"];
|
|
function _sfc_render18(_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");
|
|
return openBlock(), createBlock(_component_el_tooltip, {
|
|
ref: "tooltipRef",
|
|
offset: 0,
|
|
placement: _ctx.placement,
|
|
"show-arrow": false,
|
|
trigger: "click",
|
|
role: "dialog",
|
|
teleported: "",
|
|
effect: "light",
|
|
pure: "",
|
|
loop: "",
|
|
"popper-class": _ctx.filterClassName,
|
|
persistent: "",
|
|
"append-to": _ctx.appendTo,
|
|
onShow: _ctx.handleShowTooltip,
|
|
onHide: _ctx.handleHideTooltip
|
|
}, {
|
|
content: withCtx(() => [_ctx.multiple ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
ref: "rootRef",
|
|
tabindex: "-1",
|
|
class: normalizeClass(_ctx.ns.e("multiple"))
|
|
}, [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": _cache[0] || (_cache[0] = ($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", "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: _cache[1] || (_cache[1] = (...args) => _ctx.handleConfirm && _ctx.handleConfirm(...args))
|
|
}, toDisplayString(_ctx.t("el.table.confirmFilter")), 11, _hoisted_166), createBaseVNode("button", {
|
|
type: "button",
|
|
onClick: _cache[2] || (_cache[2] = (...args) => _ctx.handleReset && _ctx.handleReset(...args))
|
|
}, toDisplayString(_ctx.t("el.table.resetFilter")), 1)], 2)], 2)) : (openBlock(), createElementBlock("ul", {
|
|
key: 1,
|
|
ref: "rootRef",
|
|
tabindex: "-1",
|
|
role: "radiogroup",
|
|
class: normalizeClass(_ctx.ns.e("list")),
|
|
onKeydown: _cache[4] || (_cache[4] = (...args) => _ctx.handleKeydown && _ctx.handleKeydown(...args))
|
|
}, [createBaseVNode("li", {
|
|
role: "radio",
|
|
class: normalizeClass([_ctx.ns.e("list-item"), _ctx.ns.is("active", _ctx.isPropAbsent(_ctx.filterValue))]),
|
|
tabindex: _ctx.checkedIndex === 0 ? 0 : -1,
|
|
"aria-checked": _ctx.isPropAbsent(_ctx.filterValue),
|
|
onClick: _cache[3] || (_cache[3] = ($event) => _ctx.handleSelect(null, 0))
|
|
}, toDisplayString(_ctx.t("el.table.clearFilter")), 11, _hoisted_236), (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.filters, (filter2, idx) => {
|
|
return openBlock(), createElementBlock("li", {
|
|
key: filter2.value,
|
|
role: "radio",
|
|
class: normalizeClass([_ctx.ns.e("list-item"), _ctx.ns.is("active", _ctx.isActive(filter2))]),
|
|
tabindex: _ctx.checkedIndex === idx + 1 ? 0 : -1,
|
|
"aria-checked": _ctx.isActive(filter2),
|
|
onClick: ($event) => _ctx.handleSelect(filter2.value, idx + 1)
|
|
}, toDisplayString(filter2.text), 11, _hoisted_316);
|
|
}), 128))], 34))]),
|
|
default: withCtx(() => {
|
|
var _a;
|
|
return [createBaseVNode("button", {
|
|
type: "button",
|
|
class: normalizeClass(`${_ctx.ns.namespace.value}-table__column-filter-trigger`),
|
|
"aria-label": _ctx.t("el.table.filterLabel", { column: ((_a = _ctx.column) == null ? void 0 : _a.label) || "" })
|
|
}, [createVNode(_component_el_icon, null, {
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "filter-icon", {}, () => {
|
|
var _a2;
|
|
return [((_a2 = _ctx.column) == null ? void 0 : _a2.filterOpened) ? (openBlock(), createBlock(_component_arrow_up, { key: 0 })) : (openBlock(), createBlock(_component_arrow_down, { key: 1 }))];
|
|
})]),
|
|
_: 3
|
|
})], 10, _hoisted_411)];
|
|
}),
|
|
_: 3
|
|
}, 8, [
|
|
"placement",
|
|
"popper-class",
|
|
"append-to",
|
|
"onShow",
|
|
"onHide"
|
|
]);
|
|
}
|
|
var filter_panel_default = _plugin_vue_export_helper_default(filter_panel_vue_vue_type_script_lang_default, [["render", _sfc_render18]]);
|
|
|
|
// 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 _a;
|
|
const cols = ((_a = root2.vnode.el) == null ? void 0 : _a.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 column2 = columnsMap[col.getAttribute("name")];
|
|
if (column2)
|
|
col.setAttribute("width", column2.realWidth || column2.width);
|
|
}
|
|
};
|
|
const onScrollableChange = (layout2) => {
|
|
var _a, _b;
|
|
const cols = ((_a = root2.vnode.el) == null ? void 0 : _a.querySelectorAll("colgroup > col[name=gutter]")) || [];
|
|
for (let i = 0, j = cols.length; i < j; i++)
|
|
cols[i].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/table-header/event-helper.mjs
|
|
function useEvent(props2, emit) {
|
|
const instance = getCurrentInstance();
|
|
const parent2 = inject(TABLE_INJECTION_KEY);
|
|
const handleFilterClick = (event) => {
|
|
event.stopPropagation();
|
|
};
|
|
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) => {
|
|
var _a, _b, _c;
|
|
if (!isClient)
|
|
return;
|
|
if (column2.children && column2.children.length > 0)
|
|
return;
|
|
if (draggingColumn.value && props2.border && draggingColumn.value.id === column2.id) {
|
|
dragging.value = true;
|
|
const table = parent2;
|
|
emit("set-drag-visible", true);
|
|
const tableLeft = (_a = table == null ? void 0 : table.vnode.el) == null ? void 0 : _a.getBoundingClientRect().left;
|
|
const columnEl = (_c = (_b = instance == null ? void 0 : instance.vnode) == null ? void 0 : _b.el) == null ? void 0 : _c.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;
|
|
column2.width = column2.realWidth = Number.parseInt(resizeProxy.style.left, 10) - startColumnLeft;
|
|
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 = void 0;
|
|
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 _a;
|
|
if (!props2.border || column2.children && column2.children.length > 0)
|
|
return;
|
|
const el = event.target;
|
|
const target2 = isElement2(el) ? el.closest("th") : null;
|
|
if (!target2)
|
|
return;
|
|
const isSortable = hasClass(target2, "is-sortable");
|
|
if (isSortable) {
|
|
const cursor2 = dragging.value ? "col-resize" : "";
|
|
target2.style.cursor = cursor2;
|
|
const caret = target2.querySelector(".caret-wrapper");
|
|
if (caret)
|
|
caret.style.cursor = cursor2;
|
|
}
|
|
if (!column2.resizable || dragging.value) {
|
|
draggingColumn.value = null;
|
|
return;
|
|
}
|
|
const rect = target2.getBoundingClientRect();
|
|
const isLastTh = ((_a = target2.parentNode) == null ? void 0 : _a.lastElementChild) === target2;
|
|
const allowDrag = props2.allowDragLastColumn || !isLastTh;
|
|
const isResizeHandleActive = rect.width > 12 && rect.right - event.clientX < 8 && allowDrag;
|
|
const cursor = isResizeHandleActive ? "col-resize" : "";
|
|
document.body.style.cursor = cursor;
|
|
draggingColumn.value = isResizeHandleActive ? column2 : null;
|
|
if (isSortable)
|
|
target2.style.cursor = cursor;
|
|
};
|
|
const handleMouseOut = () => {
|
|
if (!isClient || dragging.value)
|
|
return;
|
|
document.body.style.cursor = "";
|
|
};
|
|
const toggleOrder = ({ order, sortOrders: sortOrders2 }) => {
|
|
if (order === "")
|
|
return sortOrders2[0];
|
|
const index = sortOrders2.indexOf(order || null);
|
|
return sortOrders2[index > sortOrders2.length - 2 ? 0 : index + 1];
|
|
};
|
|
const handleSortClick = (event, column2, givenOrder) => {
|
|
var _a;
|
|
event.stopPropagation();
|
|
const order = column2.order === givenOrder ? null : givenOrder || toggleOrder(column2);
|
|
const target2 = (_a = event.target) == null ? void 0 : _a.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 _a;
|
|
let headerCellStyles = (_a = parent2 == null ? void 0 : parent2.props.headerCellStyle) != null ? _a : {};
|
|
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/index.mjs
|
|
var table_header_default = 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(/* @__PURE__ */ new Map());
|
|
const theadRef = ref();
|
|
let delayId;
|
|
const updateFixedColumnStyle = () => {
|
|
delayId = setTimeout(() => {
|
|
if (saveIndexSelection.size > 0) {
|
|
saveIndexSelection.forEach((column2, key) => {
|
|
const el = theadRef.value.querySelector(`.${key.replace(/\s/g, ".")}`);
|
|
if (el)
|
|
column2.width = el.getBoundingClientRect().width || column2.width;
|
|
});
|
|
saveIndexSelection.clear();
|
|
}
|
|
});
|
|
};
|
|
watch(saveIndexSelection, updateFixedColumnStyle);
|
|
onBeforeUnmount(() => {
|
|
if (delayId) {
|
|
clearTimeout(delayId);
|
|
delayId = void 0;
|
|
}
|
|
});
|
|
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);
|
|
const { t } = useLocale();
|
|
instance.state = {
|
|
onColumnsChange,
|
|
onScrollableChange
|
|
};
|
|
instance.filterPanels = filterPanels;
|
|
return {
|
|
ns,
|
|
t,
|
|
filterPanels,
|
|
onColumnsChange,
|
|
onScrollableChange,
|
|
columnRows,
|
|
getHeaderRowClass,
|
|
getHeaderRowStyle,
|
|
getHeaderCellClass,
|
|
getHeaderCellStyle,
|
|
handleHeaderClick,
|
|
handleHeaderContextMenu,
|
|
handleMouseDown,
|
|
handleMouseMove,
|
|
handleMouseOut,
|
|
handleSortClick,
|
|
handleFilterClick,
|
|
isGroup,
|
|
toggleAllSelection,
|
|
saveIndexSelection,
|
|
isTableLayoutAuto,
|
|
theadRef,
|
|
updateFixedColumnStyle
|
|
};
|
|
},
|
|
render() {
|
|
const { ns, t, 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,
|
|
scope: column2.colSpan > 1 ? "colgroup" : "col",
|
|
ariaSort: column2.sortable ? column2.order : void 0,
|
|
style: getHeaderCellStyle(rowIndex, cellIndex, subColumns, column2),
|
|
onClick: ($event) => {
|
|
var _a;
|
|
if ((_a = $event.currentTarget) == null ? void 0 : _a.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("button", {
|
|
type: "button",
|
|
class: "caret-wrapper",
|
|
"aria-label": t("el.table.sortLabel", { column: column2.label || "" }),
|
|
onClick: ($event) => handleSortClick($event, column2)
|
|
}, [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(filter_panel_default, {
|
|
store,
|
|
placement: column2.filterPlacement || "bottom-start",
|
|
appendTo: $parent == null ? void 0 : $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 useEvents(props2) {
|
|
const parent2 = inject(TABLE_INJECTION_KEY);
|
|
const tooltipContent = ref("");
|
|
const tooltipTrigger = ref(h("div"));
|
|
const handleEvent = (event, row, name) => {
|
|
var _a, _b, _c;
|
|
const table = parent2;
|
|
const cell = getCell(event);
|
|
let column2 = null;
|
|
const namespace = (_a = table == null ? void 0 : table.vnode.el) == null ? void 0 : _a.dataset.prefix;
|
|
if (cell) {
|
|
column2 = getColumnByCell({ columns: (_c = (_b = props2.store) == null ? void 0 : _b.states.columns.value) != null ? _c : [] }, 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) => {
|
|
var _a;
|
|
(_a = props2.store) == null ? void 0 : _a.commit("setCurrentRow", row);
|
|
handleEvent(event, row, "click");
|
|
};
|
|
const handleContextMenu = (event, row) => {
|
|
handleEvent(event, row, "contextmenu");
|
|
};
|
|
const handleMouseEnter = debounce_default((index) => {
|
|
var _a;
|
|
(_a = props2.store) == null ? void 0 : _a.commit("setHoverRow", index);
|
|
}, 30);
|
|
const handleMouseLeave = debounce_default(() => {
|
|
var _a;
|
|
(_a = props2.store) == null ? void 0 : _a.commit("setHoverRow", null);
|
|
}, 30);
|
|
const getPadding = (el) => {
|
|
const style = window.getComputedStyle(el, null);
|
|
return {
|
|
left: Number.parseInt(style.paddingLeft, 10) || 0,
|
|
right: Number.parseInt(style.paddingRight, 10) || 0,
|
|
top: Number.parseInt(style.paddingTop, 10) || 0,
|
|
bottom: Number.parseInt(style.paddingBottom, 10) || 0
|
|
};
|
|
};
|
|
const toggleRowClassByCell = (rowSpan, event, toggle) => {
|
|
var _a;
|
|
let node = (_a = event == null ? void 0 : event.target) == null ? void 0 : _a.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 _a, _b, _c, _d, _e, _f, _g, _h, _i;
|
|
if (!parent2)
|
|
return;
|
|
const table = parent2;
|
|
const cell = getCell(event);
|
|
const namespace = (_a = table == null ? void 0 : table.vnode.el) == null ? void 0 : _a.dataset.prefix;
|
|
let column2 = null;
|
|
if (cell) {
|
|
column2 = getColumnByCell({ columns: (_c = (_b = props2.store) == null ? void 0 : _b.states.columns.value) != null ? _c : [] }, cell, namespace);
|
|
if (!column2)
|
|
return;
|
|
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) {
|
|
if (((_d = removePopper) == null ? void 0 : _d.trigger) === cell)
|
|
(_e = removePopper) == null ? void 0 : _e();
|
|
return;
|
|
}
|
|
const cellChild = event.target.querySelector(".cell");
|
|
if (!(hasClass(cellChild, `${namespace}-tooltip`) && cellChild.childNodes.length && ((_f = cellChild.textContent) == null ? void 0 : _f.trim())))
|
|
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, (_g = (cell == null ? void 0 : cell.innerText) || (cell == null ? void 0 : cell.textContent)) != null ? _g : "", row, column2, cell, table);
|
|
else if (((_h = removePopper) == null ? void 0 : _h.trigger) === cell)
|
|
(_i = removePopper) == null ? void 0 : _i();
|
|
};
|
|
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, displayIndex) => {
|
|
var _a;
|
|
const classes = [ns.e("row")];
|
|
if ((parent2 == null ? void 0 : parent2.props.highlightCurrentRow) && row === ((_a = props2.store) == null ? void 0 : _a.states.currentRow.value))
|
|
classes.push("current-row");
|
|
if (props2.stripe && displayIndex % 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.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_167 = ["colspan", "rowspan"];
|
|
var td_wrapper_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "TableTdWrapper",
|
|
__name: "td-wrapper",
|
|
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, _hoisted_167);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table/src/table-body/td-wrapper.mjs
|
|
var td_wrapper_default = td_wrapper_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// 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);
|
|
let displayIndex = -1;
|
|
const firstDefaultColumnIndex = computed(() => {
|
|
var _a;
|
|
return (_a = props2.store) == null ? void 0 : _a.states.columns.value.findIndex(({ type: type4 }) => type4 === "default");
|
|
});
|
|
const getKeyOfRow = (row, index) => {
|
|
var _a;
|
|
const rowKey2 = (_a = parent2 == null ? void 0 : parent2.props) == null ? void 0 : _a.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 = [];
|
|
let display = true;
|
|
if (treeRowData) {
|
|
rowClasses.push(ns.em("row", `level-${treeRowData.level}`));
|
|
display = !!treeRowData.display;
|
|
}
|
|
if ($index === 0)
|
|
displayIndex = -1;
|
|
if (props2.stripe && display)
|
|
displayIndex++;
|
|
rowClasses.push(...getRowClass(row, $index, displayIndex));
|
|
return h("tr", {
|
|
style: [display ? null : { display: "none" }, 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,
|
|
_self: props2.context || parent2,
|
|
column: columnData,
|
|
row,
|
|
$index,
|
|
cellIndex,
|
|
expanded
|
|
};
|
|
if (cellIndex === firstDefaultColumnIndex.value && treeRowData) {
|
|
data.treeNode = {
|
|
indent: treeRowData.level && 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(td_wrapper_default, {
|
|
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;
|
|
if (columns2.some(({ type: type4 }) => type4 === "expand")) {
|
|
const expanded = isRowExpanded(row);
|
|
const tr = rowRender(row, $index, void 0, expanded);
|
|
const renderExpanded = parent2 == null ? void 0 : 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,
|
|
noLazyChildren: void 0,
|
|
loading: void 0
|
|
};
|
|
if (isBoolean2(cur.lazy)) {
|
|
if (treeRowData && isBoolean2(cur.loaded) && cur.loaded)
|
|
treeRowData.noLazyChildren = !(cur.children && cur.children.length);
|
|
treeRowData.loading = cur.loading;
|
|
}
|
|
}
|
|
const tmp = [rowRender(row, $index, treeRowData != null ? treeRowData : void 0)];
|
|
if (cur) {
|
|
let i = 0;
|
|
const traverse = (children, parent3) => {
|
|
if (!(children && children.length && parent3))
|
|
return;
|
|
children.forEach((node) => {
|
|
const innerTreeRowData = {
|
|
display: parent3.display && parent3.expanded,
|
|
level: parent3.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)
|
|
traverse(lazyTreeNodeMap.value[childKey] || node[childrenColumnName.value], cur);
|
|
});
|
|
};
|
|
cur.display = true;
|
|
traverse(lazyTreeNodeMap.value[key] || row[childrenColumnName.value], 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 table_body_default = defineComponent({
|
|
name: "ElTableBody",
|
|
props: defaultProps2,
|
|
setup(props2) {
|
|
var _a;
|
|
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((_a = props2.store) == null ? void 0 : _a.states.hoverRow, (newVal, oldVal) => {
|
|
var _a2, _b;
|
|
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;
|
|
Array.from(childNodes).reduce((acc, item, index) => {
|
|
var _a3, _b2;
|
|
if (((_a3 = childNodes[index]) == null ? void 0 : _a3.colSpan) > 1)
|
|
control = (_b2 = childNodes[index]) == null ? void 0 : _b2.colSpan;
|
|
if (item.nodeName !== "TD" && control === 0)
|
|
acc.push(index);
|
|
control > 0 && control--;
|
|
return acc;
|
|
}, []).forEach((rowIndex) => {
|
|
var _a3;
|
|
rowNum = newVal;
|
|
while (rowNum > 0) {
|
|
const preChildNodes = (_a3 = rows[rowNum - 1]) == null ? void 0 : _a3.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 (!((_b = props2.store) == null ? void 0 : _b.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;
|
|
return h("tbody", { tabIndex: -1 }, [((store == null ? void 0 : store.states.data.value) || []).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 _a;
|
|
const store = (_a = inject(TABLE_INJECTION_KEY)) == null ? void 0 : _a.store;
|
|
return {
|
|
leftFixedLeafCount: computed(() => {
|
|
var _a2;
|
|
return (_a2 = store == null ? void 0 : store.states.fixedLeafColumnsLength.value) != null ? _a2 : 0;
|
|
}),
|
|
rightFixedLeafCount: computed(() => {
|
|
var _a2;
|
|
return (_a2 = store == null ? void 0 : store.states.rightFixedColumns.value.length) != null ? _a2 : 0;
|
|
}),
|
|
columnsCount: computed(() => {
|
|
var _a2;
|
|
return (_a2 = store == null ? void 0 : store.states.columns.value.length) != null ? _a2 : 0;
|
|
}),
|
|
leftFixedCount: computed(() => {
|
|
var _a2;
|
|
return (_a2 = store == null ? void 0 : store.states.fixedColumns.value.length) != null ? _a2 : 0;
|
|
}),
|
|
rightFixedCount: computed(() => {
|
|
var _a2;
|
|
return (_a2 = store == null ? void 0 : store.states.rightFixedColumns.value.length) != null ? _a2 : 0;
|
|
}),
|
|
columns: computed(() => {
|
|
var _a2;
|
|
return (_a2 = store == null ? void 0 : store.states.columns.value) != 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 = (columns3, cellIndex) => {
|
|
const column2 = columns3[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 table_footer_default = 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);
|
|
watch(() => props2.height, (value) => {
|
|
layout2.setHeight(value != null ? value : null);
|
|
}, { immediate: true });
|
|
watch(() => props2.maxHeight, (value) => {
|
|
layout2.setMaxHeight(value != null ? value : null);
|
|
}, { immediate: true });
|
|
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 = (_event2, 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;
|
|
if (scrollLeft >= scrollWidth - offsetWidth - 1)
|
|
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.tableInnerWrapper, () => {
|
|
var _a, _b;
|
|
resizeListener();
|
|
(_b = (_a = table.refs) == null ? void 0 : _a.scrollBarRef) == null ? void 0 : _b.update();
|
|
});
|
|
};
|
|
const resizeListener = () => {
|
|
var _a, _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 : (_a = table.refs.tableHeaderRef) == null ? void 0 : _a.$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;
|
|
});
|
|
return {
|
|
isHidden: isHidden2,
|
|
renderExpanded,
|
|
setDragVisible,
|
|
isGroup,
|
|
handleMouseLeave,
|
|
handleHeaderFooterMousewheel,
|
|
tableSize,
|
|
emptyBlockStyle: computed(() => {
|
|
if (props2.data && props2.data.length)
|
|
return;
|
|
let height = "100%";
|
|
if (props2.height && bodyScrollHeight.value)
|
|
height = `${bodyScrollHeight.value}px`;
|
|
const width = tableWidth.value;
|
|
return {
|
|
width: width ? `${width}px` : "",
|
|
height
|
|
};
|
|
}),
|
|
resizeProxyVisible,
|
|
bodyWidth,
|
|
resizeState,
|
|
doLayout,
|
|
tableBodyStyles,
|
|
tableLayout,
|
|
scrollbarViewStyle,
|
|
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 {};
|
|
})
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/table/key-render-helper.mjs
|
|
function useKeyRender(table) {
|
|
let observer;
|
|
const initWatchDom = () => {
|
|
const columnsWrapper = table.vnode.el.querySelector(".hidden-columns");
|
|
const config = {
|
|
childList: true,
|
|
subtree: true
|
|
};
|
|
const updateOrderFns = table.store.states.updateOrderFns;
|
|
observer = new MutationObserver(() => {
|
|
updateOrderFns.forEach((fn2) => fn2());
|
|
});
|
|
observer.observe(columnsWrapper, config);
|
|
};
|
|
onMounted(() => {
|
|
initWatchDom();
|
|
});
|
|
onUnmounted(() => {
|
|
observer == null ? void 0 : observer.disconnect();
|
|
});
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table/src/table/defaults.mjs
|
|
var defaults_default2 = {
|
|
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,
|
|
rowExpandable: { type: Function },
|
|
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: [
|
|
String,
|
|
Object,
|
|
Array
|
|
],
|
|
default: () => ({})
|
|
},
|
|
className: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
tableLayout: {
|
|
type: String,
|
|
default: "fixed"
|
|
},
|
|
scrollbarAlwaysOn: Boolean,
|
|
flexible: Boolean,
|
|
showOverflowTooltip: {
|
|
type: [Boolean, Object],
|
|
default: void 0
|
|
},
|
|
tooltipFormatter: Function,
|
|
appendFilterPanelTo: String,
|
|
scrollbarTabindex: {
|
|
type: [Number, String],
|
|
default: void 0
|
|
},
|
|
allowDragLastColumn: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
preserveExpandedContent: Boolean,
|
|
nativeScrollbar: Boolean
|
|
};
|
|
|
|
// 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 scrollTo2 = (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: scrollTo2,
|
|
setScrollTop,
|
|
setScrollLeft
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table/src/table.vue_vue_type_script_lang.mjs
|
|
var tableIdSeed = 1;
|
|
var table_vue_vue_type_script_lang_default = defineComponent({
|
|
name: "ElTable",
|
|
directives: { Mousewheel },
|
|
components: {
|
|
TableHeader: table_header_default,
|
|
TableBody: table_body_default,
|
|
TableFooter: table_footer_default,
|
|
ElScrollbar,
|
|
hColgroup
|
|
},
|
|
props: defaults_default2,
|
|
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 globalConfig2 = useGlobalConfig("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, resizeProxyVisible, bodyWidth, resizeState, doLayout, tableBodyStyles, tableLayout, scrollbarViewStyle, scrollbarStyle } = useStyle3(props2, layout2, store, table);
|
|
const { scrollBarRef, scrollTo: scrollTo2, 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 _a;
|
|
return (_a = props2.sumText) != null ? _a : t("el.table.sumText");
|
|
});
|
|
const computedEmptyText = computed(() => {
|
|
var _a;
|
|
return (_a = props2.emptyText) != null ? _a : t("el.table.emptyText");
|
|
});
|
|
const computedTooltipEffect = computed(() => {
|
|
var _a, _b;
|
|
return (_b = props2.tooltipEffect) != null ? _b : (_a = globalConfig2.value) == null ? void 0 : _a.tooltipEffect;
|
|
});
|
|
const computedTooltipOptions = computed(() => {
|
|
var _a, _b;
|
|
return (_b = props2.tooltipOptions) != null ? _b : (_a = globalConfig2.value) == null ? void 0 : _a.tooltipOptions;
|
|
});
|
|
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,
|
|
setCurrentRow,
|
|
getSelectionRows,
|
|
toggleRowSelection,
|
|
clearSelection,
|
|
clearFilter,
|
|
toggleAllSelection,
|
|
toggleRowExpansion,
|
|
clearSort,
|
|
doLayout,
|
|
sort,
|
|
updateKeyChildren,
|
|
t,
|
|
setDragVisible,
|
|
context: table,
|
|
computedSumText,
|
|
computedEmptyText,
|
|
computedTooltipEffect,
|
|
computedTooltipOptions,
|
|
tableLayout,
|
|
scrollbarViewStyle,
|
|
scrollbarStyle,
|
|
scrollBarRef,
|
|
scrollTo: scrollTo2,
|
|
setScrollLeft,
|
|
setScrollTop,
|
|
allowDragLastColumn: props2.allowDragLastColumn
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table/src/table.mjs
|
|
var _hoisted_168 = ["data-prefix"];
|
|
var _hoisted_237 = {
|
|
ref: "hiddenColumns",
|
|
class: "hidden-columns"
|
|
};
|
|
function _sfc_render19(_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: _cache[1] || (_cache[1] = (...args) => _ctx.handleMouseLeave && _ctx.handleMouseLeave(...args))
|
|
}, [createBaseVNode("div", {
|
|
ref: "tableInnerWrapper",
|
|
class: normalizeClass(_ctx.ns.e("inner-wrapper"))
|
|
}, [
|
|
createBaseVNode("div", _hoisted_237, [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,
|
|
native: _ctx.nativeScrollbar,
|
|
onScroll: _cache[0] || (_cache[0] = ($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.computedTooltipEffect,
|
|
"tooltip-options": _ctx.computedTooltipOptions,
|
|
"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",
|
|
"native"
|
|
])], 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, _hoisted_168);
|
|
}
|
|
var table_default = _plugin_vue_export_helper_default(table_vue_vue_type_script_lang_default, [["render", _sfc_render19]]);
|
|
|
|
// 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 }) {
|
|
var _a;
|
|
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": (_a = store.toggleAllSelection) != null ? _a : void 0,
|
|
modelValue: store.states.isAllSelected.value,
|
|
ariaLabel: store.t("el.table.selectAllLabel")
|
|
});
|
|
},
|
|
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: store.t("el.table.selectRowLabel")
|
|
});
|
|
},
|
|
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({ column: column2, row, store, expanded, $index }) {
|
|
var _a, _b, _c;
|
|
const { ns } = store;
|
|
const classes = [ns.e("expand-icon")];
|
|
if (!column2.renderExpand && expanded)
|
|
classes.push(ns.em("expand-icon", "expanded"));
|
|
const callback = function(e) {
|
|
e.stopPropagation();
|
|
store.toggleRowExpansion(row);
|
|
};
|
|
const isRowExpandable = (_c = (_b = (_a = store.states.rowExpandable).value) == null ? void 0 : _b.call(_a, row, $index)) != null ? _c : true;
|
|
if (!isRowExpandable)
|
|
classes.push(ns.is("disabled"));
|
|
return h("button", {
|
|
type: "button",
|
|
disabled: !isRowExpandable,
|
|
"aria-label": store.t(expanded ? "el.table.collapseRowLabel" : "el.table.expandRowLabel"),
|
|
"aria-expanded": expanded,
|
|
class: classes,
|
|
onClick: callback
|
|
}, { default: () => {
|
|
if (column2.renderExpand)
|
|
return [column2.renderExpand({
|
|
expanded,
|
|
expandable: isRowExpandable
|
|
})];
|
|
return [h(ElIcon, null, { default: () => {
|
|
return [h(arrow_right_default)];
|
|
} })];
|
|
} });
|
|
},
|
|
sortable: false,
|
|
resizable: false
|
|
}
|
|
};
|
|
function defaultRenderCell({ row, column: column2, $index }) {
|
|
var _a;
|
|
const property2 = column2.property;
|
|
const value = property2 && getProp(row, property2).value;
|
|
if (column2 && column2.formatter)
|
|
return column2.formatter(row, column2, value, $index);
|
|
return ((_a = value == null ? void 0 : value.toString) == null ? void 0 : _a.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("button", {
|
|
type: "button",
|
|
"aria-label": store.t(treeNode.expanded ? "el.table.collapseRowLabel" : "el.table.expandRowLabel"),
|
|
"aria-expanded": treeNode.expanded,
|
|
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",
|
|
"resizable"
|
|
];
|
|
const parentProps = ["showOverflowTooltip"];
|
|
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;
|
|
if (key === "filters" || key === "filterMethod")
|
|
instance.columnConfig.value["filterable"] = !!(instance.columnConfig.value["filters"] || instance.columnConfig.value["filterMethod"]);
|
|
});
|
|
});
|
|
parentProps.forEach((key) => {
|
|
if (hasOwn(owner.value.props, key))
|
|
watch(() => owner.value.props[key], (newVal) => {
|
|
if (instance.columnConfig.value.type === "selection")
|
|
return;
|
|
if (!isUndefined2(props_[key]))
|
|
return;
|
|
instance.columnConfig.value[key] = newVal;
|
|
});
|
|
});
|
|
const globalConfig2 = useGlobalConfig("table");
|
|
if (globalConfig2.value && hasOwn(globalConfig2.value, "showOverflowTooltip"))
|
|
watch(() => {
|
|
var _a;
|
|
return (_a = globalConfig2.value) == null ? void 0 : _a.showOverflowTooltip;
|
|
}, (newVal) => {
|
|
if (instance.columnConfig.value.type === "selection")
|
|
return;
|
|
if (!isUndefined2(props_.showOverflowTooltip) || !isUndefined2(owner.value.props.showOverflowTooltip))
|
|
return;
|
|
instance.columnConfig.value.showOverflowTooltip = 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 _a;
|
|
if (((_a = item == null ? void 0 : item.type) == null ? void 0 : _a.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"];
|
|
if (slots.header) {
|
|
const slotResult = slots.header(scope);
|
|
if (ensureValidVNode(slotResult))
|
|
return h(Fragment, slotResult);
|
|
}
|
|
return createTextVNode(column2.label);
|
|
};
|
|
if (slots["filter-icon"])
|
|
column2.renderFilterIcon = (scope) => {
|
|
return renderSlot(slots, "filter-icon", scope);
|
|
};
|
|
if (slots.expand)
|
|
column2.renderExpand = (scope) => {
|
|
return renderSlot(slots, "expand", scope);
|
|
};
|
|
let originRenderCell = column2.renderCell;
|
|
if (column2.type === "expand") {
|
|
column2.renderCell = (data) => h("div", { class: "cell" }, [originRenderCell(data)]);
|
|
owner.value.renderExpanded = (row) => {
|
|
return slots.default ? slots.default(row) : 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 prefix = treeCellPrefix(data, hasTreeColumn.value && data.cellIndex === firstUserColumnIndex);
|
|
const props3 = {
|
|
class: "cell",
|
|
style: {}
|
|
};
|
|
if (column2.showOverflowTooltip) {
|
|
props3.class = `${props3.class} ${unref(ns.namespace)}-tooltip`;
|
|
props3.style = { width: `${(data.column.realWidth || Number(data.column.width)) - 1}px` };
|
|
}
|
|
checkSubColumn(children);
|
|
return h("div", props3, [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 defaults_default3 = {
|
|
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 table_column_default = defineComponent({
|
|
name: "ElTableColumn",
|
|
components: { ElCheckbox },
|
|
props: defaults_default3,
|
|
setup(props2, { slots }) {
|
|
const instance = getCurrentInstance();
|
|
const globalConfig2 = useGlobalConfig("table");
|
|
const columnConfig = ref({});
|
|
const owner = computed(() => {
|
|
let parent3 = instance.parent;
|
|
while (parent3 && !parent3.tableId)
|
|
parent3 = parent3.parent;
|
|
return parent3;
|
|
});
|
|
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 = `${"tableId" in parent2 && parent2.tableId || "columnId" in parent2 && parent2.columnId}_column_${columnIdSeed++}`;
|
|
onBeforeMount(() => {
|
|
var _a, _b, _c, _d;
|
|
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) ? (_b = parent2.props.showOverflowTooltip) != null ? _b : (_a = globalConfig2.value) == null ? void 0 : _a.showOverflowTooltip : props2.showOverflowTooltip;
|
|
const tooltipFormatter = isUndefined2(props2.tooltipFormatter) ? (_d = parent2.props.tooltipFormatter) != null ? _d : (_c = globalConfig2.value) == null ? void 0 : _c.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
|
|
};
|
|
let column2 = getPropsData([
|
|
"columnKey",
|
|
"label",
|
|
"className",
|
|
"labelClassName",
|
|
"type",
|
|
"renderHeader",
|
|
"formatter",
|
|
"fixed",
|
|
"resizable"
|
|
], [
|
|
"sortMethod",
|
|
"sortBy",
|
|
"sortOrders"
|
|
], ["selectable", "reserveSelection"], [
|
|
"filterMethod",
|
|
"filters",
|
|
"filterMultiple",
|
|
"filterOpened",
|
|
"filteredValue",
|
|
"filterPlacement",
|
|
"filterClassName"
|
|
]);
|
|
column2 = mergeOptions(defaults2, column2);
|
|
column2 = compose(setColumnRenders, setColumnWidth, setColumnForcedProps)(column2);
|
|
columnConfig.value = column2;
|
|
registerNormalWatchers();
|
|
registerComplexWatchers();
|
|
});
|
|
onMounted(() => {
|
|
var _a, _b;
|
|
const parent3 = columnOrTableParent.value;
|
|
const children = isSubColumn.value ? (_a = parent3.vnode.el) == null ? void 0 : _a.children : (_b = parent3.refs.hiddenColumns) == null ? void 0 : _b.children;
|
|
const getColumnIndex = () => getColumnElIndex(children || [], instance.vnode.el);
|
|
columnConfig.value.getColumnIndex = getColumnIndex;
|
|
getColumnIndex() > -1 && owner.value.store.commit("insertColumn", columnConfig.value, isSubColumn.value ? "columnConfig" in parent3 && parent3.columnConfig.value : null, updateColumnOrder);
|
|
});
|
|
onBeforeUnmount(() => {
|
|
const getColumnIndex = columnConfig.value.getColumnIndex;
|
|
(getColumnIndex ? getColumnIndex() : -1) > -1 && owner.value.store.commit("removeColumn", columnConfig.value, isSubColumn.value ? "columnConfig" in parent2 && parent2.columnConfig.value : null, updateColumnOrder);
|
|
});
|
|
instance.columnId = columnId.value;
|
|
instance.columnConfig = columnConfig;
|
|
},
|
|
render() {
|
|
var _a, _b, _c;
|
|
try {
|
|
const renderDefault = (_b = (_a = this.$slots).default) == null ? void 0 : _b.call(_a, {
|
|
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((vnode) => {
|
|
if ((vnode == null ? void 0 : vnode.patchFlag) !== 1024 && !isString(vnode == null ? void 0 : vnode.children))
|
|
children.push(vnode);
|
|
});
|
|
}
|
|
return h("div", children);
|
|
} catch {
|
|
return h("div", []);
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table/src/tableColumn.mjs
|
|
var tableColumn_default = table_column_default;
|
|
|
|
// node_modules/element-plus/es/components/table/index.mjs
|
|
var ElTable = withInstall(table_default, { TableColumn: tableColumn_default });
|
|
var ElTableColumn = withNoopInstall(tableColumn_default);
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/constants.mjs
|
|
var SortOrder = function(SortOrder2) {
|
|
SortOrder2["ASC"] = "asc";
|
|
SortOrder2["DESC"] = "desc";
|
|
return SortOrder2;
|
|
}({});
|
|
var Alignment = function(Alignment2) {
|
|
Alignment2["LEFT"] = "left";
|
|
Alignment2["CENTER"] = "center";
|
|
Alignment2["RIGHT"] = "right";
|
|
return Alignment2;
|
|
}({});
|
|
var FixedDir = function(FixedDir2) {
|
|
FixedDir2["LEFT"] = "left";
|
|
FixedDir2["RIGHT"] = "right";
|
|
return FixedDir2;
|
|
}({});
|
|
var oppositeOrderMap = {
|
|
[SortOrder.ASC]: SortOrder.DESC,
|
|
[SortOrder.DESC]: SortOrder.ASC
|
|
};
|
|
var sortOrders = [SortOrder.ASC, SortOrder.DESC];
|
|
|
|
// 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/table-v2/src/composables/utils.mjs
|
|
var calcColumnStyle = (column2, fixedColumn, fixed) => {
|
|
var _a, _b, _c;
|
|
const flex = {
|
|
flexGrow: 0,
|
|
flexShrink: 0,
|
|
...fixed ? {} : {
|
|
flexGrow: (_a = column2.flexGrow) != null ? _a : 0,
|
|
flexShrink: (_b = column2.flexShrink) != null ? _b : 1
|
|
}
|
|
};
|
|
const style = {
|
|
...(_c = column2.style) != null ? _c : {},
|
|
...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 _a, _b;
|
|
return {
|
|
...column2,
|
|
key: (_b = (_a = column2.key) != null ? _a : 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 _a;
|
|
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];
|
|
(_a = props2.onColumnSort) == null ? void 0 : _a.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 _a, _b, _c;
|
|
const { scrollTop } = params;
|
|
(_a = mainTableRef.value) == null ? void 0 : _a.scrollTo(params);
|
|
(_b = leftTableRef.value) == null ? void 0 : _b.scrollToTop(scrollTop);
|
|
(_c = rightTableRef.value) == null ? void 0 : _c.scrollToTop(scrollTop);
|
|
}
|
|
function scrollTo2(params) {
|
|
scrollPos.value = params;
|
|
doScroll(params);
|
|
}
|
|
function scrollToTop(scrollTop) {
|
|
scrollPos.value.scrollTop = scrollTop;
|
|
doScroll(unref(scrollPos));
|
|
}
|
|
function scrollToLeft(scrollLeft) {
|
|
var _a, _b;
|
|
scrollPos.value.scrollLeft = scrollLeft;
|
|
(_b = (_a = mainTableRef.value) == null ? void 0 : _a.scrollTo) == null ? void 0 : _b.call(_a, unref(scrollPos));
|
|
}
|
|
function onScroll(params) {
|
|
var _a;
|
|
scrollTo2(params);
|
|
(_a = props2.onScroll) == null ? void 0 : _a.call(props2, params);
|
|
}
|
|
function onVerticalScroll({ scrollTop }) {
|
|
const { scrollTop: currentScrollTop } = unref(scrollPos);
|
|
if (scrollTop !== currentScrollTop)
|
|
scrollToTop(scrollTop);
|
|
}
|
|
function scrollToRow(row, strategy = "auto") {
|
|
var _a;
|
|
(_a = mainTableRef.value) == null ? void 0 : _a.scrollToRow(row, strategy);
|
|
}
|
|
watch(() => unref(scrollPos).scrollTop, (cur, prev) => {
|
|
if (cur > prev)
|
|
onMaybeEndReached();
|
|
});
|
|
return {
|
|
scrollPos,
|
|
scrollTo: scrollTo2,
|
|
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 _a;
|
|
(_a = props2.onRowsRendered) == null ? void 0 : _a.call(props2, params);
|
|
if (params.rowCacheEnd > unref(lastRenderedRowIndex))
|
|
lastRenderedRowIndex.value = params.rowCacheEnd;
|
|
}
|
|
function onRowHovered({ hovered, rowKey: rowKey2 }) {
|
|
if (isScrolling.value)
|
|
return;
|
|
tableInstance.vnode.el.querySelectorAll(`[rowkey="${String(rowKey2)}"]`).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 _a, _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);
|
|
(_a = props2.onRowExpand) == null ? void 0 : _a.call(props2, {
|
|
expanded,
|
|
rowData,
|
|
rowIndex,
|
|
rowKey: rowKey2
|
|
});
|
|
(_b = props2.onExpandedRowsChange) == null ? void 0 : _b.call(props2, _expandedRowKeys);
|
|
if (tableInstance.vnode.el.querySelector(`.${ns.is("hovered")}[rowkey="${String(rowKey2)}"]`))
|
|
nextTick(() => onRowHovered({
|
|
hovered: true,
|
|
rowKey: rowKey2
|
|
}));
|
|
}
|
|
const flushingRowHeights = debounce_default(() => {
|
|
var _a, _b, _c, _d;
|
|
isResetting.value = true;
|
|
rowHeights.value = {
|
|
...unref(rowHeights),
|
|
...unref(pendingRowHeights)
|
|
};
|
|
resetAfterIndex(unref(resetIndex), false);
|
|
pendingRowHeights.value = {};
|
|
resetIndex.value = null;
|
|
(_a = mainTableRef.value) == null ? void 0 : _a.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 = /* @__PURE__ */ 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 = (sum3, num) => sum3 + 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, hScrollbarSize } = props2;
|
|
if (maxHeight > 0) {
|
|
const _fixedRowsHeight = unref(fixedRowsHeight);
|
|
const _rowsHeight = unref(rowsHeight);
|
|
const total2 = unref(headerHeight) + _fixedRowsHeight + _rowsHeight + hScrollbarSize;
|
|
return Math.min(total2, maxHeight - footerHeight);
|
|
}
|
|
return height - footerHeight;
|
|
});
|
|
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 _a;
|
|
return (((_a = props2.fixedData) == null ? void 0 : _a.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
|
|
});
|
|
});
|
|
return {
|
|
bodyWidth,
|
|
fixedTableHeight,
|
|
mainTableHeight,
|
|
leftTableWidth,
|
|
rightTableWidth,
|
|
windowHeight,
|
|
footerHeight: computed(() => enforceUnit({ height: props2.footerHeight })),
|
|
emptyStyle: computed(() => ({
|
|
top: addUnit(unref(headerHeight)),
|
|
bottom: addUnit(props2.footerHeight),
|
|
width: addUnit(props2.width)
|
|
})),
|
|
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: scrollTo2, 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 remainDistance = _totalHeight - (scrollTop + unref(windowHeight)) + 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: scrollTo2,
|
|
scrollToLeft,
|
|
scrollToTop,
|
|
scrollToRow,
|
|
onScroll,
|
|
onVerticalScroll
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/tokens.mjs
|
|
var TableV2InjectionKey = Symbol("tableV2");
|
|
var TABLE_V2_GRID_INJECTION_KEY = "tableV2GridScrollLeft";
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/components/header.mjs
|
|
var TableV2Header = defineComponent({
|
|
name: "ElTableV2Header",
|
|
props: tableV2HeaderProps,
|
|
setup(props2, { slots, expose }) {
|
|
const ns = useNamespace("table-v2");
|
|
const scrollLeftInfo = inject(TABLE_V2_GRID_INJECTION_KEY);
|
|
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 _a;
|
|
const style = enforceUnit({
|
|
height: rowHeight,
|
|
width: "100%"
|
|
});
|
|
return (_a = slots.fixed) == null ? void 0 : _a.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 _a;
|
|
const style = enforceUnit({
|
|
width: "100%",
|
|
height: rowHeight
|
|
});
|
|
return (_a = slots.dynamic) == null ? void 0 : _a.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()])]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/table-grid.mjs
|
|
var COMPONENT_NAME18 = "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 _a;
|
|
(_a = props2.onRowsRendered) == null ? void 0 : _a.call(props2, {
|
|
rowCacheStart,
|
|
rowCacheEnd,
|
|
rowVisibleStart,
|
|
rowVisibleEnd
|
|
});
|
|
}
|
|
function resetAfterRowIndex(index, forceUpdate2) {
|
|
var _a;
|
|
(_a = bodyRef.value) == null ? void 0 : _a.resetAfterRowIndex(index, forceUpdate2);
|
|
}
|
|
function scrollTo2(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 _a;
|
|
(_a = unref(bodyRef)) == null ? void 0 : _a.scrollTo({ scrollTop });
|
|
}
|
|
function scrollToRow(row, strategy) {
|
|
const body = unref(bodyRef);
|
|
if (!body)
|
|
return;
|
|
const prevScrollLeft = scrollLeft.value;
|
|
body.scrollToItem(row, 0, strategy);
|
|
if (prevScrollLeft)
|
|
scrollTo2({ scrollLeft: prevScrollLeft });
|
|
}
|
|
function forceUpdate() {
|
|
var _a, _b;
|
|
(_a = unref(bodyRef)) == null ? void 0 : _a.$forceUpdate();
|
|
(_b = unref(headerRef)) == null ? void 0 : _b.$forceUpdate();
|
|
}
|
|
watch(() => props2.bodyWidth, () => {
|
|
var _a;
|
|
if (isNumber2(props2.estimatedRowHeight))
|
|
(_a = bodyRef.value) == null ? void 0 : _a.resetAfter({ columnIndex: 0 }, false);
|
|
});
|
|
return {
|
|
bodyRef,
|
|
forceUpdate,
|
|
fixedRowHeight,
|
|
gridHeight,
|
|
hasHeader,
|
|
headerHeight,
|
|
headerRef,
|
|
totalHeight,
|
|
itemKey,
|
|
onItemRendered,
|
|
resetAfterRowIndex,
|
|
scrollTo: scrollTo2,
|
|
scrollToTop,
|
|
scrollToRow,
|
|
scrollLeft
|
|
};
|
|
};
|
|
var TableGrid = defineComponent({
|
|
name: COMPONENT_NAME18,
|
|
props: tableV2GridProps,
|
|
setup(props2, { slots, expose }) {
|
|
const { ns } = inject(TableV2InjectionKey);
|
|
const { bodyRef, fixedRowHeight, gridHeight, hasHeader, headerRef, headerHeight, totalHeight, forceUpdate, itemKey, onItemRendered, resetAfterRowIndex, scrollTo: scrollTo2, scrollToTop, scrollToRow, scrollLeft } = useTableGrid(props2);
|
|
provide(TABLE_V2_GRID_INJECTION_KEY, scrollLeft);
|
|
onActivated(async () => {
|
|
var _a;
|
|
await nextTick();
|
|
const scrollTop = (_a = bodyRef.value) == null ? void 0 : _a.states.scrollTop;
|
|
scrollTop && scrollToTop(Math.round(scrollTop) + 1);
|
|
});
|
|
expose({
|
|
forceUpdate,
|
|
totalHeight,
|
|
scrollTo: scrollTo2,
|
|
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 _a;
|
|
const rowData = data[params.rowIndex];
|
|
return (_a = slots.row) == null ? void 0 : _a.call(slots, {
|
|
...params,
|
|
columns: columns2,
|
|
rowData
|
|
});
|
|
} }), unref(hasHeader) && createVNode(TableV2Header, {
|
|
"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
|
|
})]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/main-table.mjs
|
|
function _isSlot3(s2) {
|
|
return typeof s2 === "function" || Object.prototype.toString.call(s2) === "[object Object]" && !isVNode(s2);
|
|
}
|
|
var MainTable = (props2, { slots }) => {
|
|
const { mainTableRef, ...rest2 } = props2;
|
|
return createVNode(TableGrid, mergeProps({ "ref": mainTableRef }, rest2), _isSlot3(slots) ? slots : { default: () => [slots] });
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/left-table.mjs
|
|
function _isSlot4(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(TableGrid, mergeProps({ "ref": leftTableRef }, rest2), _isSlot4(slots) ? slots : { default: () => [slots] });
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/right-table.mjs
|
|
function _isSlot5(s2) {
|
|
return typeof s2 === "function" || Object.prototype.toString.call(s2) === "[object Object]" && !isVNode(s2);
|
|
}
|
|
var RightTable = (props2, { slots }) => {
|
|
if (!props2.columns.length)
|
|
return;
|
|
const { rightTableRef, ...rest2 } = props2;
|
|
return createVNode(TableGrid, mergeProps({ "ref": rightTableRef }, rest2), _isSlot5(slots) ? slots : { default: () => [slots] });
|
|
};
|
|
|
|
// 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 TableV2Row = defineComponent({
|
|
name: "ElTableV2TableRow",
|
|
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]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/row.mjs
|
|
function _isSlot6(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.is("expanded", canExpand && expandedRowKeys.includes(_rowKey)),
|
|
ns.is("fixed", !depth && isFixedRow),
|
|
ns.is("customized", Boolean(slots.row)),
|
|
{ [ns.e(`row-depth-${depth}`)]: canExpand && rowIndex >= 0 }
|
|
];
|
|
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 handlerMouseEnter = (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(TableV2Row, mergeProps(_rowProps, {
|
|
"onRowExpand": onRowExpanded,
|
|
"onMouseenter": handlerMouseEnter,
|
|
"onMouseleave": handlerMouseLeave,
|
|
"rowkey": _rowKey
|
|
}), _isSlot6(slots) ? slots : { default: () => [slots] });
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/components/cell.mjs
|
|
var TableV2Cell = (props2, { slots }) => {
|
|
var _a;
|
|
const { cellData, style } = props2;
|
|
const displayText = ((_a = cellData == null ? void 0 : cellData.toString) == null ? void 0 : _a.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;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/components/expand-icon.mjs
|
|
var ExpandIcon = (props2) => {
|
|
const { expanded, expandable, onExpand, style, size: size3, ariaLabel } = props2;
|
|
return createVNode("button", mergeProps({
|
|
onClick: expandable ? () => onExpand(!expanded) : void 0,
|
|
ariaLabel,
|
|
ariaExpanded: expanded,
|
|
class: props2.class
|
|
}, { "type": "button" }), [createVNode(ElIcon, {
|
|
"size": size3,
|
|
"style": style
|
|
}, { default: () => [createVNode(arrow_right_default, null, null)] })]);
|
|
};
|
|
ExpandIcon.inheritAttrs = false;
|
|
|
|
// 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, t, 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 Cell = columnCellRenderer ? columnCellRenderer(cellProps) : renderSlot(slots, "default", cellProps, () => [createVNode(TableV2Cell, 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, mergeProps(expandIconProps, {
|
|
"class": [ns.e("expand-icon"), ns.is("expanded", expanded)],
|
|
"size": iconSize,
|
|
"expanded": expanded,
|
|
"ariaLabel": t(expanded ? "el.table.collapseRowLabel" : "el.table.expandRowLabel"),
|
|
"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, Cell]);
|
|
};
|
|
CellRenderer.inheritAttrs = false;
|
|
|
|
// 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]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/header.mjs
|
|
function _isSlot7(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))
|
|
];
|
|
return createVNode(TableV2HeaderRow, {
|
|
...tryCall(headerProps, param),
|
|
columnsStyles,
|
|
class: kls,
|
|
columns: columns2,
|
|
headerIndex,
|
|
style
|
|
}, _isSlot7(slots) ? slots : { default: () => [slots] });
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/components/header-cell.mjs
|
|
var HeaderCell = (props2, { slots }) => renderSlot(slots, "default", props2, () => {
|
|
var _a, _b;
|
|
return [createVNode("div", {
|
|
"class": props2.class,
|
|
"title": (_a = props2.column) == null ? void 0 : _a.title
|
|
}, [(_b = props2.column) == null ? void 0 : _b.title])];
|
|
});
|
|
HeaderCell.displayName = "ElTableV2HeaderCell";
|
|
HeaderCell.inheritAttrs = false;
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/components/sort-icon.mjs
|
|
var SortIcon = (props2) => {
|
|
const { sortOrder } = props2;
|
|
return createVNode("button", {
|
|
"type": "button",
|
|
"aria-label": props2.ariaLabel,
|
|
"class": props2.class
|
|
}, [createVNode(ElIcon, { "size": 14 }, { default: () => [sortOrder === SortOrder.ASC ? createVNode(sort_up_default, null, null) : createVNode(sort_down_default, null, null)] })]);
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/header-cell.mjs
|
|
var HeaderCellRenderer = (props2, { slots }) => {
|
|
const { column: column2, ns, t, 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 Cell = columnCellRenderer ? columnCellRenderer(cellProps) : renderSlot(slots, "default", cellProps, () => [createVNode(HeaderCell, cellProps, null)]);
|
|
const { sortBy: sortBy2, sortState, headerCellProps } = props2;
|
|
let sorting, sortOrder, ariaSort;
|
|
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;
|
|
}
|
|
if (sortOrder === SortOrder.ASC)
|
|
ariaSort = "ascending";
|
|
else if (sortOrder === SortOrder.DESC)
|
|
ariaSort = "descending";
|
|
else
|
|
ariaSort = void 0;
|
|
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")
|
|
];
|
|
return createVNode("div", mergeProps({
|
|
...tryCall(headerCellProps, props2),
|
|
onClick: column2.sortable ? onColumnSorted : void 0,
|
|
ariaSort: sortable ? ariaSort : void 0,
|
|
class: cellKls,
|
|
style: cellStyle,
|
|
["data-key"]: column2.key
|
|
}, { "role": "columnheader" }), [Cell, sortable && createVNode(SortIcon, {
|
|
"class": [ns.e("sort-icon"), sorting && ns.is("sorting")],
|
|
"sortOrder": sortOrder,
|
|
"ariaLabel": t("el.table.sortLabel", { column: column2.title || "" })
|
|
}, null)]);
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/footer.mjs
|
|
var Footer = (props2, { slots }) => {
|
|
var _a;
|
|
return createVNode("div", {
|
|
"class": props2.class,
|
|
"style": props2.style
|
|
}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
|
|
};
|
|
Footer.displayName = "ElTableV2Footer";
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/empty.mjs
|
|
var Footer2 = (props2, { slots }) => {
|
|
const defaultSlot = renderSlot(slots, "default", {}, () => [createVNode(ElEmpty, null, null)]);
|
|
return createVNode("div", {
|
|
"class": props2.class,
|
|
"style": props2.style
|
|
}, [defaultSlot]);
|
|
};
|
|
Footer2.displayName = "ElTableV2Empty";
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/renderers/overlay.mjs
|
|
var Overlay = (props2, { slots }) => {
|
|
var _a;
|
|
return createVNode("div", {
|
|
"class": props2.class,
|
|
"style": props2.style
|
|
}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
|
|
};
|
|
Overlay.displayName = "ElTableV2Overlay";
|
|
|
|
// node_modules/element-plus/es/components/table-v2/src/table-v2.mjs
|
|
function _isSlot8(s2) {
|
|
return typeof s2 === "function" || Object.prototype.toString.call(s2) === "[object Object]" && !isVNode(s2);
|
|
}
|
|
var TableV2 = defineComponent({
|
|
name: "ElTableV2",
|
|
props: tableV2Props,
|
|
slots: Object,
|
|
setup(props2, { slots, expose }) {
|
|
const ns = useNamespace("table-v2");
|
|
const { t } = useLocale();
|
|
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: scrollTo2, scrollToLeft, scrollToTop, scrollToRow, getRowHeight, onColumnSorted, onRowHeightChange, onRowHovered, onRowExpanded, onRowsRendered, onScroll, onVerticalScroll } = useTable(props2);
|
|
expose({
|
|
scrollTo: scrollTo2,
|
|
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: `${ns.cssVarName("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,
|
|
t
|
|
};
|
|
const tableHeaderProps = {
|
|
ns,
|
|
headerClass,
|
|
headerProps,
|
|
columnsStyles: _columnsStyles
|
|
};
|
|
const tableHeaderCellProps = {
|
|
ns,
|
|
t,
|
|
sortBy: sortBy2,
|
|
sortState,
|
|
headerCellProps,
|
|
onColumnSorted
|
|
};
|
|
const tableSlots = {
|
|
row: (props3) => createVNode(RowRenderer, mergeProps(props3, tableRowProps), {
|
|
row: slots.row,
|
|
cell: (props4) => {
|
|
let _slot;
|
|
return slots.cell ? createVNode(CellRenderer, mergeProps(props4, tableCellProps, { "style": _columnsStyles[props4.column.key] }), _isSlot8(_slot = slots.cell(props4)) ? _slot : { default: () => [_slot] }) : createVNode(CellRenderer, mergeProps(props4, tableCellProps, { "style": _columnsStyles[props4.column.key] }), null);
|
|
}
|
|
}),
|
|
header: (props3) => createVNode(HeaderRenderer, mergeProps(props3, tableHeaderProps), {
|
|
header: slots.header,
|
|
cell: (props4) => {
|
|
let _slot2;
|
|
return slots["header-cell"] ? createVNode(HeaderCellRenderer, mergeProps(props4, tableHeaderCellProps, { "style": _columnsStyles[props4.column.key] }), _isSlot8(_slot2 = slots["header-cell"](props4)) ? _slot2 : { default: () => [_slot2] }) : createVNode(HeaderCellRenderer, mergeProps(props4, tableHeaderCellProps, { "style": _columnsStyles[props4.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, mainTableProps, _isSlot8(tableSlots) ? tableSlots : { default: () => [tableSlots] }),
|
|
createVNode(LeftTable, leftTableProps, _isSlot8(tableSlots) ? tableSlots : { default: () => [tableSlots] }),
|
|
createVNode(RightTable, rightTableProps, _isSlot8(tableSlots) ? tableSlots : { default: () => [tableSlots] }),
|
|
slots.footer && createVNode(Footer, footerProps, { default: slots.footer }),
|
|
unref(showEmpty) && createVNode(Footer2, {
|
|
"class": ns.e("empty"),
|
|
"style": unref(emptyStyle)
|
|
}, { default: slots.empty }),
|
|
slots.overlay && createVNode(Overlay, { "class": ns.e("overlay") }, { default: slots.overlay })
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// 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 _a;
|
|
(_a = props2.onResize) == null ? void 0 : _a.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 _a;
|
|
return createVNode("div", {
|
|
"ref": sizer,
|
|
"class": ns.b(),
|
|
"style": style
|
|
}, [(_a = slots.default) == null ? void 0 : _a.call(slots, {
|
|
height: height.value,
|
|
width: width.value
|
|
})]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/table-v2/index.mjs
|
|
var ElTableV2 = withInstall(TableV2);
|
|
var ElAutoResizer = withInstall(AutoResizer);
|
|
|
|
// 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([])
|
|
},
|
|
tabRefs: {
|
|
type: definePropType(Object),
|
|
default: () => mutable({})
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tabs/src/tab-bar.vue_vue_type_script_setup_true_lang.mjs
|
|
var COMPONENT_NAME19 = "ElTabBar";
|
|
var tab_bar_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: COMPONENT_NAME19,
|
|
__name: "tab-bar",
|
|
props: tabBarProps,
|
|
setup(__props, { expose: __expose }) {
|
|
const props2 = __props;
|
|
const rootTabs = inject(tabsRootContextKey);
|
|
if (!rootTabs)
|
|
throwError(COMPONENT_NAME19, "<el-tabs><el-tab-bar /></el-tabs>");
|
|
const ns = useNamespace("tabs");
|
|
const barRef = ref();
|
|
const barStyle = ref();
|
|
const renderActiveBar = computed(() => {
|
|
var _a;
|
|
return isUndefined2(rootTabs.props.defaultValue) || Boolean((_a = barStyle.value) == null ? void 0 : _a.transform);
|
|
});
|
|
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) => {
|
|
if (isUndefined2(tab.paneName))
|
|
return false;
|
|
const $el = props2.tabRefs[tab.paneName];
|
|
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 tabObservers = [];
|
|
const observerTabs = () => {
|
|
tabObservers.forEach((observer) => observer.stop());
|
|
tabObservers.length = 0;
|
|
Object.values(props2.tabRefs).forEach((tab) => {
|
|
tabObservers.push(useResizeObserver(tab, update2));
|
|
});
|
|
};
|
|
watch(() => props2.tabs, async () => {
|
|
await nextTick();
|
|
update2();
|
|
observerTabs();
|
|
}, { immediate: true });
|
|
const barObserver = useResizeObserver(barRef, () => update2());
|
|
onBeforeUnmount(() => {
|
|
tabObservers.forEach((observer) => observer.stop());
|
|
tabObservers.length = 0;
|
|
barObserver.stop();
|
|
});
|
|
__expose({
|
|
ref: barRef,
|
|
update: update2
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return renderActiveBar.value ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
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)) : createCommentVNode("v-if", true);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tabs/src/tab-bar2.mjs
|
|
var tab_bar_default = tab_bar_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// 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,
|
|
tabindex: {
|
|
type: [String, Number],
|
|
default: void 0
|
|
}
|
|
});
|
|
var tabNavEmits = {
|
|
tabClick: (tab, tabName, ev) => ev instanceof Event,
|
|
tabRemove: (tab, ev) => ev instanceof Event
|
|
};
|
|
var COMPONENT_NAME20 = "ElTabNav";
|
|
var TabNav = defineComponent({
|
|
name: COMPONENT_NAME20,
|
|
props: tabNavProps,
|
|
emits: tabNavEmits,
|
|
setup(props2, { expose, emit }) {
|
|
const rootTabs = inject(tabsRootContextKey);
|
|
if (!rootTabs)
|
|
throwError(COMPONENT_NAME20, `<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 tabRefsMap = ref({});
|
|
const tabBarRef = ref();
|
|
const scrollable = ref(false);
|
|
const navOffset = ref(0);
|
|
const isFocus = ref(false);
|
|
const focusable = ref(true);
|
|
const isWheelScrolling = ref(false);
|
|
const tracker = shallowRef();
|
|
const isHorizontal2 = computed(() => ["top", "bottom"].includes(rootTabs.props.tabPosition));
|
|
const sizeName = computed(() => isHorizontal2.value ? "width" : "height");
|
|
const navStyle = computed(() => {
|
|
const dir = sizeName.value === "width" ? "X" : "Y";
|
|
return {
|
|
transition: isWheelScrolling.value ? "none" : void 0,
|
|
transform: `translate${dir}(-${navOffset.value}px)`
|
|
};
|
|
});
|
|
const { width: navContainerWidth, height: navContainerHeight } = useElementSize(navScroll$);
|
|
const { width: navWidth, height: navHeight } = useElementSize(nav$, {
|
|
width: 0,
|
|
height: 0
|
|
}, { box: "border-box" });
|
|
const navContainerSize = computed(() => isHorizontal2.value ? navContainerWidth.value : navContainerHeight.value);
|
|
const navSize = computed(() => isHorizontal2.value ? navWidth.value : navHeight.value);
|
|
const { onWheel } = useWheel({
|
|
atStartEdge: computed(() => navOffset.value <= 0),
|
|
atEndEdge: computed(() => navSize.value - navOffset.value <= navContainerSize.value),
|
|
layout: computed(() => isHorizontal2.value ? "horizontal" : "vertical")
|
|
}, (offset3) => {
|
|
navOffset.value = clamp_default(navOffset.value + offset3, 0, navSize.value - navContainerSize.value);
|
|
});
|
|
const handleWheel = (event) => {
|
|
isWheelScrolling.value = true;
|
|
onWheel(event);
|
|
rAF(() => {
|
|
isWheelScrolling.value = false;
|
|
});
|
|
};
|
|
const scrollPrev = () => {
|
|
if (!navScroll$.value)
|
|
return;
|
|
const containerSize = navScroll$.value.getBoundingClientRect()[sizeName.value];
|
|
const currentOffset = navOffset.value;
|
|
if (!currentOffset)
|
|
return;
|
|
navOffset.value = currentOffset > containerSize ? currentOffset - containerSize : 0;
|
|
};
|
|
const scrollNext = () => {
|
|
if (!navScroll$.value || !nav$.value)
|
|
return;
|
|
const navSize2 = nav$.value.getBoundingClientRect()[sizeName.value];
|
|
const containerSize = navScroll$.value.getBoundingClientRect()[sizeName.value];
|
|
const currentOffset = navOffset.value;
|
|
if (!isGreaterThan(navSize2 - currentOffset, containerSize))
|
|
return;
|
|
navOffset.value = navSize2 - currentOffset > containerSize * 2 ? currentOffset + containerSize : navSize2 - containerSize;
|
|
};
|
|
const scrollToActiveTab = async () => {
|
|
const nav = nav$.value;
|
|
if (!scrollable.value || !el$.value || !navScroll$.value || !nav)
|
|
return;
|
|
await nextTick();
|
|
const activeTab = tabRefsMap.value[props2.currentName];
|
|
if (!activeTab)
|
|
return;
|
|
const navScroll = navScroll$.value;
|
|
const activeTabBounding = activeTab.getBoundingClientRect();
|
|
const navScrollBounding = navScroll.getBoundingClientRect();
|
|
const navScrollLeft = navScrollBounding.left + 1;
|
|
const navScrollRight = navScrollBounding.right - 1;
|
|
const navBounding = nav.getBoundingClientRect();
|
|
const maxOffset = isHorizontal2.value ? navBounding.width - navScrollBounding.width : navBounding.height - navScrollBounding.height;
|
|
const currentOffset = navOffset.value;
|
|
let newOffset = currentOffset;
|
|
if (isHorizontal2.value) {
|
|
if (activeTabBounding.left < navScrollLeft)
|
|
newOffset = currentOffset - (navScrollLeft - activeTabBounding.left);
|
|
if (activeTabBounding.right > navScrollRight)
|
|
newOffset = currentOffset + activeTabBounding.right - navScrollRight;
|
|
} 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 _a;
|
|
if (!nav$.value || !navScroll$.value)
|
|
return;
|
|
props2.stretch && ((_a = tabBarRef.value) == null ? void 0 : _a.update());
|
|
const navSize2 = nav$.value.getBoundingClientRect()[sizeName.value];
|
|
const containerSize = navScroll$.value.getBoundingClientRect()[sizeName.value];
|
|
const currentOffset = navOffset.value;
|
|
if (containerSize < navSize2) {
|
|
scrollable.value = scrollable.value || {};
|
|
scrollable.value.prev = currentOffset;
|
|
scrollable.value.next = isGreaterThan(navSize2, currentOffset + containerSize);
|
|
if (isGreaterThan(containerSize, navSize2 - currentOffset))
|
|
navOffset.value = navSize2 - containerSize;
|
|
} else {
|
|
scrollable.value = false;
|
|
if (currentOffset > 0)
|
|
navOffset.value = 0;
|
|
}
|
|
};
|
|
const changeTab = (event) => {
|
|
const code = getEventCode(event);
|
|
let step2 = 0;
|
|
switch (code) {
|
|
case EVENT_CODE.left:
|
|
case EVENT_CODE.up:
|
|
step2 = -1;
|
|
break;
|
|
case EVENT_CODE.right:
|
|
case EVENT_CODE.down:
|
|
step2 = 1;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
const tabList = Array.from(event.currentTarget.querySelectorAll("[role=tab]:not(.is-disabled)"));
|
|
let nextIndex = tabList.indexOf(event.target) + step2;
|
|
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;
|
|
const setRefs = (el, key) => {
|
|
tabRefsMap.value[key] = el;
|
|
};
|
|
const focusActiveTab = async () => {
|
|
var _a;
|
|
await nextTick();
|
|
(_a = tabRefsMap.value[props2.currentName]) == null ? void 0 : _a.focus({ preventScroll: true });
|
|
};
|
|
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$, () => {
|
|
rAF(update2);
|
|
});
|
|
onMounted(() => setTimeout(() => scrollToActiveTab(), 0));
|
|
onUpdated(() => update2());
|
|
expose({
|
|
scrollToActiveTab,
|
|
removeFocus,
|
|
focusActiveTab,
|
|
tabListRef: nav$,
|
|
tabBarRef,
|
|
scheduleRender: () => triggerRef(tracker)
|
|
});
|
|
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 _a, _b, _c, _d, _e;
|
|
const uid2 = pane.uid;
|
|
const disabled = pane.props.disabled;
|
|
const tabName = (_b = (_a = pane.props.name) != null ? _a : pane.index) != null ? _b : `${index}`;
|
|
const closable = !disabled && (pane.isClosable || pane.props.closable !== false && 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 ? (_e = props2.tabindex) != null ? _e : rootTabs.props.tabindex : -1;
|
|
return createVNode("div", {
|
|
"ref": (el) => setRefs(el, tabName),
|
|
"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) => {
|
|
const code = getEventCode(ev);
|
|
if (closable && (code === EVENT_CODE.delete || code === EVENT_CODE.backspace))
|
|
emit("tabRemove", pane, ev);
|
|
}
|
|
}, [...[tabLabelContent, btnClose]]);
|
|
});
|
|
tracker.value;
|
|
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$
|
|
}, [props2.panes.length > 0 ? 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,
|
|
"onWheel": handleWheel
|
|
}, [...[!props2.type ? createVNode(tab_bar_default, {
|
|
"ref": tabBarRef,
|
|
"tabs": [...props2.panes],
|
|
"tabRefs": tabRefsMap.value
|
|
}, null) : null, tabs]]) : null])]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// 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] },
|
|
defaultValue: { type: [String, Number] },
|
|
editable: Boolean,
|
|
tabPosition: {
|
|
type: String,
|
|
values: [
|
|
"top",
|
|
"right",
|
|
"bottom",
|
|
"left"
|
|
],
|
|
default: "top"
|
|
},
|
|
beforeLeave: {
|
|
type: definePropType(Function),
|
|
default: () => true
|
|
},
|
|
stretch: Boolean,
|
|
tabindex: {
|
|
type: [String, Number],
|
|
default: 0
|
|
}
|
|
});
|
|
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 _a;
|
|
const ns = useNamespace("tabs");
|
|
const isVertical = computed(() => ["left", "right"].includes(props2.tabPosition));
|
|
const { children: panes, addChild: registerPane, removeChild: unregisterPane, ChildrenSorter: PanesSorter } = useOrderedChildren(getCurrentInstance(), "ElTabPane");
|
|
const nav$ = ref();
|
|
const currentName = ref((_a = isUndefined2(props2.modelValue) ? props2.defaultValue : props2.modelValue) != null ? _a : "0");
|
|
const setCurrentName = async (value, trigger = false) => {
|
|
var _a2, _b, _c, _d;
|
|
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) {
|
|
const isFocusInsidePane = (_a2 = panes.value.find((item) => item.paneName === currentName.value)) == null ? void 0 : _a2.isFocusInsidePane();
|
|
currentName.value = value;
|
|
if (trigger) {
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emit("tabChange", value);
|
|
}
|
|
(_c = (_b = nav$.value) == null ? void 0 : _b.removeFocus) == null ? void 0 : _c.call(_b);
|
|
if (isFocusInsidePane)
|
|
(_d = nav$.value) == null ? void 0 : _d.focusActiveTab();
|
|
}
|
|
} catch {
|
|
}
|
|
};
|
|
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");
|
|
};
|
|
const handleKeydown = (event) => {
|
|
const code = getEventCode(event);
|
|
if ([EVENT_CODE.enter, EVENT_CODE.numpadEnter].includes(code))
|
|
handleTabAdd();
|
|
};
|
|
const swapChildren = (vnode) => {
|
|
const actualFirstChild = vnode.el.firstChild;
|
|
const firstChild = ["bottom", "right"].includes(props2.tabPosition) ? vnode.children[0].el : vnode.children[1].el;
|
|
if (actualFirstChild !== firstChild)
|
|
actualFirstChild.before(firstChild);
|
|
};
|
|
watch(() => props2.modelValue, (modelValue) => setCurrentName(modelValue));
|
|
watch(currentName, async () => {
|
|
var _a2;
|
|
await nextTick();
|
|
(_a2 = nav$.value) == null ? void 0 : _a2.scrollToActiveTab();
|
|
});
|
|
provide(tabsRootContextKey, {
|
|
props: props2,
|
|
currentName,
|
|
registerPane,
|
|
unregisterPane,
|
|
nav$
|
|
});
|
|
expose({
|
|
currentName,
|
|
get tabNavRef() {
|
|
return omit_default(nav$.value, ["scheduleRender"]);
|
|
}
|
|
});
|
|
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": props2.tabindex,
|
|
"onClick": handleTabAdd,
|
|
"onKeydown": handleKeydown
|
|
}, [addSlot ? renderSlot(slots, "add-icon") : createVNode(ElIcon, { "class": ns.is("icon-plus") }, { default: () => [createVNode(plus_default, null, null)] })]) : null;
|
|
const tabNav = () => createVNode(TabNav, {
|
|
"ref": nav$,
|
|
"currentName": currentName.value,
|
|
"editable": props2.editable,
|
|
"type": props2.type,
|
|
"panes": panes.value,
|
|
"stretch": props2.stretch,
|
|
"onTabClick": handleTabClick,
|
|
"onTabRemove": handleTabRemove
|
|
}, null);
|
|
const header = createVNode("div", { "class": [
|
|
ns.e("header"),
|
|
isVertical.value && ns.e("header-vertical"),
|
|
ns.is(props2.tabPosition)
|
|
] }, [createVNode(PanesSorter, null, {
|
|
default: tabNav,
|
|
$stable: true
|
|
}), 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"
|
|
}
|
|
],
|
|
"onVnodeMounted": swapChildren,
|
|
"onVnodeUpdated": swapChildren
|
|
}, [panels, header]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tabs/src/tab-pane.mjs
|
|
var tabPaneProps = buildProps({
|
|
label: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
name: { type: [String, Number] },
|
|
closable: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
disabled: Boolean,
|
|
lazy: Boolean
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tabs/src/tab-pane.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_169 = [
|
|
"id",
|
|
"aria-hidden",
|
|
"aria-labelledby"
|
|
];
|
|
var COMPONENT_NAME21 = "ElTabPane";
|
|
var tab_pane_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: COMPONENT_NAME21,
|
|
__name: "tab-pane",
|
|
props: tabPaneProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const instance = getCurrentInstance();
|
|
const slots = useSlots();
|
|
const tabsRoot = inject(tabsRootContextKey);
|
|
if (!tabsRoot)
|
|
throwError(COMPONENT_NAME21, "usage: <el-tabs><el-tab-pane /></el-tabs/>");
|
|
const ns = useNamespace("tab-pane");
|
|
const paneRef = ref();
|
|
const index = ref();
|
|
const isClosable = computed(() => {
|
|
var _a;
|
|
return (_a = props2.closable) != null ? _a : tabsRoot.props.closable;
|
|
});
|
|
const active = computed(() => {
|
|
var _a;
|
|
return tabsRoot.currentName.value === ((_a = props2.name) != null ? _a : index.value);
|
|
});
|
|
const loaded = ref(active.value);
|
|
const paneName = computed(() => {
|
|
var _a;
|
|
return (_a = props2.name) != null ? _a : index.value;
|
|
});
|
|
const shouldBeRender = computed(() => !props2.lazy || loaded.value || active.value);
|
|
const isFocusInsidePane = () => {
|
|
var _a;
|
|
return (_a = paneRef.value) == null ? void 0 : _a.contains(document.activeElement);
|
|
};
|
|
watch(active, (val) => {
|
|
if (val)
|
|
loaded.value = true;
|
|
});
|
|
const pane = reactive({
|
|
uid: instance.uid,
|
|
getVnode: () => instance.vnode,
|
|
slots,
|
|
props: props2,
|
|
paneName,
|
|
active,
|
|
index,
|
|
isClosable,
|
|
isFocusInsidePane
|
|
});
|
|
tabsRoot.registerPane(pane);
|
|
onBeforeUnmount(() => {
|
|
tabsRoot.unregisterPane(pane);
|
|
});
|
|
onBeforeUpdate(() => {
|
|
var _a;
|
|
if (slots.label)
|
|
(_a = tabsRoot.nav$.value) == null ? void 0 : _a.scheduleRender();
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return shouldBeRender.value ? withDirectives((openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
id: `pane-${paneName.value}`,
|
|
ref_key: "paneRef",
|
|
ref: paneRef,
|
|
class: normalizeClass(unref(ns).b()),
|
|
role: "tabpanel",
|
|
"aria-hidden": !active.value,
|
|
"aria-labelledby": `tab-${paneName.value}`
|
|
}, [renderSlot(_ctx.$slots, "default")], 10, _hoisted_169)), [[vShow, active.value]]) : createCommentVNode("v-if", true);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tabs/src/tab-pane2.mjs
|
|
var tab_pane_default = tab_pane_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/tabs/index.mjs
|
|
var ElTabs = withInstall(Tabs, { TabPane: tab_pane_default });
|
|
var ElTabPane = withNoopInstall(tab_pane_default);
|
|
|
|
// 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/text.vue_vue_type_script_setup_true_lang.mjs
|
|
var text_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElText",
|
|
__name: "text",
|
|
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 bindTitle = () => {
|
|
var _a, _b, _c, _d, _e, _f, _g;
|
|
if (useAttrs().title)
|
|
return;
|
|
let shouldAddTitle = false;
|
|
const text = ((_a = textRef.value) == null ? void 0 : _a.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(__props.tag), {
|
|
ref_key: "textRef",
|
|
ref: textRef,
|
|
class: normalizeClass(textKls.value),
|
|
style: normalizeStyle({ "-webkit-line-clamp": __props.lineClamp })
|
|
}, {
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
|
|
_: 3
|
|
}, 8, ["class", "style"]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/text/src/text2.mjs
|
|
var text_default = text_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/text/index.mjs
|
|
var ElText = withInstall(text_default);
|
|
|
|
// node_modules/element-plus/es/components/time-select/src/time-select.mjs
|
|
var DEFAULT_STEP = "00:30";
|
|
var timeSelectProps = buildProps({
|
|
format: {
|
|
type: String,
|
|
default: "HH:mm"
|
|
},
|
|
modelValue: { type: definePropType(String) },
|
|
disabled: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
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: DEFAULT_STEP
|
|
},
|
|
minTime: { type: definePropType(String) },
|
|
maxTime: { type: definePropType(String) },
|
|
includeEndTime: Boolean,
|
|
name: String,
|
|
prefixIcon: {
|
|
type: definePropType([String, Object]),
|
|
default: () => clock_default
|
|
},
|
|
clearIcon: {
|
|
type: definePropType([String, Object]),
|
|
default: () => circle_close_default
|
|
},
|
|
popperClass: {
|
|
type: String,
|
|
default: ""
|
|
},
|
|
popperStyle: { type: definePropType([String, Object]) },
|
|
...useEmptyValuesProps
|
|
});
|
|
|
|
// 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, step2) => {
|
|
const timeValue = parseTime(time);
|
|
if (!timeValue)
|
|
return "";
|
|
const stepValue = parseTime(step2);
|
|
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-select.vue_vue_type_script_setup_true_lang.mjs
|
|
var import_dayjs19 = __toESM(require_dayjs_min(), 1);
|
|
var import_customParseFormat3 = __toESM(require_customParseFormat(), 1);
|
|
var time_select_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElTimeSelect",
|
|
__name: "time-select",
|
|
props: timeSelectProps,
|
|
emits: [
|
|
CHANGE_EVENT,
|
|
"blur",
|
|
"focus",
|
|
"clear",
|
|
UPDATE_MODEL_EVENT
|
|
],
|
|
setup(__props, { expose: __expose }) {
|
|
import_dayjs19.default.extend(import_customParseFormat3.default);
|
|
const { Option: ElOption2 } = ElSelect;
|
|
const props2 = __props;
|
|
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 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 step2 = computed(() => {
|
|
const time = parseTime(props2.step);
|
|
const isInvalidStep = !time || time.hours < 0 || time.minutes < 0 || Number.isNaN(time.hours) || Number.isNaN(time.minutes) || time.hours === 0 && time.minutes === 0;
|
|
if (isInvalidStep)
|
|
debugWarn("ElTimeSelect", `invalid step, fallback to default step (${DEFAULT_STEP}).`);
|
|
return !isInvalidStep ? formatTime2(time) : DEFAULT_STEP;
|
|
});
|
|
const items = computed(() => {
|
|
var _a;
|
|
const result2 = [];
|
|
const push = (formattedValue, rawValue) => {
|
|
result2.push({
|
|
value: formattedValue,
|
|
rawValue,
|
|
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_dayjs19.default)(current, "HH:mm").locale(lang.value).format(props2.format);
|
|
push(currentTime, current);
|
|
current = nextTime(current, step2.value);
|
|
}
|
|
if (props2.includeEndTime && end.value && ((_a = result2[result2.length - 1]) == null ? void 0 : _a.rawValue) !== end.value)
|
|
push((0, import_dayjs19.default)(end.value, "HH:mm").locale(lang.value).format(props2.format), end.value);
|
|
}
|
|
return result2;
|
|
});
|
|
const blur = () => {
|
|
var _a, _b;
|
|
(_b = (_a = select.value) == null ? void 0 : _a.blur) == null ? void 0 : _b.call(_a);
|
|
};
|
|
const focus = () => {
|
|
var _a, _b;
|
|
(_b = (_a = select.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
|
|
};
|
|
__expose({
|
|
blur,
|
|
focus
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(unref(ElSelect), {
|
|
ref_key: "select",
|
|
ref: select,
|
|
name: __props.name,
|
|
"model-value": value.value,
|
|
disabled: unref(_disabled),
|
|
clearable: __props.clearable,
|
|
"clear-icon": __props.clearIcon,
|
|
size: __props.size,
|
|
effect: __props.effect,
|
|
placeholder: __props.placeholder,
|
|
"default-first-option": "",
|
|
filterable: __props.editable,
|
|
"empty-values": __props.emptyValues,
|
|
"value-on-clear": __props.valueOnClear,
|
|
"popper-class": __props.popperClass,
|
|
"popper-style": __props.popperStyle,
|
|
"onUpdate:modelValue": _cache[0] || (_cache[0] = (event) => _ctx.$emit(unref(UPDATE_MODEL_EVENT), event)),
|
|
onChange: _cache[1] || (_cache[1] = (event) => _ctx.$emit(unref(CHANGE_EVENT), event)),
|
|
onBlur: _cache[2] || (_cache[2] = (event) => _ctx.$emit("blur", event)),
|
|
onFocus: _cache[3] || (_cache[3] = (event) => _ctx.$emit("focus", event)),
|
|
onClear: _cache[4] || (_cache[4] = () => _ctx.$emit("clear"))
|
|
}, {
|
|
prefix: withCtx(() => [__props.prefixIcon ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(nsInput).e("prefix-icon"))
|
|
}, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.prefixIcon)))]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true)]),
|
|
default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(items.value, (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, [
|
|
"name",
|
|
"model-value",
|
|
"disabled",
|
|
"clearable",
|
|
"clear-icon",
|
|
"size",
|
|
"effect",
|
|
"placeholder",
|
|
"filterable",
|
|
"empty-values",
|
|
"value-on-clear",
|
|
"popper-class",
|
|
"popper-style"
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/time-select/src/time-select2.mjs
|
|
var time_select_default = time_select_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/time-select/index.mjs
|
|
var ElTimeSelect = withInstall(time_select_default);
|
|
|
|
// node_modules/element-plus/es/components/timeline/src/tokens.mjs
|
|
var TIMELINE_INJECTION_KEY = "timeline";
|
|
|
|
// node_modules/element-plus/es/components/timeline/src/timeline.mjs
|
|
var timelineProps = buildProps({
|
|
mode: {
|
|
type: String,
|
|
values: [
|
|
"start",
|
|
"alternate",
|
|
"alternate-reverse",
|
|
"end"
|
|
],
|
|
default: "start"
|
|
},
|
|
reverse: Boolean
|
|
});
|
|
var Timeline = defineComponent({
|
|
name: "ElTimeline",
|
|
props: timelineProps,
|
|
setup(props2, { slots }) {
|
|
const ns = useNamespace("timeline");
|
|
provide(TIMELINE_INJECTION_KEY, {
|
|
props: props2,
|
|
slots
|
|
});
|
|
const timelineKls = computed(() => [ns.b(), ns.is(props2.mode)]);
|
|
return () => {
|
|
var _a, _b;
|
|
const children = flattedChildren((_b = (_a = slots.default) == null ? void 0 : _a.call(slots)) != null ? _b : []);
|
|
return h("ul", { class: timelineKls.value }, props2.reverse ? children.reverse() : children);
|
|
};
|
|
}
|
|
});
|
|
|
|
// 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-item.vue_vue_type_script_setup_true_lang.mjs
|
|
var timeline_item_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElTimelineItem",
|
|
__name: "timeline-item",
|
|
props: timelineItemProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const { props: timelineProps2 } = inject(TIMELINE_INJECTION_KEY);
|
|
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)
|
|
]);
|
|
const timelineItemKls = computed(() => [
|
|
ns.b(),
|
|
{ [ns.e("center")]: props2.center },
|
|
ns.is(timelineProps2.mode)
|
|
]);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("li", { class: normalizeClass(timelineItemKls.value) }, [
|
|
createBaseVNode("div", { class: normalizeClass(unref(ns).e("tail")) }, null, 2),
|
|
!_ctx.$slots.dot ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass(defaultNodeKls.value),
|
|
style: normalizeStyle({ backgroundColor: __props.color })
|
|
}, [__props.icon ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("icon"))
|
|
}, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.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")) }, [
|
|
!__props.hideTimestamp && __props.placement === "top" ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("timestamp"), unref(ns).is("top")])
|
|
}, toDisplayString(__props.timestamp), 3)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", { class: normalizeClass(unref(ns).e("content")) }, [renderSlot(_ctx.$slots, "default")], 2),
|
|
!__props.hideTimestamp && __props.placement === "bottom" ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass([unref(ns).e("timestamp"), unref(ns).is("bottom")])
|
|
}, toDisplayString(__props.timestamp), 3)) : createCommentVNode("v-if", true)
|
|
], 2)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/timeline/src/timeline-item2.mjs
|
|
var timeline_item_default = timeline_item_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/timeline/index.mjs
|
|
var ElTimeline = withInstall(Timeline, { TimelineItem: timeline_item_default });
|
|
var ElTimelineItem = withNoopInstall(timeline_item_default);
|
|
|
|
// 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/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-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/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), {}));
|
|
return {
|
|
sourceData: computed(() => props2.data.filter((item) => !props2.modelValue.includes(item[propsAlias.value.key]))),
|
|
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;
|
|
}, []);
|
|
})
|
|
};
|
|
};
|
|
|
|
// 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/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-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
|
|
return String(item[propsAlias.value.label] || item[propsAlias.value.key]).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)
|
|
emit(CHECKED_CHANGE_EVENT, val, val.concat(oldVal).filter((v2) => !val.includes(v2) || !oldVal.includes(v2)));
|
|
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-panel.vue_vue_type_script_setup_true_lang.mjs
|
|
var transfer_panel_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElTransferPanel",
|
|
__name: "transfer-panel",
|
|
props: transferPanelProps,
|
|
emits: transferPanelEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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": _cache[0] || (_cache[0] = ($event) => isRef(allChecked) ? allChecked.value = $event : null),
|
|
indeterminate: unref(isIndeterminate),
|
|
"validate-event": false,
|
|
onChange: unref(handleAllCheckedChange)
|
|
}, {
|
|
default: withCtx(() => [createBaseVNode("span", { class: normalizeClass(unref(ns).be("panel", "header-title")) }, toDisplayString(__props.title), 3), createBaseVNode("span", { class: normalizeClass(unref(ns).be("panel", "header-count")) }, toDisplayString(unref(checkedSummary)), 3)]),
|
|
_: 1
|
|
}, 8, [
|
|
"modelValue",
|
|
"indeterminate",
|
|
"onChange"
|
|
])], 2),
|
|
createBaseVNode("div", { class: normalizeClass([unref(ns).be("panel", "body"), unref(ns).is("with-footer", hasFooter.value)]) }, [
|
|
__props.filterable ? (openBlock(), createBlock(unref(ElInput), {
|
|
key: 0,
|
|
modelValue: unref(query),
|
|
"onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => isRef(query) ? query.value = $event : null),
|
|
class: normalizeClass(unref(ns).be("panel", "filter")),
|
|
size: "default",
|
|
placeholder: __props.placeholder,
|
|
"prefix-icon": unref(search_default),
|
|
clearable: "",
|
|
"validate-event": false
|
|
}, null, 8, [
|
|
"modelValue",
|
|
"class",
|
|
"placeholder",
|
|
"prefix-icon"
|
|
])) : createCommentVNode("v-if", true),
|
|
withDirectives(createVNode(unref(ElCheckboxGroup), {
|
|
modelValue: unref(checked),
|
|
"onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => isRef(checked) ? checked.value = $event : null),
|
|
"validate-event": false,
|
|
class: normalizeClass([unref(ns).is("filterable", __props.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 _a;
|
|
return [createVNode(OptionContent, { option: (_a = __props.optionRender) == null ? void 0 : _a.call(__props, item) }, null, 8, ["option"])];
|
|
}),
|
|
_: 2
|
|
}, 1032, [
|
|
"class",
|
|
"value",
|
|
"disabled"
|
|
]);
|
|
}), 128))]),
|
|
_: 1
|
|
}, 8, ["modelValue", "class"]), [[vShow, !hasNoMatch.value && !unref(isEmpty2)(__props.data)]]),
|
|
withDirectives(createBaseVNode("div", { class: normalizeClass(unref(ns).be("panel", "empty")) }, [renderSlot(_ctx.$slots, "empty", {}, () => [createTextVNode(toDisplayString(hasNoMatch.value ? unref(t)("el.transfer.noMatch") : unref(t)("el.transfer.noData")), 1)])], 2), [[vShow, hasNoMatch.value || unref(isEmpty2)(__props.data)]])
|
|
], 2),
|
|
hasFooter.value ? (openBlock(), createElementBlock("p", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).be("panel", "footer"))
|
|
}, [renderSlot(_ctx.$slots, "default")], 2)) : createCommentVNode("v-if", true)
|
|
], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/transfer/src/transfer-panel2.mjs
|
|
var transfer_panel_default = transfer_panel_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/transfer/src/transfer.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_170 = { key: 0 };
|
|
var _hoisted_238 = { key: 0 };
|
|
var transfer_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElTransfer",
|
|
__name: "transfer",
|
|
props: transferProps,
|
|
emits: transferEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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 _a;
|
|
if (props2.validateEvent)
|
|
(_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "change").catch((err) => debugWarn(err));
|
|
});
|
|
const optionRender = computed(() => (option) => {
|
|
var _a;
|
|
if (props2.renderContent)
|
|
return props2.renderContent(h, option);
|
|
const defaultSlotVNodes = (((_a = slots.default) == null ? void 0 : _a.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(transfer_panel_default, {
|
|
ref_key: "leftPanel",
|
|
ref: leftPanel,
|
|
data: unref(sourceData),
|
|
"option-render": optionRender.value,
|
|
placeholder: panelFilterPlaceholder.value,
|
|
title: leftPanelTitle.value,
|
|
filterable: __props.filterable,
|
|
format: __props.format,
|
|
"filter-method": __props.filterMethod,
|
|
"default-checked": __props.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", hasButtonTexts.value)]),
|
|
disabled: unref(isEmpty2)(checkedState.rightChecked),
|
|
onClick: unref(addToLeft)
|
|
}, {
|
|
default: withCtx(() => [createVNode(unref(ElIcon), null, {
|
|
default: withCtx(() => [createVNode(unref(arrow_left_default))]),
|
|
_: 1
|
|
}), !unref(isUndefined2)(__props.buttonTexts[0]) ? (openBlock(), createElementBlock("span", _hoisted_170, toDisplayString(__props.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", hasButtonTexts.value)]),
|
|
disabled: unref(isEmpty2)(checkedState.leftChecked),
|
|
onClick: unref(addToRight)
|
|
}, {
|
|
default: withCtx(() => [!unref(isUndefined2)(__props.buttonTexts[1]) ? (openBlock(), createElementBlock("span", _hoisted_238, toDisplayString(__props.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(transfer_panel_default, {
|
|
ref_key: "rightPanel",
|
|
ref: rightPanel,
|
|
data: unref(targetData),
|
|
"option-render": optionRender.value,
|
|
placeholder: panelFilterPlaceholder.value,
|
|
filterable: __props.filterable,
|
|
format: __props.format,
|
|
"filter-method": __props.filterMethod,
|
|
title: rightPanelTitle.value,
|
|
"default-checked": __props.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);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/transfer/src/transfer2.mjs
|
|
var transfer_default = transfer_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/transfer/index.mjs
|
|
var ElTransfer = withInstall(transfer_default);
|
|
|
|
// node_modules/element-plus/es/components/tree/src/tokens.mjs
|
|
var ROOT_TREE_INJECTION_KEY = "RootTree";
|
|
var NODE_INSTANCE_INJECTION_KEY = "NodeInstance";
|
|
var TREE_NODE_MAP_INJECTION_KEY = "TreeNodeMap";
|
|
|
|
// node_modules/element-plus/es/components/tree/src/tree.mjs
|
|
var treeProps = buildProps({
|
|
data: {
|
|
type: definePropType(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: Boolean,
|
|
autoExpandParent: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
defaultCheckedKeys: { type: Array },
|
|
defaultExpandedKeys: { type: Array },
|
|
currentNodeKey: { type: [String, Number] },
|
|
renderContent: { type: definePropType(Function) },
|
|
showCheckbox: Boolean,
|
|
draggable: Boolean,
|
|
allowDrag: { type: definePropType(Function) },
|
|
allowDrop: { type: definePropType(Function) },
|
|
props: {
|
|
type: Object,
|
|
default: () => ({
|
|
children: "children",
|
|
label: "label",
|
|
disabled: "disabled"
|
|
})
|
|
},
|
|
lazy: Boolean,
|
|
highlightCurrent: Boolean,
|
|
load: { type: Function },
|
|
filterNodeMethod: { type: Function },
|
|
accordion: Boolean,
|
|
indent: {
|
|
type: Number,
|
|
default: 18
|
|
},
|
|
icon: { type: iconPropType }
|
|
});
|
|
var treeEmits = {
|
|
"check-change": (data, checked, indeterminate) => data && isBoolean2(checked) && isBoolean2(indeterminate),
|
|
"current-change": (data, node) => true,
|
|
"node-click": (data, node, nodeInstance, evt) => data && node && evt instanceof Event,
|
|
"node-contextmenu": (evt, data, node, nodeInstance) => evt instanceof Event && data && node,
|
|
"node-collapse": (data, node, nodeInstance) => data && node,
|
|
"node-expand": (data, node, nodeInstance) => data && node,
|
|
check: (data, checkedInfo) => data && checkedInfo,
|
|
"node-drag-start": (node, evt) => node && evt,
|
|
"node-drag-end": (draggingNode, dropNode, dropType, evt) => draggingNode && evt,
|
|
"node-drop": (draggingNode, dropNode, dropType, evt) => draggingNode && dropNode && evt,
|
|
"node-drag-leave": (draggingNode, oldDropNode, evt) => draggingNode && oldDropNode && evt,
|
|
"node-drag-enter": (draggingNode, dropNode, evt) => draggingNode && dropNode && evt,
|
|
"node-drag-over": (draggingNode, dropNode, evt) => draggingNode && dropNode && evt
|
|
};
|
|
|
|
// 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;
|
|
let isEffectivelyChecked = 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;
|
|
if (!n.isEffectivelyChecked)
|
|
isEffectivelyChecked = false;
|
|
}
|
|
return {
|
|
all,
|
|
none,
|
|
allWithoutDisable,
|
|
half: !all && !none,
|
|
isEffectivelyChecked
|
|
};
|
|
};
|
|
var reInitChecked = function(node) {
|
|
if (node.childNodes.length === 0 || node.loading) {
|
|
node.isEffectivelyChecked = node.disabled || node.checked;
|
|
return;
|
|
}
|
|
const { all, none, half, isEffectivelyChecked } = getChildState(node.childNodes);
|
|
node.isEffectivelyChecked = isEffectivelyChecked;
|
|
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 setCanFocus = function(childNodes, focus) {
|
|
childNodes.forEach((item) => {
|
|
item.canFocus = focus;
|
|
setCanFocus(item.childNodes, focus);
|
|
});
|
|
};
|
|
var nodeIdSeed = 0;
|
|
var Node4 = class Node5 {
|
|
constructor(options) {
|
|
this.isLeafByUser = void 0;
|
|
this.isLeaf = void 0;
|
|
this.isEffectivelyChecked = false;
|
|
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() {
|
|
var _a;
|
|
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 && !isNil_default(this.key) && defaultExpandedKeys && defaultExpandedKeys.includes(this.key))
|
|
this.expand(null, store.autoExpandParent);
|
|
if (key && store.currentNodeKey !== void 0 && this.key === store.currentNodeKey) {
|
|
store.currentNode && (store.currentNode.isCurrent = false);
|
|
store.currentNode = this;
|
|
store.currentNode.isCurrent = true;
|
|
}
|
|
if (store.lazy)
|
|
store._initDefaultCheckedNode(this);
|
|
this.updateLeafState();
|
|
if (this.level === 1 || ((_a = this.parent) == null ? void 0 : _a.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 Node5)) {
|
|
if (!batch) {
|
|
const children = this.getChildren(true);
|
|
if (!(children == null ? void 0 : children.includes(child.data)))
|
|
if (isUndefined2(index) || index < 0)
|
|
children == null ? void 0 : children.push(child.data);
|
|
else
|
|
children == null ? void 0 : children.splice(index, 0, child.data);
|
|
}
|
|
Object.assign(child, {
|
|
parent: this,
|
|
store: this.store
|
|
});
|
|
child = reactive(new Node5(child));
|
|
if (child instanceof Node5)
|
|
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) {
|
|
const targetNode = this.childNodes.find((child) => child.data === data);
|
|
if (targetNode)
|
|
this.removeChild(targetNode);
|
|
}
|
|
expand(callback, expandParent) {
|
|
const done = () => {
|
|
if (expandParent) {
|
|
let parent2 = this.parent;
|
|
while (parent2 && parent2.level > 0) {
|
|
parent2.expanded = true;
|
|
parent2 = parent2.parent;
|
|
}
|
|
}
|
|
this.expanded = true;
|
|
if (callback)
|
|
callback();
|
|
setCanFocus(this.childNodes, 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, defaultProps4 = {}) {
|
|
array4.forEach((item) => {
|
|
this.insertChild(Object.assign({ data: item }, defaultProps4), void 0, true);
|
|
});
|
|
}
|
|
collapse() {
|
|
this.expanded = false;
|
|
setCanFocus(this.childNodes, false);
|
|
}
|
|
shouldLoadData() {
|
|
return Boolean(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;
|
|
this.isEffectivelyChecked = this.isLeaf && this.disabled;
|
|
return;
|
|
}
|
|
const childNodes = this.childNodes;
|
|
if (!this.store.lazy || this.store.lazy === true && this.loaded === true) {
|
|
this.isLeaf = !childNodes || childNodes.length === 0;
|
|
this.isEffectivelyChecked = this.isLeaf && this.disabled;
|
|
return;
|
|
}
|
|
this.isLeaf = false;
|
|
}
|
|
setChecked(value, deep, recursion, passValue) {
|
|
this.indeterminate = value === "half";
|
|
this.checked = value === true;
|
|
this.isEffectivelyChecked = !this.childNodes.length && (this.disabled || this.checked);
|
|
if (this.store.checkStrictly)
|
|
return;
|
|
if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
|
|
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.isLeaf ? child.checked : passValue;
|
|
child.setChecked(isCheck, deep, true, passValue);
|
|
}
|
|
const { half, all, isEffectivelyChecked } = getChildState(childNodes);
|
|
if (!all) {
|
|
this.checked = all;
|
|
this.indeterminate = half;
|
|
}
|
|
this.isEffectivelyChecked = !this.childNodes.length ? this.disabled || this.checked : isEffectivelyChecked;
|
|
}
|
|
};
|
|
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];
|
|
if (!!key && oldData.some((data) => (data == null ? void 0 : data[NODE_KEY]) === key))
|
|
newDataMap[key] = {
|
|
index,
|
|
data: item
|
|
};
|
|
else
|
|
newNodes.push({
|
|
index,
|
|
data: item
|
|
});
|
|
});
|
|
if (!this.store.lazy)
|
|
oldData.forEach((item) => {
|
|
if (!newDataMap[item == null ? void 0 : item[NODE_KEY]])
|
|
this.removeChildByData(item);
|
|
});
|
|
newNodes.forEach(({ index, data }) => {
|
|
this.insertChild({ data }, index);
|
|
});
|
|
this.updateLeafState();
|
|
}
|
|
loadData(callback, defaultProps4 = {}) {
|
|
if (this.store.lazy === true && this.store.load && !this.loaded && (!this.loading || Object.keys(defaultProps4).length)) {
|
|
this.loading = true;
|
|
const resolve = (children) => {
|
|
this.childNodes = [];
|
|
this.doCreateChildren(children, defaultProps4);
|
|
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.lazy = false;
|
|
this.checkStrictly = false;
|
|
this.autoExpandParent = false;
|
|
this.defaultExpandAll = false;
|
|
this.checkDescendants = false;
|
|
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 Node4({
|
|
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();
|
|
}, NOOP);
|
|
} 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 == null ? void 0 : 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) {
|
|
if (newVal !== this.root.data) {
|
|
this.nodesMap = {};
|
|
this.root.setData(newVal);
|
|
this._initDefaultCheckedNodes();
|
|
this.setCurrentNodeKey(this.currentNodeKey);
|
|
} else
|
|
this.root.updateChildren();
|
|
}
|
|
getNode(data) {
|
|
if (data instanceof Node4)
|
|
return data;
|
|
const key = isObject(data) ? getNodeKey(this.key, data) : data;
|
|
return this.nodesMap[key] || null;
|
|
}
|
|
insertBefore(data, refData) {
|
|
var _a;
|
|
const refNode = this.getNode(refData);
|
|
(_a = refNode.parent) == null ? void 0 : _a.insertBefore({ data }, refNode);
|
|
}
|
|
insertAfter(data, refData) {
|
|
var _a;
|
|
const refNode = this.getNode(refData);
|
|
(_a = refNode.parent) == null ? void 0 : _a.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 (!isNil_default(node.key) && 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 (!isNil_default(nodeKey))
|
|
this.nodesMap[nodeKey] = node;
|
|
}
|
|
}
|
|
deregisterNode(node) {
|
|
if (!this.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) {
|
|
(node.root ? node.root.childNodes : node.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) {
|
|
(node.root ? node.root.childNodes : node.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 = /* @__PURE__ */ Object.create(null);
|
|
const keys3 = Object.keys(checkedKeys);
|
|
allNodes.forEach((node) => node.setChecked(false, false));
|
|
const cacheCheckedChild = (node) => {
|
|
node.childNodes.forEach((child) => {
|
|
var _a;
|
|
cache2[child.data[key]] = true;
|
|
if ((_a = child.childNodes) == null ? void 0 : _a.length)
|
|
cacheCheckedChild(child);
|
|
});
|
|
};
|
|
for (let i = 0, j = allNodes.length; i < j; i++) {
|
|
const node = allNodes[i];
|
|
const nodeKey = node.data[key].toString();
|
|
if (!keys3.includes(nodeKey)) {
|
|
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, true);
|
|
const traverse = function(node2) {
|
|
node2.childNodes.forEach((child) => {
|
|
if (!child.isLeaf)
|
|
child.setChecked(false, false, true);
|
|
traverse(child);
|
|
});
|
|
node2.reInitChecked();
|
|
};
|
|
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) {
|
|
var _a;
|
|
const key = node[this.key];
|
|
const currNode = this.nodesMap[key];
|
|
this.setCurrentNode(currNode);
|
|
if (shouldAutoExpandParent && this.currentNode && this.currentNode.level > 1)
|
|
(_a = this.currentNode.parent) == null ? void 0 : _a.expand(null, true);
|
|
}
|
|
setCurrentNodeKey(key, shouldAutoExpandParent = true) {
|
|
var _a;
|
|
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 && this.currentNode.level > 1)
|
|
(_a = this.currentNode.parent) == null ? void 0 : _a.expand(null, true);
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/tree/src/model/useNodeExpandEventBroadcast.mjs
|
|
function useNodeExpandEventBroadcast(props2) {
|
|
const parentNodeMap = inject(TREE_NODE_MAP_INJECTION_KEY, null);
|
|
let currentNodeMap = {
|
|
treeNodeExpand: (node) => {
|
|
var _a;
|
|
if (props2.node !== node)
|
|
(_a = props2.node) == null ? void 0 : _a.collapse();
|
|
},
|
|
children: /* @__PURE__ */ new Set()
|
|
};
|
|
if (parentNodeMap)
|
|
parentNodeMap.children.add(currentNodeMap);
|
|
onBeforeUnmount(() => {
|
|
if (parentNodeMap)
|
|
parentNodeMap.children.delete(currentNodeMap);
|
|
currentNodeMap = null;
|
|
});
|
|
provide(TREE_NODE_MAP_INJECTION_KEY, 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 (!event.dataTransfer)
|
|
return;
|
|
if (isFunction(props2.allowDrag) && !props2.allowDrag(treeNode.node)) {
|
|
event.preventDefault();
|
|
return false;
|
|
}
|
|
event.dataTransfer.effectAllowed = "move";
|
|
try {
|
|
event.dataTransfer.setData("text/plain", "");
|
|
} catch {
|
|
}
|
|
dragState.value.draggingNode = treeNode;
|
|
ctx.emit("node-drag-start", treeNode.node, event);
|
|
};
|
|
const treeNodeDragOver = ({ event, treeNode }) => {
|
|
if (!event.dataTransfer)
|
|
return;
|
|
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 dropEl = dropNode.$el;
|
|
const targetPosition = dropEl.querySelector(`.${ns.be("node", "content")}`).getBoundingClientRect();
|
|
const treePosition = el$.value.getBoundingClientRect();
|
|
const treeScrollTop = el$.value.scrollTop;
|
|
let dropType;
|
|
const prevPercent = dropPrev ? dropInner ? 0.25 : dropNext ? 0.45 : 1 : Number.NEGATIVE_INFINITY;
|
|
const nextPercent = dropNext ? dropInner ? 0.75 : dropPrev ? 0.55 : 0 : Number.POSITIVE_INFINITY;
|
|
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 = dropEl.querySelector(`.${ns.be("node", "expand-icon")}`).getBoundingClientRect();
|
|
const dropIndicator = dropIndicator$.value;
|
|
if (dropType === "before")
|
|
indicatorTop = iconPosition.top - treePosition.top + treeScrollTop;
|
|
else if (dropType === "after")
|
|
indicatorTop = iconPosition.bottom - treePosition.top + treeScrollTop;
|
|
dropIndicator.style.top = `${indicatorTop}px`;
|
|
dropIndicator.style.left = `${iconPosition.right - treePosition.left}px`;
|
|
if (dropType === "inner")
|
|
addClass(dropEl, ns.is("drop-inner"));
|
|
else
|
|
removeClass(dropEl, 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) => {
|
|
var _a, _b;
|
|
const { draggingNode, dropType, dropNode } = dragState.value;
|
|
event.preventDefault();
|
|
if (event.dataTransfer)
|
|
event.dataTransfer.dropEffect = "move";
|
|
if ((draggingNode == null ? void 0 : draggingNode.node.data) && dropNode) {
|
|
const draggingNodeCopy = { data: draggingNode.node.data };
|
|
if (dropType !== "none")
|
|
draggingNode.node.remove();
|
|
if (dropType === "before")
|
|
(_a = dropNode.node.parent) == null ? void 0 : _a.insertBefore(draggingNodeCopy, dropNode.node);
|
|
else if (dropType === "after")
|
|
(_b = dropNode.node.parent) == null ? void 0 : _b.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-content.vue_vue_type_script_lang.mjs
|
|
var tree_node_content_vue_vue_type_script_lang_default = defineComponent({
|
|
name: "ElTreeNodeContent",
|
|
props: {
|
|
node: {
|
|
type: Object,
|
|
required: true
|
|
},
|
|
renderContent: Function
|
|
},
|
|
setup(props2) {
|
|
const ns = useNamespace("tree");
|
|
const nodeInstance = inject(NODE_INSTANCE_INJECTION_KEY);
|
|
const tree = inject(ROOT_TREE_INJECTION_KEY);
|
|
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])]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tree/src/tree-node-content.mjs
|
|
var tree_node_content_default = tree_node_content_vue_vue_type_script_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/tree/src/tree-node.vue_vue_type_script_lang.mjs
|
|
var tree_node_vue_vue_type_script_lang_default = defineComponent({
|
|
name: "ElTreeNode",
|
|
components: {
|
|
ElCollapseTransition,
|
|
ElCheckbox,
|
|
NodeContent: tree_node_content_default,
|
|
ElIcon,
|
|
Loading: loading_default
|
|
},
|
|
props: {
|
|
node: {
|
|
type: Node4,
|
|
default: () => ({})
|
|
},
|
|
props: {
|
|
type: Object,
|
|
default: () => ({})
|
|
},
|
|
accordion: Boolean,
|
|
renderContent: Function,
|
|
renderAfterExpand: Boolean,
|
|
showCheckbox: Boolean
|
|
},
|
|
emits: ["node-expand"],
|
|
setup(props2, ctx) {
|
|
const ns = useNamespace("tree");
|
|
const { broadcastExpanded } = useNodeExpandEventBroadcast(props2);
|
|
const tree = inject(ROOT_TREE_INJECTION_KEY);
|
|
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(NODE_INSTANCE_INJECTION_KEY, 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 _a;
|
|
const children = (_a = props2.node.data) == null ? void 0 : _a[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 tree.props.nodeKey ? getNodeKey(tree.props.nodeKey, node.data) : node.id;
|
|
};
|
|
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 _a;
|
|
if ((_a = tree == null ? void 0 : tree.props) == null ? void 0 : _a.nodeKey) {
|
|
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 _a;
|
|
if ((_a = tree.instance.vnode.props) == null ? void 0 : _a["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) => {
|
|
const checkStrictly = tree == null ? void 0 : tree.props.checkStrictly;
|
|
const childNodes = props2.node.childNodes;
|
|
if (!checkStrictly && childNodes.length)
|
|
value = childNodes.some((node) => !node.isEffectivelyChecked);
|
|
props2.node.setChecked(value, !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
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tree/src/tree-node.mjs
|
|
var _hoisted_171 = [
|
|
"aria-expanded",
|
|
"aria-disabled",
|
|
"aria-checked",
|
|
"draggable",
|
|
"data-key"
|
|
];
|
|
var _hoisted_239 = ["aria-expanded"];
|
|
function _sfc_render20(_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: _cache[2] || (_cache[2] = withModifiers((...args) => _ctx.handleClick && _ctx.handleClick(...args), ["stop"])),
|
|
onContextmenu: _cache[3] || (_cache[3] = (...args) => _ctx.handleContextMenu && _ctx.handleContextMenu(...args)),
|
|
onDragstart: _cache[4] || (_cache[4] = withModifiers((...args) => _ctx.handleDragStart && _ctx.handleDragStart(...args), ["stop"])),
|
|
onDragover: _cache[5] || (_cache[5] = withModifiers((...args) => _ctx.handleDragOver && _ctx.handleDragOver(...args), ["stop"])),
|
|
onDragend: _cache[6] || (_cache[6] = withModifiers((...args) => _ctx.handleDragEnd && _ctx.handleDragEnd(...args), ["stop"])),
|
|
onDrop: _cache[7] || (_cache[7] = withModifiers((...args) => _ctx.handleDrop && _ctx.handleDrop(...args), ["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: _cache[0] || (_cache[0] = withModifiers(() => {
|
|
}, ["stop"])),
|
|
onChange: _ctx.handleCheckChange
|
|
}, null, 8, [
|
|
"model-value",
|
|
"indeterminate",
|
|
"disabled",
|
|
"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: _cache[1] || (_cache[1] = 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, _hoisted_239)), [[vShow, _ctx.expanded]]) : createCommentVNode("v-if", true)]),
|
|
_: 1
|
|
})], 42, _hoisted_171)), [[vShow, _ctx.node.visible]]);
|
|
}
|
|
var tree_node_default = _plugin_vue_export_helper_default(tree_node_vue_vue_type_script_lang_default, [["render", _sfc_render20]]);
|
|
|
|
// node_modules/element-plus/es/components/tree/src/model/useKeydown.mjs
|
|
function useKeydown({ el$ }, store) {
|
|
const ns = useNamespace("tree");
|
|
onMounted(() => {
|
|
initTabIndex();
|
|
});
|
|
onUpdated(() => {
|
|
var _a;
|
|
(_a = el$.value) == null ? void 0 : _a.querySelectorAll("input[type=checkbox]").forEach((checkbox) => {
|
|
checkbox.setAttribute("tabindex", "-1");
|
|
});
|
|
});
|
|
function canNodeFocus(treeItems, nextIndex) {
|
|
var _a, _b;
|
|
const currentNode = store.value.getNode(treeItems[nextIndex].dataset.key);
|
|
return currentNode.canFocus && currentNode.visible && (((_a = currentNode.parent) == null ? void 0 : _a.expanded) || ((_b = currentNode.parent) == null ? void 0 : _b.level) === 0);
|
|
}
|
|
const handleKeydown = (ev) => {
|
|
const currentItem = ev.target;
|
|
if (!currentItem.className.includes(ns.b("node")))
|
|
return;
|
|
const code = getEventCode(ev);
|
|
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 (canNodeFocus(treeItems, nextIndex))
|
|
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 (canNodeFocus(treeItems, nextIndex))
|
|
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 _a;
|
|
if (!el$.value)
|
|
return;
|
|
const treeItems = Array.from(el$.value.querySelectorAll(`.${ns.is("focusable")}[role=treeitem]`));
|
|
Array.from(el$.value.querySelectorAll("input[type=checkbox]")).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;
|
|
}
|
|
(_a = treeItems[0]) == null ? void 0 : _a.setAttribute("tabindex", "0");
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/tree/src/tree.vue_vue_type_script_lang.mjs
|
|
var tree_vue_vue_type_script_lang_default = defineComponent({
|
|
name: "ElTree",
|
|
components: { ElTreeNode: tree_node_default },
|
|
props: treeProps,
|
|
emits: treeEmits,
|
|
setup(props2, ctx) {
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("tree");
|
|
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 instance = getCurrentInstance();
|
|
const isSelectTree = computed(() => {
|
|
let parent2 = instance == null ? void 0 : instance.parent;
|
|
while (parent2) {
|
|
if (parent2.type.name === "ElTreeSelect")
|
|
return true;
|
|
parent2 = parent2.parent;
|
|
}
|
|
return false;
|
|
});
|
|
const isEmpty3 = computed(() => {
|
|
const { childNodes } = root2.value;
|
|
return (!childNodes || childNodes.length === 0 || childNodes.every(({ visible }) => !visible)) && !isSelectTree.value;
|
|
});
|
|
watch(() => props2.currentNodeKey, (newVal) => {
|
|
store.value.setCurrentNodeKey(newVal != null ? newVal : null);
|
|
});
|
|
watch(() => props2.defaultCheckedKeys, (newVal, oldVal) => {
|
|
if (isEqual_default(newVal, oldVal))
|
|
return;
|
|
store.value.setDefaultCheckedKey(newVal != null ? newVal : []);
|
|
});
|
|
watch(() => props2.defaultExpandedKeys, (newVal) => {
|
|
store.value.setDefaultExpandedKeys(newVal != null ? 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 props2.nodeKey ? getNodeKey(props2.nodeKey, node.data) : node.id;
|
|
};
|
|
const requireNodeKey = (methodName) => {
|
|
if (!props2.nodeKey)
|
|
throw new Error(`[Tree] nodeKey is required in ${methodName}`);
|
|
};
|
|
const getNodePath = (data) => {
|
|
requireNodeKey("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 = () => {
|
|
requireNodeKey("getCurrentKey");
|
|
const currentNode2 = getCurrentNode();
|
|
return currentNode2 ? currentNode2[props2.nodeKey] : null;
|
|
};
|
|
const setCheckedNodes = (nodes, leafOnly) => {
|
|
requireNodeKey("setCheckedNodes");
|
|
store.value.setCheckedNodes(nodes, leafOnly);
|
|
};
|
|
const setCheckedKeys = (keys3, leafOnly) => {
|
|
requireNodeKey("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) => {
|
|
requireNodeKey("setCurrentNode");
|
|
handleCurrentChange(store, ctx.emit, () => {
|
|
broadcastExpanded(node);
|
|
store.value.setUserCurrentNode(node, shouldAutoExpandParent);
|
|
});
|
|
};
|
|
const setCurrentKey = (key = null, shouldAutoExpandParent = true) => {
|
|
requireNodeKey("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, instance2) => {
|
|
broadcastExpanded(node);
|
|
ctx.emit("node-expand", nodeData, node, instance2);
|
|
};
|
|
const updateKeyChildren = (key, data) => {
|
|
requireNodeKey("updateKeyChildren");
|
|
store.value.updateChildren(key, data);
|
|
};
|
|
provide(ROOT_TREE_INJECTION_KEY, {
|
|
ctx,
|
|
props: props2,
|
|
store,
|
|
root: root2,
|
|
currentNode,
|
|
instance
|
|
});
|
|
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
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tree/src/tree2.mjs
|
|
function _sfc_render21(_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 _a;
|
|
return [createBaseVNode("span", { class: normalizeClass(_ctx.ns.e("empty-text")) }, toDisplayString((_a = _ctx.emptyText) != null ? _a : _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_default = _plugin_vue_export_helper_default(tree_vue_vue_type_script_lang_default, [["render", _sfc_render21]]);
|
|
|
|
// node_modules/element-plus/es/components/tree/index.mjs
|
|
var ElTree = withInstall(tree_default);
|
|
|
|
// 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 _a, _b;
|
|
(_b = tree.value) == null ? void 0 : _b.filter((_a = select.value) == null ? void 0 : _a.states.inputValue);
|
|
});
|
|
}, { flush: "post" });
|
|
const focusLastNode = (listNode) => {
|
|
var _a, _b;
|
|
const lastNode = listNode.at(-1);
|
|
if (lastNode.expanded && lastNode.childNodes.at(-1))
|
|
focusLastNode([lastNode.childNodes.at(-1)]);
|
|
else {
|
|
(_b = (_a = tree.value.el$) == null ? void 0 : _a.querySelector(`[data-key="${listNode.at(-1).key}"]`)) == null ? void 0 : _b.focus({ preventScroll: true });
|
|
return;
|
|
}
|
|
};
|
|
onMounted(() => {
|
|
useEventListener(() => {
|
|
var _a;
|
|
return (_a = select.value) == null ? void 0 : _a.$el;
|
|
}, "keydown", async (evt) => {
|
|
const code = getEventCode(evt);
|
|
const { dropdownMenuVisible } = select.value;
|
|
if ([EVENT_CODE.down, EVENT_CODE.up].includes(code) && dropdownMenuVisible) {
|
|
await nextTick();
|
|
setTimeout(() => {
|
|
var _a, _b, _c;
|
|
if (EVENT_CODE.up === code) {
|
|
const listNode = tree.value.store.root.childNodes;
|
|
focusLastNode(listNode);
|
|
return;
|
|
}
|
|
(_c = (_b = (_a = select.value.optionsArray[select.value.states.hoveringIndex].$el) == null ? void 0 : _a.parentNode) == null ? void 0 : _b.parentNode) == null ? void 0 : _c.focus({ preventScroll: true });
|
|
});
|
|
}
|
|
}, { capture: true });
|
|
});
|
|
return {
|
|
...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 _a;
|
|
if (props2.filterMethod)
|
|
props2.filterMethod(keyword);
|
|
else if (props2.remoteMethod)
|
|
props2.remoteMethod(keyword);
|
|
else
|
|
(_a = tree.value) == null ? void 0 : _a.filter(keyword);
|
|
}
|
|
};
|
|
};
|
|
|
|
// 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, tree], () => {
|
|
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 _a;
|
|
const propVal = propsMap.value[prop];
|
|
if (isFunction(propVal))
|
|
return propVal(data, (_a = tree.value) == null ? void 0 : _a.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 _a;
|
|
return (_a = tree.value) == null ? void 0 : _a.getCheckedKeys().filter((checkedKey) => {
|
|
var _a2;
|
|
const node = (_a2 = tree.value) == null ? void 0 : _a2.getNode(checkedKey);
|
|
return !isNil_default(node) && isEmpty2(node.childNodes);
|
|
});
|
|
};
|
|
const emitChange = (val) => {
|
|
if (!isEqual_default(props2.modelValue, val))
|
|
emit(CHANGE_EVENT, val);
|
|
};
|
|
function update2(val) {
|
|
emit(UPDATE_MODEL_EVENT, val);
|
|
emitChange(val);
|
|
}
|
|
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;
|
|
return new RegExp(escapeStringRegexp(value), "i").test(getNodeValByProp("label", data) || "");
|
|
},
|
|
onNodeClick: (data, node, e) => {
|
|
var _a, _b, _c;
|
|
(_a = attrs.onNodeClick) == null ? void 0 : _a.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();
|
|
},
|
|
onCheck: (data, params) => {
|
|
var _a;
|
|
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)
|
|
update2(props2.multiple ? checkedKeys : checkedKeys.includes(dataValue) ? dataValue : void 0);
|
|
else if (props2.multiple) {
|
|
const childKeys = getChildCheckedKeys();
|
|
update2(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));
|
|
update2(firstLeafKey === props2.modelValue || hasCheckedChild ? void 0 : firstLeafKey);
|
|
}
|
|
nextTick(() => {
|
|
var _a2;
|
|
const checkedKeys2 = toValidArray(props2.modelValue);
|
|
tree.value.setCheckedKeys(checkedKeys2);
|
|
(_a2 = attrs.onCheck) == null ? void 0 : _a2.call(attrs, data, {
|
|
checkedKeys: tree.value.getCheckedKeys(),
|
|
checkedNodes: tree.value.getCheckedNodes(),
|
|
halfCheckedKeys: tree.value.getHalfCheckedKeys(),
|
|
halfCheckedNodes: tree.value.getHalfCheckedNodes()
|
|
});
|
|
});
|
|
(_a = select.value) == null ? void 0 : _a.focus();
|
|
},
|
|
onNodeExpand: (data, node, e) => {
|
|
var _a;
|
|
(_a = attrs.onNodeExpand) == null ? void 0 : _a.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();
|
|
update2(cachedKeys.concat(childKeys));
|
|
}
|
|
});
|
|
},
|
|
cacheOptions
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/tree-select/src/cache-options.mjs
|
|
var cache_options_default = defineComponent({
|
|
props: { data: {
|
|
type: Array,
|
|
default: () => []
|
|
} },
|
|
setup(props2) {
|
|
const select = inject(selectKey);
|
|
watch(() => props2.data, () => {
|
|
var _a;
|
|
props2.data.forEach((item) => {
|
|
if (!select.states.cachedOptions.has(item.value))
|
|
select.states.cachedOptions.set(item.value, item);
|
|
});
|
|
const inputs = ((_a = select.selectRef) == null ? void 0 : _a.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.vue_vue_type_script_lang.mjs
|
|
var tree_select_vue_vue_type_script_lang_default = defineComponent({
|
|
name: "ElTreeSelect",
|
|
inheritAttrs: false,
|
|
props: {
|
|
...selectProps,
|
|
...treeProps,
|
|
cacheData: {
|
|
type: Array,
|
|
default: () => []
|
|
}
|
|
},
|
|
setup(props2, context) {
|
|
const { slots, expose, emit, attrs } = context;
|
|
const childAttrs = {
|
|
...attrs,
|
|
onChange: void 0
|
|
};
|
|
const select = ref();
|
|
const tree = ref();
|
|
const key = computed(() => props2.nodeKey || props2.valueKey || "value");
|
|
const selectProps2 = useSelect3(props2, {
|
|
attrs,
|
|
emit
|
|
}, {
|
|
select,
|
|
tree,
|
|
key
|
|
});
|
|
const { cacheOptions, ...treeProps3 } = useTree2(props2, {
|
|
attrs: childAttrs,
|
|
slots,
|
|
emit
|
|
}, {
|
|
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"
|
|
]),
|
|
treeRef: tree.value,
|
|
selectRef: select.value
|
|
});
|
|
});
|
|
return () => h(
|
|
ElSelect,
|
|
reactive({
|
|
...selectProps2,
|
|
ref: (ref2) => select.value = ref2
|
|
}),
|
|
{
|
|
...slots,
|
|
default: () => [h(cache_options_default, { data: cacheOptions.value }), h(ElTree, reactive({
|
|
...treeProps3,
|
|
ref: (ref2) => tree.value = ref2
|
|
}))]
|
|
}
|
|
);
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tree-select/src/tree-select.mjs
|
|
var tree_select_default = tree_select_vue_vue_type_script_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/tree-select/index.mjs
|
|
var ElTreeSelect = withInstall(tree_select_default);
|
|
|
|
// node_modules/element-plus/es/components/tree-v2/src/virtual-tree.mjs
|
|
var ROOT_TREE_INJECTION_KEY2 = Symbol();
|
|
var EMPTY_NODE = {
|
|
key: -1,
|
|
level: -1,
|
|
data: {}
|
|
};
|
|
var TreeOptionsEnum = function(TreeOptionsEnum2) {
|
|
TreeOptionsEnum2["KEY"] = "id";
|
|
TreeOptionsEnum2["LABEL"] = "label";
|
|
TreeOptionsEnum2["CHILDREN"] = "children";
|
|
TreeOptionsEnum2["DISABLED"] = "disabled";
|
|
TreeOptionsEnum2["CLASS"] = "";
|
|
return TreeOptionsEnum2;
|
|
}({});
|
|
var SetOperationEnum = function(SetOperationEnum2) {
|
|
SetOperationEnum2["ADD"] = "add";
|
|
SetOperationEnum2["DELETE"] = "delete";
|
|
return SetOperationEnum2;
|
|
}({});
|
|
var itemSize2 = {
|
|
type: Number,
|
|
default: 26
|
|
};
|
|
var treeProps2 = buildProps({
|
|
data: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([])
|
|
},
|
|
emptyText: { type: String },
|
|
height: {
|
|
type: Number,
|
|
default: 200
|
|
},
|
|
props: {
|
|
type: definePropType(Object),
|
|
default: () => mutable({
|
|
children: TreeOptionsEnum.CHILDREN,
|
|
label: TreeOptionsEnum.LABEL,
|
|
disabled: TreeOptionsEnum.DISABLED,
|
|
value: TreeOptionsEnum.KEY,
|
|
class: TreeOptionsEnum.CLASS
|
|
})
|
|
},
|
|
highlightCurrent: Boolean,
|
|
showCheckbox: Boolean,
|
|
defaultCheckedKeys: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([])
|
|
},
|
|
checkStrictly: Boolean,
|
|
defaultExpandedKeys: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([])
|
|
},
|
|
indent: {
|
|
type: Number,
|
|
default: 16
|
|
},
|
|
itemSize: itemSize2,
|
|
icon: { type: iconPropType },
|
|
expandOnClickNode: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
checkOnClickNode: Boolean,
|
|
checkOnClickLeaf: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
currentNodeKey: { type: definePropType([String, Number]) },
|
|
accordion: Boolean,
|
|
filterMethod: { type: definePropType(Function) },
|
|
perfMode: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
scrollbarAlwaysOn: Boolean
|
|
});
|
|
var treeNodeProps = buildProps({
|
|
node: {
|
|
type: definePropType(Object),
|
|
default: () => mutable(EMPTY_NODE)
|
|
},
|
|
expanded: Boolean,
|
|
checked: Boolean,
|
|
indeterminate: Boolean,
|
|
showCheckbox: Boolean,
|
|
disabled: Boolean,
|
|
current: Boolean,
|
|
hiddenExpandIcon: Boolean,
|
|
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 treeEmits2 = {
|
|
[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(/* @__PURE__ */ new Set());
|
|
const indeterminateKeys = ref(/* @__PURE__ */ 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 = /* @__PURE__ */ new Set();
|
|
for (let level = maxLevel; level >= 1; --level) {
|
|
const nodes = levelTreeNodeMap.get(level);
|
|
if (!nodes)
|
|
continue;
|
|
nodes.forEach((node) => {
|
|
const children = node.children;
|
|
let isEffectivelyChecked = !node.isLeaf || node.disabled || checkedKeySet.has(node.key);
|
|
if (children) {
|
|
let allChecked = true;
|
|
let hasChecked = false;
|
|
for (const childNode of children) {
|
|
const key = childNode.key;
|
|
if (!childNode.isEffectivelyChecked)
|
|
isEffectivelyChecked = false;
|
|
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);
|
|
}
|
|
}
|
|
node.isEffectivelyChecked = isEffectivelyChecked;
|
|
});
|
|
}
|
|
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 children = node.children;
|
|
if (!props2.checkStrictly && nodeClick && (children == null ? void 0 : children.length))
|
|
isChecked2 = children.some((node2) => !node2.isEffectivelyChecked);
|
|
const toggle = (node2, checked) => {
|
|
checkedKeySet[checked ? SetOperationEnum.ADD : SetOperationEnum.DELETE](node2.key);
|
|
const children2 = node2.children;
|
|
if (!props2.checkStrictly && children2)
|
|
children2.forEach((childNode) => {
|
|
if (!childNode.disabled || childNode.children)
|
|
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(/* @__PURE__ */ new Set([]));
|
|
const hiddenExpandIconKeySet = ref(/* @__PURE__ */ new Set([]));
|
|
const filterable = computed(() => {
|
|
return isFunction(props2.filterMethod);
|
|
});
|
|
function doFilter(query) {
|
|
var _a;
|
|
if (!filterable.value)
|
|
return;
|
|
const expandKeySet = /* @__PURE__ */ new Set();
|
|
const hiddenExpandIconKeys = hiddenExpandIconKeySet.value;
|
|
const hiddenKeys = hiddenNodeKeySet.value;
|
|
const family = [];
|
|
const nodes = ((_a = tree.value) == null ? void 0 : _a.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);
|
|
member.expanded = true;
|
|
});
|
|
else {
|
|
node.expanded = false;
|
|
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(/* @__PURE__ */ new Set());
|
|
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 _a;
|
|
return ((_a = props2.props) == null ? void 0 : _a.value) || TreeOptionsEnum.KEY;
|
|
});
|
|
const childrenKey = computed(() => {
|
|
var _a;
|
|
return ((_a = props2.props) == null ? void 0 : _a.children) || TreeOptionsEnum.CHILDREN;
|
|
});
|
|
const disabledKey = computed(() => {
|
|
var _a;
|
|
return ((_a = props2.props) == null ? void 0 : _a.disabled) || TreeOptionsEnum.DISABLED;
|
|
});
|
|
const labelKey = computed(() => {
|
|
var _a;
|
|
return ((_a = props2.props) == null ? void 0 : _a.label) || TreeOptionsEnum.LABEL;
|
|
});
|
|
const flattenTree = computed(() => {
|
|
var _a;
|
|
const expandedKeys = expandedKeySet.value;
|
|
const hiddenKeys = hiddenNodeKeySet.value;
|
|
const flattenNodes = [];
|
|
const nodes = ((_a = tree.value) == null ? void 0 : _a.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 = /* @__PURE__ */ new Map();
|
|
const levelTreeNodeMap = /* @__PURE__ */ new Map();
|
|
let maxLevel = 1;
|
|
function traverse(nodes, level = 1, parent2 = void 0) {
|
|
var _a;
|
|
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;
|
|
node.expanded = expandedKeySet.value.has(value);
|
|
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, []);
|
|
(_a = levelTreeNodeMap.get(level)) == null ? void 0 : _a.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) {
|
|
if (expandedKeySet.value.has(node.key))
|
|
collapseNode(node);
|
|
else
|
|
expandNode(node);
|
|
}
|
|
function setExpandedKeys(keys3) {
|
|
const expandedKeys = /* @__PURE__ */ new Set();
|
|
const nodeMap = tree.value.treeNodeMap;
|
|
expandedKeySet.value.forEach((key) => {
|
|
const node = nodeMap.get(key);
|
|
if (node)
|
|
node.expanded = false;
|
|
});
|
|
keys3.forEach((k) => {
|
|
let node = nodeMap.get(k);
|
|
while (node && !expandedKeys.has(node.key)) {
|
|
expandedKeys.add(node.key);
|
|
node.expanded = true;
|
|
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);
|
|
treeNode.expanded = false;
|
|
}
|
|
});
|
|
}
|
|
keySet.add(node.key);
|
|
const _node = getNode(node.key);
|
|
if (_node) {
|
|
_node.expanded = true;
|
|
emit(NODE_EXPAND, _node.data, _node);
|
|
}
|
|
}
|
|
function collapseNode(node) {
|
|
expandedKeySet.value.delete(node.key);
|
|
const _node = getNode(node.key);
|
|
if (_node) {
|
|
_node.expanded = false;
|
|
emit(NODE_COLLAPSE, _node.data, _node);
|
|
}
|
|
}
|
|
function isDisabled(node) {
|
|
return !!node.disabled;
|
|
}
|
|
function isCurrent(node) {
|
|
const current = currentKey.value;
|
|
return current !== void 0 && current === node.key;
|
|
}
|
|
function getCurrentNode() {
|
|
var _a, _b;
|
|
if (!currentKey.value)
|
|
return void 0;
|
|
return (_b = (_a = tree.value) == null ? void 0 : _a.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 _a;
|
|
const key = isObject(data) ? getKey(data) : data;
|
|
return (_a = tree.value) == null ? void 0 : _a.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 scrollTo2(offset3) {
|
|
var _a;
|
|
(_a = listRef.value) == null ? void 0 : _a.scrollTo(offset3);
|
|
}
|
|
watch(() => props2.currentNodeKey, (key) => {
|
|
currentKey.value = key;
|
|
}, { immediate: true });
|
|
watch(() => props2.defaultExpandedKeys, (keys3) => {
|
|
setExpandedKeys(keys3 || []);
|
|
});
|
|
watch(() => props2.data, (data) => {
|
|
setData2(data);
|
|
setExpandedKeys(props2.defaultExpandedKeys || []);
|
|
}, { immediate: true });
|
|
return {
|
|
tree,
|
|
flattenTree,
|
|
isNotEmpty,
|
|
listRef,
|
|
getKey,
|
|
getChildren,
|
|
toggleExpand,
|
|
toggleCheckbox,
|
|
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: scrollTo2
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/tree-v2/src/tree-node-content.mjs
|
|
var tree_node_content_default2 = defineComponent({
|
|
name: "ElTreeNodeContent",
|
|
props: treeNodeContentProps,
|
|
setup(props2) {
|
|
const tree = inject(ROOT_TREE_INJECTION_KEY2);
|
|
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.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_173 = [
|
|
"aria-expanded",
|
|
"aria-disabled",
|
|
"aria-checked",
|
|
"data-key"
|
|
];
|
|
var tree_node_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElTreeNode",
|
|
__name: "tree-node",
|
|
props: treeNodeProps,
|
|
emits: treeNodeEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const tree = inject(ROOT_TREE_INJECTION_KEY2);
|
|
const ns = useNamespace("tree");
|
|
const indent = computed(() => {
|
|
var _a;
|
|
return (_a = tree == null ? void 0 : tree.props.indent) != null ? _a : 16;
|
|
});
|
|
const icon = computed(() => {
|
|
var _a;
|
|
return (_a = tree == null ? void 0 : tree.props.icon) != null ? _a : caret_right_default;
|
|
});
|
|
const getNodeClass = (node) => {
|
|
var _a;
|
|
const nodeClassFunc = (_a = tree == null ? void 0 : tree.props.props) == null ? void 0 : _a.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 _a, _b, _c, _d;
|
|
if ((_c = (_b = (_a = tree == null ? void 0 : tree.instance) == null ? void 0 : _a.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 _a, _b, _c;
|
|
return openBlock(), createElementBlock("div", {
|
|
ref: "node$",
|
|
class: normalizeClass([
|
|
unref(ns).b("node"),
|
|
unref(ns).is("expanded", __props.expanded),
|
|
unref(ns).is("current", __props.current),
|
|
unref(ns).is("focusable", !__props.disabled),
|
|
unref(ns).is("checked", !__props.disabled && __props.checked),
|
|
getNodeClass(__props.node)
|
|
]),
|
|
role: "treeitem",
|
|
tabindex: "-1",
|
|
"aria-expanded": __props.expanded,
|
|
"aria-disabled": __props.disabled,
|
|
"aria-checked": __props.checked,
|
|
"data-key": (_a = __props.node) == null ? void 0 : _a.key,
|
|
onClick: withModifiers(handleClick, ["stop"]),
|
|
onContextmenu: handleContextMenu,
|
|
onDragover: _cache[1] || (_cache[1] = withModifiers(() => {
|
|
}, ["prevent"])),
|
|
onDragenter: _cache[2] || (_cache[2] = withModifiers(() => {
|
|
}, ["prevent"])),
|
|
onDrop: withModifiers(handleDrop, ["stop"])
|
|
}, [createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).be("node", "content")),
|
|
style: normalizeStyle({
|
|
paddingLeft: `${(__props.node.level - 1) * indent.value}px`,
|
|
height: __props.itemSize + "px"
|
|
})
|
|
}, [
|
|
icon.value ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass([
|
|
unref(ns).is("leaf", !!((_b = __props.node) == null ? void 0 : _b.isLeaf)),
|
|
unref(ns).is("hidden", __props.hiddenExpandIcon),
|
|
{ expanded: !((_c = __props.node) == null ? void 0 : _c.isLeaf) && __props.expanded },
|
|
unref(ns).be("node", "expand-icon")
|
|
]),
|
|
onClick: withModifiers(handleExpandIconClick, ["stop"])
|
|
}, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(icon.value)))]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true),
|
|
__props.showCheckbox ? (openBlock(), createBlock(unref(ElCheckbox), {
|
|
key: 1,
|
|
"model-value": __props.checked,
|
|
indeterminate: __props.indeterminate,
|
|
disabled: __props.disabled,
|
|
onChange: handleCheckChange,
|
|
onClick: _cache[0] || (_cache[0] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}, null, 8, [
|
|
"model-value",
|
|
"indeterminate",
|
|
"disabled"
|
|
])) : createCommentVNode("v-if", true),
|
|
createVNode(unref(tree_node_content_default2), { node: {
|
|
...__props.node,
|
|
expanded: __props.expanded
|
|
} }, null, 8, ["node"])
|
|
], 6)], 42, _hoisted_173);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tree-v2/src/tree-node.mjs
|
|
var tree_node_default2 = tree_node_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/tree-v2/src/tree.vue_vue_type_script_setup_true_lang.mjs
|
|
var tree_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElTreeV2",
|
|
__name: "tree",
|
|
props: treeProps2,
|
|
emits: treeEmits2,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const slots = useSlots();
|
|
const treeNodeSize = computed(() => props2.itemSize);
|
|
provide(ROOT_TREE_INJECTION_KEY2, {
|
|
ctx: {
|
|
emit,
|
|
slots
|
|
},
|
|
props: props2,
|
|
instance: getCurrentInstance()
|
|
});
|
|
provide(formItemContextKey, void 0);
|
|
const { t } = useLocale();
|
|
const ns = useNamespace("tree");
|
|
const { flattenTree, isNotEmpty, listRef, toggleExpand, 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: scrollTo2 } = useTree3(props2, emit);
|
|
__expose({
|
|
toggleCheckbox,
|
|
getCurrentNode,
|
|
getCurrentKey,
|
|
setCurrentKey,
|
|
getCheckedKeys,
|
|
getCheckedNodes,
|
|
getHalfCheckedKeys,
|
|
getHalfCheckedNodes,
|
|
setChecked,
|
|
setCheckedKeys,
|
|
filter: filter2,
|
|
setData: setData2,
|
|
getNode,
|
|
expandNode,
|
|
collapseNode,
|
|
setExpandedKeys,
|
|
scrollToNode,
|
|
scrollTo: scrollTo2
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([unref(ns).b(), { [unref(ns).m("highlight-current")]: __props.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: __props.height,
|
|
"item-size": treeNodeSize.value,
|
|
"perf-mode": __props.perfMode,
|
|
"scrollbar-always-on": __props.scrollbarAlwaysOn
|
|
}, {
|
|
default: withCtx(({ data, index, style }) => [(openBlock(), createBlock(tree_node_default2, {
|
|
key: data[index].key,
|
|
style: normalizeStyle(style),
|
|
node: data[index],
|
|
expanded: data[index].expanded,
|
|
"show-checkbox": __props.showCheckbox,
|
|
checked: unref(isChecked)(data[index]),
|
|
indeterminate: unref(isIndeterminate)(data[index]),
|
|
"item-size": treeNodeSize.value,
|
|
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",
|
|
"scrollbar-always-on"
|
|
])) : (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass(unref(ns).e("empty-block"))
|
|
}, [renderSlot(_ctx.$slots, "empty", {}, () => {
|
|
var _a;
|
|
return [createBaseVNode("span", { class: normalizeClass(unref(ns).e("empty-text")) }, toDisplayString((_a = __props.emptyText) != null ? _a : unref(t)("el.tree.emptyText")), 3)];
|
|
})], 2))], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tree-v2/src/tree.mjs
|
|
var tree_default2 = tree_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/tree-v2/index.mjs
|
|
var ElTreeV2 = withInstall(tree_default2);
|
|
|
|
// node_modules/element-plus/es/components/upload/src/ajax.mjs
|
|
var SCOPE11 = "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 {
|
|
return text;
|
|
}
|
|
}
|
|
var ajaxUpload = (option) => {
|
|
if (typeof XMLHttpRequest === "undefined")
|
|
throwError(SCOPE11, "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))
|
|
if (value.length === 2 && value[0] instanceof Blob && isString(value[1]))
|
|
formData.append(key, value[0], value[1]);
|
|
else
|
|
value.forEach((item) => {
|
|
formData.append(key, item);
|
|
});
|
|
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: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
limit: Number,
|
|
directory: Boolean
|
|
});
|
|
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) }
|
|
});
|
|
var uploadBasePropsDefaults = {
|
|
action: "#",
|
|
method: "post",
|
|
data: () => mutable({}),
|
|
name: "file",
|
|
showFileList: true,
|
|
accept: "",
|
|
fileList: () => mutable([]),
|
|
autoUpload: true,
|
|
listType: "text",
|
|
httpRequest: ajaxUpload,
|
|
disabled: void 0
|
|
};
|
|
var uploadPropsDefaults = {
|
|
...uploadBasePropsDefaults,
|
|
beforeUpload: NOOP,
|
|
onRemove: NOOP,
|
|
onChange: NOOP,
|
|
onPreview: NOOP,
|
|
onSuccess: NOOP,
|
|
onProgress: NOOP,
|
|
onError: NOOP,
|
|
onExceed: NOOP
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/upload/src/constants.mjs
|
|
var uploadContextKey = Symbol("uploadContextKey");
|
|
|
|
// node_modules/element-plus/es/components/upload/src/upload-list.mjs
|
|
var uploadListProps = buildProps({
|
|
files: {
|
|
type: definePropType(Array),
|
|
default: () => mutable([])
|
|
},
|
|
disabled: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
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-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
|
|
}
|
|
});
|
|
var uploadContentPropsDefaults = {
|
|
...uploadBasePropsDefaults,
|
|
beforeUpload: NOOP,
|
|
onRemove: NOOP,
|
|
onStart: NOOP,
|
|
onSuccess: NOOP,
|
|
onProgress: NOOP,
|
|
onError: NOOP,
|
|
onExceed: NOOP
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/upload/src/upload-dragger.mjs
|
|
var uploadDraggerProps = buildProps({
|
|
disabled: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
directory: Boolean
|
|
});
|
|
var uploadDraggerEmits = { file: (file) => isArray(file) };
|
|
|
|
// node_modules/element-plus/es/components/upload/src/upload-list.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_174 = [
|
|
"tabindex",
|
|
"aria-disabled",
|
|
"onKeydown"
|
|
];
|
|
var _hoisted_240 = ["src", "crossorigin"];
|
|
var _hoisted_317 = ["onClick"];
|
|
var _hoisted_412 = ["title"];
|
|
var _hoisted_510 = ["onClick"];
|
|
var _hoisted_65 = ["onClick"];
|
|
var upload_list_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElUploadList",
|
|
__name: "upload-list",
|
|
props: uploadListProps,
|
|
emits: uploadListEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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", disabled.value)
|
|
]);
|
|
const handleRemove = (file) => {
|
|
emit("remove", file);
|
|
};
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createBlock(TransitionGroup, {
|
|
tag: "ul",
|
|
class: normalizeClass(containerKls.value),
|
|
name: unref(nsList).b()
|
|
}, {
|
|
default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.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: unref(disabled) ? void 0 : 0,
|
|
"aria-disabled": unref(disabled),
|
|
role: "button",
|
|
onKeydown: withKeys(($event) => !unref(disabled) && handleRemove(file), ["delete"]),
|
|
onFocus: _cache[0] || (_cache[0] = ($event) => focusing.value = true),
|
|
onBlur: _cache[1] || (_cache[1] = ($event) => focusing.value = false),
|
|
onClick: _cache[2] || (_cache[2] = ($event) => focusing.value = false)
|
|
}, [renderSlot(_ctx.$slots, "default", {
|
|
file,
|
|
index
|
|
}, () => [
|
|
__props.listType === "picture" || file.status !== "uploading" && __props.listType === "picture-card" ? (openBlock(), createElementBlock("img", {
|
|
key: 0,
|
|
class: normalizeClass(unref(nsUpload).be("list", "item-thumbnail")),
|
|
src: file.url,
|
|
crossorigin: __props.crossorigin,
|
|
alt: ""
|
|
}, null, 10, _hoisted_240)) : createCommentVNode("v-if", true),
|
|
file.status === "uploading" || __props.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) => __props.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, _hoisted_412)], 10, _hoisted_317), file.status === "uploading" ? (openBlock(), createBlock(unref(ElProgress), {
|
|
key: 0,
|
|
type: __props.listType === "picture-card" ? "circle" : "line",
|
|
"stroke-width": __props.listType === "picture-card" ? 6 : 2,
|
|
percentage: Number(file.percentage),
|
|
style: normalizeStyle(__props.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")) }, [__props.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(__props.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")),
|
|
"aria-label": unref(t)("el.upload.delete"),
|
|
role: "button",
|
|
tabindex: "0",
|
|
onClick: ($event) => handleRemove(file),
|
|
onKeydown: withKeys(withModifiers(($event) => handleRemove(file), ["prevent"]), ["enter", "space"])
|
|
}, {
|
|
default: withCtx(() => [createVNode(unref(close_default))]),
|
|
_: 1
|
|
}, 8, [
|
|
"class",
|
|
"aria-label",
|
|
"onClick",
|
|
"onKeydown"
|
|
])) : createCommentVNode("v-if", true),
|
|
!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),
|
|
__props.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) => __props.handlePreview(file)
|
|
}, [createVNode(unref(ElIcon), { class: normalizeClass(unref(nsIcon).m("zoom-in")) }, {
|
|
default: withCtx(() => [createVNode(unref(zoom_in_default))]),
|
|
_: 1
|
|
}, 8, ["class"])], 10, _hoisted_510), !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, _hoisted_65)) : createCommentVNode("v-if", true)], 2)) : createCommentVNode("v-if", true)
|
|
])], 42, _hoisted_174);
|
|
}), 128)), renderSlot(_ctx.$slots, "append")]),
|
|
_: 3
|
|
}, 8, ["class", "name"]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/upload/src/upload-list2.mjs
|
|
var upload_list_default = upload_list_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/upload/src/upload-dragger.vue_vue_type_script_setup_true_lang.mjs
|
|
var COMPONENT_NAME22 = "ElUploadDrag";
|
|
var upload_dragger_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: COMPONENT_NAME22,
|
|
__name: "upload-dragger",
|
|
props: uploadDraggerProps,
|
|
emits: uploadDraggerEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
if (!inject(uploadContextKey))
|
|
throwError(COMPONENT_NAME22, "usage: <el-upload><el-upload-dragger /></el-upload>");
|
|
const ns = useNamespace("upload");
|
|
const dragover = ref(false);
|
|
const disabled = useFormDisabled();
|
|
const getFile = (entry) => {
|
|
return new Promise((resolve, reject2) => entry.file(resolve, reject2));
|
|
};
|
|
const getAllFiles = async (entry) => {
|
|
try {
|
|
if (entry.isFile) {
|
|
const file = await getFile(entry);
|
|
file.isDirectory = false;
|
|
return [file];
|
|
}
|
|
if (entry.isDirectory) {
|
|
const dirReader = entry.createReader();
|
|
const getEntries = () => {
|
|
return new Promise((resolve, reject2) => dirReader.readEntries(resolve, reject2));
|
|
};
|
|
const entries = [];
|
|
let readEntries = await getEntries();
|
|
while (readEntries.length > 0) {
|
|
entries.push(...readEntries);
|
|
readEntries = await getEntries();
|
|
}
|
|
const filePromises = entries.map((entry2) => getAllFiles(entry2).catch(() => []));
|
|
return flatten_default(await Promise.all(filePromises));
|
|
}
|
|
} catch {
|
|
return [];
|
|
}
|
|
return [];
|
|
};
|
|
const onDrop = async (e) => {
|
|
if (disabled.value)
|
|
return;
|
|
dragover.value = false;
|
|
e.stopPropagation();
|
|
const files = Array.from(e.dataTransfer.files);
|
|
const items = e.dataTransfer.items || [];
|
|
if (props2.directory) {
|
|
const entries = Array.from(items).map((item) => {
|
|
var _a;
|
|
return (_a = item == null ? void 0 : item.webkitGetAsEntry) == null ? void 0 : _a.call(item);
|
|
}).filter((entry) => entry);
|
|
emit("file", flatten_default(await Promise.all(entries.map(getAllFiles))));
|
|
return;
|
|
}
|
|
files.forEach((file, index) => {
|
|
var _a, _b;
|
|
const entry = (_b = (_a = items[index]) == null ? void 0 : _a.webkitGetAsEntry) == null ? void 0 : _b.call(_a);
|
|
if (entry)
|
|
file.isDirectory = entry.isDirectory;
|
|
});
|
|
emit("file", files);
|
|
};
|
|
const onDragover = () => {
|
|
if (!disabled.value)
|
|
dragover.value = true;
|
|
};
|
|
const onDragleave = (e) => {
|
|
if (!e.currentTarget.contains(e.relatedTarget))
|
|
dragover.value = false;
|
|
};
|
|
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(onDragleave, ["prevent"])
|
|
}, [renderSlot(_ctx.$slots, "default")], 34);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/upload/src/upload-dragger2.mjs
|
|
var upload_dragger_default = upload_dragger_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/upload/src/upload-content.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_175 = [
|
|
"tabindex",
|
|
"aria-disabled",
|
|
"onKeydown"
|
|
];
|
|
var _hoisted_241 = [
|
|
"name",
|
|
"disabled",
|
|
"multiple",
|
|
"accept",
|
|
"webkitdirectory"
|
|
];
|
|
var upload_content_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElUploadContent",
|
|
inheritAttrs: false,
|
|
__name: "upload-content",
|
|
props: uploadContentProps,
|
|
setup(__props, { expose: __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 {
|
|
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 {
|
|
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) => {
|
|
entriesOf(requests.value).filter(file ? ([uid2]) => String(file.uid) === uid2 : () => true).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(__props.listType),
|
|
unref(ns).is("drag", __props.drag),
|
|
unref(ns).is("disabled", unref(disabled))
|
|
]),
|
|
tabindex: unref(disabled) ? void 0 : 0,
|
|
"aria-disabled": unref(disabled),
|
|
role: "button",
|
|
onClick: handleClick,
|
|
onKeydown: withKeys(withModifiers(handleKeydown, ["self"]), ["enter", "space"])
|
|
}, [__props.drag ? (openBlock(), createBlock(upload_dragger_default, {
|
|
key: 0,
|
|
disabled: unref(disabled),
|
|
directory: __props.directory,
|
|
onFile: uploadFiles
|
|
}, {
|
|
default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
|
|
_: 3
|
|
}, 8, ["disabled", "directory"])) : renderSlot(_ctx.$slots, "default", { key: 1 }), createBaseVNode("input", {
|
|
ref_key: "inputRef",
|
|
ref: inputRef,
|
|
class: normalizeClass(unref(ns).e("input")),
|
|
name: __props.name,
|
|
disabled: unref(disabled),
|
|
multiple: __props.multiple,
|
|
accept: __props.accept,
|
|
webkitdirectory: __props.directory || void 0,
|
|
type: "file",
|
|
onChange: handleChange,
|
|
onClick: _cache[0] || (_cache[0] = withModifiers(() => {
|
|
}, ["stop"]))
|
|
}, null, 42, _hoisted_241)], 42, _hoisted_175);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/upload/src/upload-content2.mjs
|
|
var upload_content_default = upload_content_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/upload/src/use-handlers.mjs
|
|
var SCOPE12 = "ElUpload";
|
|
var revokeFileObjectURL = (file) => {
|
|
var _a;
|
|
if ((_a = file.url) == null ? void 0 : _a.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 _a;
|
|
(_a = uploadRef.value) == null ? void 0 : _a.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 emitChange = (file) => {
|
|
nextTick(() => props2.onChange(file, uploadFiles.value));
|
|
};
|
|
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);
|
|
emitChange(file);
|
|
};
|
|
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);
|
|
emitChange(file);
|
|
};
|
|
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(SCOPE12, err.message);
|
|
props2.onError(err, uploadFile, uploadFiles.value);
|
|
}
|
|
uploadFiles.value = [...uploadFiles.value, uploadFile];
|
|
emitChange(uploadFile);
|
|
};
|
|
const handleRemove = async (file) => {
|
|
const uploadFile = file instanceof File ? getFile(file) : file;
|
|
if (!uploadFile)
|
|
throwError(SCOPE12, "file to be removed not found");
|
|
const doRemove = (file2) => {
|
|
abort(file2);
|
|
removeFile(file2);
|
|
props2.onRemove(file2, uploadFiles.value);
|
|
revokeFileObjectURL(file2);
|
|
};
|
|
if (props2.beforeRemove) {
|
|
if (await props2.beforeRemove(uploadFile, uploadFiles.value) !== false)
|
|
doRemove(uploadFile);
|
|
} else
|
|
doRemove(uploadFile);
|
|
};
|
|
function submit() {
|
|
uploadFiles.value.filter(({ status }) => status === "ready").forEach(({ raw }) => {
|
|
var _a;
|
|
return raw && ((_a = uploadRef.value) == null ? void 0 : _a.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/upload.vue_vue_type_script_setup_true_lang.mjs
|
|
var upload_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElUpload",
|
|
__name: "upload",
|
|
props: uploadProps,
|
|
setup(__props, { expose: __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, [
|
|
isPictureCard.value && __props.showFileList ? (openBlock(), createBlock(upload_list_default, {
|
|
key: 0,
|
|
disabled: unref(disabled),
|
|
"list-type": __props.listType,
|
|
files: unref(uploadFiles),
|
|
crossorigin: __props.crossorigin,
|
|
"handle-preview": __props.onPreview,
|
|
onRemove: unref(handleRemove)
|
|
}, createSlots({
|
|
append: withCtx(() => [createVNode(upload_content_default, mergeProps({
|
|
ref_key: "uploadRef",
|
|
ref: uploadRef
|
|
}, uploadContentProps2.value), {
|
|
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
|
|
})]),
|
|
key: "0"
|
|
} : void 0]), 1032, [
|
|
"disabled",
|
|
"list-type",
|
|
"files",
|
|
"crossorigin",
|
|
"handle-preview",
|
|
"onRemove"
|
|
])) : createCommentVNode("v-if", true),
|
|
!isPictureCard.value || isPictureCard.value && !__props.showFileList ? (openBlock(), createBlock(upload_content_default, mergeProps({
|
|
key: 1,
|
|
ref_key: "uploadRef",
|
|
ref: uploadRef
|
|
}, uploadContentProps2.value), {
|
|
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"),
|
|
!isPictureCard.value && __props.showFileList ? (openBlock(), createBlock(upload_list_default, {
|
|
key: 3,
|
|
disabled: unref(disabled),
|
|
"list-type": __props.listType,
|
|
files: unref(uploadFiles),
|
|
crossorigin: __props.crossorigin,
|
|
"handle-preview": __props.onPreview,
|
|
onRemove: unref(handleRemove)
|
|
}, createSlots({ _: 2 }, [_ctx.$slots.file ? {
|
|
name: "default",
|
|
fn: withCtx(({ file, index }) => [renderSlot(_ctx.$slots, "file", {
|
|
file,
|
|
index
|
|
})]),
|
|
key: "0"
|
|
} : void 0]), 1032, [
|
|
"disabled",
|
|
"list-type",
|
|
"files",
|
|
"crossorigin",
|
|
"handle-preview",
|
|
"onRemove"
|
|
])) : createCommentVNode("v-if", true)
|
|
]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/upload/src/upload2.mjs
|
|
var upload_default = upload_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/upload/index.mjs
|
|
var ElUpload = withInstall(upload_default);
|
|
|
|
// 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 TEXT_ALIGN_RATIO_MAP = {
|
|
left: [0, 0.5],
|
|
start: [0, 0.5],
|
|
center: [0.5, 0],
|
|
right: [1, -0.5],
|
|
end: [1, -0.5]
|
|
};
|
|
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, space) {
|
|
const [ctx, canvas, contentWidth, contentHeight] = prepareCanvas(width, height, ratio);
|
|
let baselineOffset = 0;
|
|
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];
|
|
if (textBaseline !== "top" && contents[0]) {
|
|
const argumentMetrics = ctx.measureText(contents[0]);
|
|
ctx.textBaseline = "top";
|
|
const topMetrics = ctx.measureText(contents[0]);
|
|
baselineOffset = argumentMetrics.actualBoundingBoxAscent - topMetrics.actualBoundingBoxAscent;
|
|
}
|
|
contents == null ? void 0 : contents.forEach((item, index) => {
|
|
const [alignRatio, spaceRatio] = TEXT_ALIGN_RATIO_MAP[textAlign];
|
|
ctx.fillText(item != null ? item : "", contentWidth * alignRatio + space * spaceRatio, index * (mergedFontSize + font.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) {
|
|
return [x2 * Math.cos(angle) - y * Math.sin(angle), x2 * Math.sin(angle) + y * Math.cos(angle)];
|
|
}
|
|
let left = 0;
|
|
let right = 0;
|
|
let top = 0;
|
|
let bottom = 0;
|
|
const halfWidth = contentWidth / 2;
|
|
const halfHeight = contentHeight / 2;
|
|
[
|
|
[0 - halfWidth, 0 - halfHeight],
|
|
[0 + halfWidth, 0 - halfHeight],
|
|
[0 + halfWidth, 0 + halfHeight],
|
|
[0 - halfWidth, 0 + halfHeight]
|
|
].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 + baselineOffset, 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/watermark.vue_vue_type_script_setup_true_lang.mjs
|
|
var watermark_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElWatermark",
|
|
__name: "watermark",
|
|
props: watermarkProps,
|
|
setup(__props) {
|
|
const style = { position: "relative" };
|
|
const props2 = __props;
|
|
const fontGap = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = props2.font) == null ? void 0 : _a.fontGap) != null ? _b : 3;
|
|
});
|
|
const color = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = props2.font) == null ? void 0 : _a.color) != null ? _b : "rgba(0,0,0,.15)";
|
|
});
|
|
const fontSize = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = props2.font) == null ? void 0 : _a.fontSize) != null ? _b : 16;
|
|
});
|
|
const fontWeight = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = props2.font) == null ? void 0 : _a.fontWeight) != null ? _b : "normal";
|
|
});
|
|
const fontStyle = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = props2.font) == null ? void 0 : _a.fontStyle) != null ? _b : "normal";
|
|
});
|
|
const fontFamily = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = props2.font) == null ? void 0 : _a.fontFamily) != null ? _b : "sans-serif";
|
|
});
|
|
const textAlign = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = props2.font) == null ? void 0 : _a.textAlign) != null ? _b : "center";
|
|
});
|
|
const textBaseline = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = props2.font) == null ? void 0 : _a.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 _a, _b;
|
|
return (_b = (_a = props2.offset) == null ? void 0 : _a[0]) != null ? _b : gapXCenter.value;
|
|
});
|
|
const offsetTop = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = props2.offset) == null ? void 0 : _a[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 _a;
|
|
if (containerRef.value && watermarkRef.value) {
|
|
stopObservation.value = true;
|
|
watermarkRef.value.setAttribute("style", getStyleStr({
|
|
...getMarkStyle(),
|
|
backgroundImage: `url('${base64Url}')`,
|
|
backgroundSize: `${Math.floor(markWidth)}px`
|
|
}));
|
|
(_a = containerRef.value) == null ? void 0 : _a.append(watermarkRef.value);
|
|
setTimeout(() => {
|
|
stopObservation.value = false;
|
|
});
|
|
}
|
|
};
|
|
const getMarkSize = (ctx) => {
|
|
let defaultWidth = 120;
|
|
let defaultHeight = 64;
|
|
let space = 0;
|
|
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.value;
|
|
const angle = Math.PI / 180 * Number(rotate);
|
|
space = Math.ceil(Math.abs(Math.sin(angle) * defaultHeight) / 2);
|
|
defaultWidth += space;
|
|
}
|
|
return [
|
|
width != null ? width : defaultWidth,
|
|
height != null ? height : defaultHeight,
|
|
space
|
|
];
|
|
};
|
|
const getClips = useClips();
|
|
const renderWatermark = () => {
|
|
const ctx = document.createElement("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, space] = 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,
|
|
fontGap: fontGap.value,
|
|
textAlign: textAlign.value,
|
|
textBaseline: textBaseline.value
|
|
}, gapX.value, gapY.value, space);
|
|
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);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/watermark/src/watermark2.mjs
|
|
var watermark_default = watermark_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/watermark/index.mjs
|
|
var ElWatermark = withInstall(watermark_default);
|
|
|
|
// 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/step.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/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 _a;
|
|
return (_a = isArray(gap.value.offset) ? gap.value.offset[index] : gap.value.offset) != null ? _a : 6;
|
|
};
|
|
const mergedPosInfo = computed(() => {
|
|
var _a;
|
|
if (!posInfo.value)
|
|
return posInfo.value;
|
|
const gapOffsetX = getGapOffset(0);
|
|
const gapOffsetY = getGapOffset(1);
|
|
const gapRadius = ((_a = gap.value) == null ? void 0 : _a.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
|
|
};
|
|
});
|
|
return {
|
|
mergedPosInfo,
|
|
triggerTarget: computed(() => {
|
|
const targetEl = getTargetEl();
|
|
if (!mergedMask.value || !targetEl || !window.DOMRect)
|
|
return targetEl || void 0;
|
|
return { getBoundingClientRect() {
|
|
var _a, _b, _c, _d;
|
|
return window.DOMRect.fromRect({
|
|
width: ((_a = mergedPosInfo.value) == null ? void 0 : _a.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
|
|
});
|
|
} };
|
|
})
|
|
};
|
|
};
|
|
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: arrow3 } = unref(middlewareData);
|
|
return {
|
|
left: (arrow3 == null ? void 0 : arrow3.x) != null ? `${arrow3 == null ? void 0 : arrow3.x}px` : "",
|
|
top: (arrow3 == null ? void 0 : arrow3.y) != null ? `${arrow3 == null ? void 0 : arrow3.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;
|
|
return { data: { maxWidth: state.rects.floating.width - overWidth } };
|
|
}
|
|
};
|
|
};
|
|
|
|
// 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/mask.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_176 = { style: {
|
|
width: "100%",
|
|
height: "100%"
|
|
} };
|
|
var _hoisted_242 = ["d"];
|
|
var mask_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElTourMask",
|
|
inheritAttrs: false,
|
|
__name: "mask",
|
|
props: maskProps,
|
|
setup(__props) {
|
|
const props2 = __props;
|
|
const { ns } = inject(tourKey);
|
|
const radius = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = props2.pos) == null ? void 0 : _a.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 { width: windowWidth, height: windowHeight } = useWindowSize();
|
|
const path = computed(() => {
|
|
const width = windowWidth.value;
|
|
const height = windowHeight.value;
|
|
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 maskStyle = computed(() => ({
|
|
position: "fixed",
|
|
left: 0,
|
|
right: 0,
|
|
top: 0,
|
|
bottom: 0,
|
|
zIndex: props2.zIndex,
|
|
pointerEvents: props2.pos && props2.targetAreaClickable ? "none" : "auto"
|
|
}));
|
|
const pathStyle = computed(() => ({
|
|
fill: props2.fill,
|
|
pointerEvents: "auto",
|
|
cursor: "auto"
|
|
}));
|
|
useLockscreen(toRef(props2, "visible"), { ns });
|
|
return (_ctx, _cache) => {
|
|
return __props.visible ? (openBlock(), createElementBlock("div", mergeProps({
|
|
key: 0,
|
|
class: unref(ns).e("mask"),
|
|
style: maskStyle.value
|
|
}, _ctx.$attrs), [(openBlock(), createElementBlock("svg", _hoisted_176, [createBaseVNode("path", {
|
|
class: normalizeClass(unref(ns).e("hollow")),
|
|
style: normalizeStyle(pathStyle.value),
|
|
d: path.value
|
|
}, null, 14, _hoisted_242)]))], 16)) : createCommentVNode("v-if", true);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tour/src/mask2.mjs
|
|
var mask_default = mask_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/tour/src/content.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_177 = ["data-side"];
|
|
var content_vue_vue_type_script_setup_true_lang_default3 = defineComponent({
|
|
name: "ElTourContent",
|
|
__name: "content",
|
|
props: tourContentProps,
|
|
emits: tourContentEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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": side.value,
|
|
tabindex: "-1"
|
|
}, [createVNode(unref(focus_trap_default$1), {
|
|
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"]), __props.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, _hoisted_177);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tour/src/content2.mjs
|
|
var content_default3 = content_vue_vue_type_script_setup_true_lang_default3;
|
|
|
|
// node_modules/element-plus/es/components/tour/src/steps.mjs
|
|
var steps_default2 = defineComponent({
|
|
name: "ElTourSteps",
|
|
props: { current: {
|
|
type: Number,
|
|
default: 0
|
|
} },
|
|
emits: ["update-total"],
|
|
setup(props2, { slots, emit }) {
|
|
let cacheTotal = 0;
|
|
return () => {
|
|
var _a, _b;
|
|
const children = (_a = slots.default) == null ? void 0 : _a.call(slots);
|
|
const result2 = [];
|
|
let total2 = 0;
|
|
function filterSteps(children2) {
|
|
if (!isArray(children2))
|
|
return;
|
|
children2.forEach((item) => {
|
|
var _a2;
|
|
if (((_a2 = (item == null ? void 0 : item.type) || {}) == null ? void 0 : _a2.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/tour.vue_vue_type_script_setup_true_lang.mjs
|
|
var tour_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElTour",
|
|
inheritAttrs: false,
|
|
__name: "tour",
|
|
props: tourProps,
|
|
emits: tourEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const ns = useNamespace("tour");
|
|
const total2 = ref(0);
|
|
const currentStep = ref();
|
|
const current = useVModel(props2, "current", emit, { passive: true });
|
|
const currentTarget = computed(() => {
|
|
var _a;
|
|
return (_a = currentStep.value) == null ? void 0 : _a.target;
|
|
});
|
|
const kls = computed(() => [ns.b(), mergedType.value === "primary" ? ns.m("primary") : ""]);
|
|
const mergedPlacement = computed(() => {
|
|
var _a;
|
|
return ((_a = currentStep.value) == null ? void 0 : _a.placement) || props2.placement;
|
|
});
|
|
const mergedContentStyle = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = currentStep.value) == null ? void 0 : _a.contentStyle) != null ? _b : props2.contentStyle;
|
|
});
|
|
const mergedMask = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = currentStep.value) == null ? void 0 : _a.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 _a, _b;
|
|
return !!currentTarget.value && ((_b = (_a = currentStep.value) == null ? void 0 : _a.showArrow) != null ? _b : props2.showArrow);
|
|
});
|
|
const mergedScrollIntoViewOptions = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = currentStep.value) == null ? void 0 : _a.scrollIntoViewOptions) != null ? _b : props2.scrollIntoViewOptions;
|
|
});
|
|
const mergedType = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = currentStep.value) == null ? void 0 : _a.type) != null ? _b : props2.type;
|
|
});
|
|
const { nextZIndex } = useZIndex();
|
|
const nowZIndex = nextZIndex();
|
|
const mergedZIndex = computed(() => {
|
|
var _a;
|
|
return (_a = props2.zIndex) != null ? _a : 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: __props.appendTo }, {
|
|
default: withCtx(() => {
|
|
var _a, _b;
|
|
return [createBaseVNode("div", mergeProps({ class: kls.value }, _ctx.$attrs), [createVNode(mask_default, {
|
|
visible: mergedShowMask.value,
|
|
fill: (_a = mergedMaskStyle.value) == null ? void 0 : _a.color,
|
|
style: normalizeStyle((_b = mergedMaskStyle.value) == null ? void 0 : _b.style),
|
|
pos: unref(pos),
|
|
"z-index": mergedZIndex.value,
|
|
"target-area-clickable": __props.targetAreaClickable
|
|
}, null, 8, [
|
|
"visible",
|
|
"fill",
|
|
"style",
|
|
"pos",
|
|
"z-index",
|
|
"target-area-clickable"
|
|
]), __props.modelValue ? (openBlock(), createBlock(content_default3, {
|
|
key: unref(current),
|
|
reference: unref(triggerTarget),
|
|
placement: mergedPlacement.value,
|
|
"show-arrow": mergedShowArrow.value,
|
|
"z-index": mergedZIndex.value,
|
|
style: normalizeStyle(mergedContentStyle.value),
|
|
onClose: onEscClose
|
|
}, {
|
|
default: withCtx(() => [createVNode(unref(steps_default2), {
|
|
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);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tour/src/tour2.mjs
|
|
var tour_default = tour_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/tour/src/step.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_178 = ["aria-label"];
|
|
var step_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElTourStep",
|
|
__name: "step",
|
|
props: tourStepProps,
|
|
emits: tourStepEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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 _a;
|
|
return (_a = props2.showClose) != null ? _a : showClose.value;
|
|
});
|
|
const mergedCloseIcon = computed(() => {
|
|
var _a, _b;
|
|
return (_b = (_a = props2.closeIcon) != null ? _a : closeIcon.value) != null ? _b : Close;
|
|
});
|
|
const filterButtonProps = (btnProps) => {
|
|
if (!btnProps)
|
|
return;
|
|
return omit_default(btnProps, ["children", "onClick"]);
|
|
};
|
|
const onPrev = () => {
|
|
var _a, _b;
|
|
current.value -= 1;
|
|
if ((_a = props2.prevButtonProps) == null ? void 0 : _a.onClick)
|
|
(_b = props2.prevButtonProps) == null ? void 0 : _b.onClick();
|
|
onChange();
|
|
};
|
|
const onNext = () => {
|
|
var _a;
|
|
if (current.value >= total2.value - 1)
|
|
onFinish();
|
|
else
|
|
current.value += 1;
|
|
if ((_a = props2.nextButtonProps) == null ? void 0 : _a.onClick)
|
|
props2.nextButtonProps.onClick();
|
|
onChange();
|
|
};
|
|
const onFinish = () => {
|
|
onClose();
|
|
tourOnFinish();
|
|
};
|
|
const onClose = () => {
|
|
updateModelValue(false);
|
|
tourOnClose();
|
|
emit("close");
|
|
};
|
|
const handleKeydown = (e) => {
|
|
var _a;
|
|
if ((_a = e.target) == null ? void 0 : _a.isContentEditable)
|
|
return;
|
|
switch (getEventCode(e)) {
|
|
case EVENT_CODE.left:
|
|
e.preventDefault();
|
|
current.value > 0 && onPrev();
|
|
break;
|
|
case EVENT_CODE.right:
|
|
e.preventDefault();
|
|
onNext();
|
|
break;
|
|
}
|
|
};
|
|
onMounted(() => {
|
|
window.addEventListener("keydown", handleKeydown);
|
|
});
|
|
onBeforeUnmount(() => {
|
|
window.removeEventListener("keydown", handleKeydown);
|
|
});
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock(Fragment, null, [
|
|
mergedShowClose.value ? (openBlock(), createElementBlock("button", {
|
|
key: 0,
|
|
"aria-label": unref(t)("el.tour.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(mergedCloseIcon.value)))]),
|
|
_: 1
|
|
}, 8, ["class"])], 10, _hoisted_178)) : 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(__props.title), 3)])], 2),
|
|
createBaseVNode("div", { class: normalizeClass(unref(ns).e("body")) }, [renderSlot(_ctx.$slots, "default", {}, () => [createBaseVNode("span", null, toDisplayString(__props.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"), unref(ns).is("active", index === unref(current))])
|
|
}, 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(__props.prevButtonProps), { onClick: onPrev }), {
|
|
default: withCtx(() => {
|
|
var _a, _b;
|
|
return [createTextVNode(toDisplayString((_b = (_a = __props.prevButtonProps) == null ? void 0 : _a.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(__props.nextButtonProps), { onClick: onNext }), {
|
|
default: withCtx(() => {
|
|
var _a, _b;
|
|
return [createTextVNode(toDisplayString((_b = (_a = __props.nextButtonProps) == null ? void 0 : _a.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);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/tour/src/step2.mjs
|
|
var step_default = step_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/tour/index.mjs
|
|
var ElTour = withInstall(tour_default, { TourStep: step_default });
|
|
var ElTourStep = withNoopInstall(step_default);
|
|
|
|
// 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: Boolean
|
|
});
|
|
var anchorEmits = {
|
|
change: (href) => isString(href),
|
|
click: (e, href) => e instanceof MouseEvent && (isString(href) || isUndefined2(href))
|
|
};
|
|
|
|
// 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 {
|
|
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/constants.mjs
|
|
var anchorKey = Symbol("anchor");
|
|
|
|
// node_modules/element-plus/es/components/anchor/src/anchor.vue_vue_type_script_setup_true_lang.mjs
|
|
var anchor_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElAnchor",
|
|
__name: "anchor",
|
|
props: anchorProps,
|
|
emits: anchorEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const slots = useSlots();
|
|
const currentAnchor = ref("");
|
|
const markerStyle = 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) => {
|
|
if (currentAnchor.value !== href) {
|
|
currentAnchor.value = href;
|
|
emit(CHANGE_EVENT, href);
|
|
}
|
|
};
|
|
let clearAnimate = null;
|
|
let currentTargetHref = "";
|
|
const scrollToAnchor = (href) => {
|
|
if (!containerEl.value)
|
|
return;
|
|
const target2 = getElement(href);
|
|
if (!target2)
|
|
return;
|
|
if (clearAnimate) {
|
|
if (currentTargetHref === href)
|
|
return;
|
|
clearAnimate();
|
|
}
|
|
currentTargetHref = href;
|
|
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;
|
|
currentTargetHref = "";
|
|
}, 20);
|
|
});
|
|
};
|
|
const scrollTo2 = (href) => {
|
|
if (href) {
|
|
setCurrentAnchor(href);
|
|
scrollToAnchor(href);
|
|
}
|
|
};
|
|
const handleClick = (e, href) => {
|
|
emit("click", e, href);
|
|
scrollTo2(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 distance = getOffsetTopDistance(target2, getScrollElement(target2, containerEl.value));
|
|
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 updateMarkerStyle = () => {
|
|
nextTick(() => {
|
|
if (!anchorRef.value || !markerRef.value || !currentAnchor.value) {
|
|
markerStyle.value = {};
|
|
return;
|
|
}
|
|
const currentLinkEl = links[currentAnchor.value];
|
|
if (!currentLinkEl) {
|
|
markerStyle.value = {};
|
|
return;
|
|
}
|
|
const anchorRect = anchorRef.value.getBoundingClientRect();
|
|
const markerRect = markerRef.value.getBoundingClientRect();
|
|
const linkRect = currentLinkEl.getBoundingClientRect();
|
|
if (props2.direction === "horizontal")
|
|
markerStyle.value = {
|
|
left: `${linkRect.left - anchorRect.left}px`,
|
|
width: `${linkRect.width}px`,
|
|
opacity: 1
|
|
};
|
|
else
|
|
markerStyle.value = {
|
|
top: `${linkRect.top - anchorRect.top + (linkRect.height - markerRect.height) / 2}px`,
|
|
opacity: 1
|
|
};
|
|
});
|
|
};
|
|
watch(currentAnchor, updateMarkerStyle);
|
|
watch(() => {
|
|
var _a;
|
|
return (_a = slots.default) == null ? void 0 : _a.call(slots);
|
|
}, updateMarkerStyle);
|
|
onMounted(() => {
|
|
getContainer();
|
|
const hash = decodeURIComponent(window.location.hash);
|
|
if (getElement(hash))
|
|
scrollTo2(hash);
|
|
else
|
|
handleScroll2();
|
|
});
|
|
watch(() => props2.container, () => {
|
|
getContainer();
|
|
});
|
|
provide(anchorKey, {
|
|
ns,
|
|
direction: props2.direction,
|
|
currentAnchor,
|
|
addLink,
|
|
removeLink,
|
|
handleClick
|
|
});
|
|
__expose({ scrollTo: scrollTo2 });
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "anchorRef",
|
|
ref: anchorRef,
|
|
class: normalizeClass(cls.value)
|
|
}, [__props.marker ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
ref_key: "markerRef",
|
|
ref: markerRef,
|
|
class: normalizeClass(unref(ns).e("marker")),
|
|
style: normalizeStyle(markerStyle.value)
|
|
}, null, 6)) : createCommentVNode("v-if", true), createBaseVNode("div", { class: normalizeClass(unref(ns).e("list")) }, [renderSlot(_ctx.$slots, "default")], 2)], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/anchor/src/anchor2.mjs
|
|
var anchor_default = anchor_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// 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-link.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_179 = ["href"];
|
|
var anchor_link_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElAnchorLink",
|
|
__name: "anchor-link",
|
|
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(cls.value),
|
|
href: __props.href,
|
|
onClick: handleClick
|
|
}, [renderSlot(_ctx.$slots, "default", {}, () => [createTextVNode(toDisplayString(__props.title), 1)])], 10, _hoisted_179), _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);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/anchor/src/anchor-link2.mjs
|
|
var anchor_link_default = anchor_link_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/anchor/index.mjs
|
|
var ElAnchor = withInstall(anchor_default, { AnchorLink: anchor_link_default });
|
|
var ElAnchorLink = withNoopInstall(anchor_link_default);
|
|
|
|
// node_modules/element-plus/es/components/segmented/src/segmented.mjs
|
|
var defaultProps3 = {
|
|
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: () => defaultProps3
|
|
},
|
|
block: Boolean,
|
|
size: useSizeProp,
|
|
disabled: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
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/segmented.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_180 = [
|
|
"id",
|
|
"aria-label",
|
|
"aria-labelledby"
|
|
];
|
|
var _hoisted_243 = [
|
|
"name",
|
|
"disabled",
|
|
"checked",
|
|
"onChange"
|
|
];
|
|
var segmented_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElSegmented",
|
|
__name: "segmented",
|
|
props: segmentedProps,
|
|
emits: segmentedEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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 = (evt, item) => {
|
|
const value = getValue3(item);
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emit(CHANGE_EVENT, value);
|
|
evt.target.checked = value === props2.modelValue;
|
|
};
|
|
const aliasProps = computed(() => ({
|
|
...defaultProps3,
|
|
...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;
|
|
}
|
|
state.isInit = true;
|
|
if (props2.direction === "vertical") {
|
|
state.height = selectedItem.offsetHeight;
|
|
state.translateY = selectedItem.offsetTop;
|
|
} else {
|
|
state.width = selectedItem.offsetWidth;
|
|
state.translateX = selectedItem.offsetLeft;
|
|
}
|
|
try {
|
|
state.focusVisible = selectedItemInput.matches(":focus-visible");
|
|
} catch {
|
|
}
|
|
};
|
|
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 _a;
|
|
updateSelect();
|
|
if (props2.validateEvent)
|
|
(_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "change").catch((err) => debugWarn(err));
|
|
}, { flush: "post" });
|
|
return (_ctx, _cache) => {
|
|
return __props.options.length ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
id: unref(inputId),
|
|
ref_key: "segmentedRef",
|
|
ref: segmentedRef,
|
|
class: normalizeClass(segmentedCls.value),
|
|
role: "radiogroup",
|
|
"aria-label": !unref(isLabeledByFormItem) ? __props.ariaLabel || "segmented" : void 0,
|
|
"aria-labelledby": unref(isLabeledByFormItem) ? unref(formItem).labelId : void 0
|
|
}, [createBaseVNode("div", { class: normalizeClass([unref(ns).e("group"), unref(ns).m(__props.direction)]) }, [createBaseVNode("div", {
|
|
style: normalizeStyle(selectedStyle.value),
|
|
class: normalizeClass(selectedCls.value)
|
|
}, null, 6), (openBlock(true), createElementBlock(Fragment, null, renderList(__props.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: name.value,
|
|
disabled: getDisabled(item),
|
|
checked: getSelected(item),
|
|
onChange: ($event) => handleChange($event, item)
|
|
}, null, 42, _hoisted_243), createBaseVNode("div", { class: normalizeClass(unref(ns).e("item-label")) }, [renderSlot(_ctx.$slots, "default", { item }, () => [createTextVNode(toDisplayString(getLabel(item)), 1)])], 2)], 2);
|
|
}), 128))], 2)], 10, _hoisted_180)) : createCommentVNode("v-if", true);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/segmented/src/segmented2.mjs
|
|
var segmented_default = segmented_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/segmented/index.mjs
|
|
var ElSegmented = withInstall(segmented_default);
|
|
|
|
// node_modules/element-plus/es/components/mention/src/helper.mjs
|
|
var filterOption = (pattern4, option) => {
|
|
const lowerCase2 = pattern4.toLowerCase();
|
|
return (option.label || option.value || "").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 (splitIndex === -1 && (char === split2 || char === "\n" || char === "\r")) {
|
|
splitIndex = i;
|
|
continue;
|
|
}
|
|
if (prefixArray.includes(char)) {
|
|
const end = splitIndex === -1 ? selectionEnd : splitIndex;
|
|
mentionCtx = {
|
|
pattern: inputValue.slice(i + 1, end),
|
|
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: useTooltipContentProps.popperClass,
|
|
popperStyle: useTooltipContentProps.popperStyle,
|
|
popperOptions: {
|
|
type: definePropType(Object),
|
|
default: () => ({})
|
|
},
|
|
props: {
|
|
type: definePropType(Object),
|
|
default: () => mentionDefaultProps
|
|
}
|
|
});
|
|
var mentionEmits = {
|
|
[UPDATE_MODEL_EVENT]: (value) => isString(value),
|
|
"whole-remove": (pattern4, prefix) => isString(pattern4) && isString(prefix),
|
|
input: (value) => isString(value),
|
|
search: (pattern4, prefix) => isString(pattern4) && isString(prefix),
|
|
select: (option, prefix) => isObject(option) && isString(prefix),
|
|
focus: (evt) => evt instanceof FocusEvent,
|
|
blur: (evt) => evt instanceof FocusEvent
|
|
};
|
|
var mentionDefaultProps = {
|
|
value: "value",
|
|
label: "label",
|
|
disabled: "disabled"
|
|
};
|
|
|
|
// 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-dropdown.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_181 = [
|
|
"id",
|
|
"aria-disabled",
|
|
"aria-selected",
|
|
"onMousemove",
|
|
"onClick"
|
|
];
|
|
var mention_dropdown_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElMentionDropdown",
|
|
__name: "mention-dropdown",
|
|
props: mentionDropdownProps,
|
|
emits: mentionDropdownEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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 || hoverOption.value.disabled || props2.disabled)
|
|
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 _a, _b, _c, _d;
|
|
const { options } = props2;
|
|
const index = options.findIndex((item) => item.value === option.value);
|
|
const target2 = (_a = optionRefs.value) == null ? void 0 : _a[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 = props2.options.findIndex((item) => !item.disabled);
|
|
};
|
|
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: __props.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": __props.ariaLabel,
|
|
"aria-orientation": "vertical"
|
|
}, {
|
|
default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.options, (item, index) => {
|
|
return openBlock(), createElementBlock("li", {
|
|
id: `${__props.contentId}-${index}`,
|
|
ref_for: true,
|
|
ref_key: "optionRefs",
|
|
ref: optionRefs,
|
|
key: index,
|
|
class: normalizeClass(optionkls(item, index)),
|
|
role: "option",
|
|
"aria-disabled": item.disabled || __props.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 _a;
|
|
return [createBaseVNode("span", null, toDisplayString((_a = item.label) != null ? _a : item.value), 1)];
|
|
})], 42, _hoisted_181);
|
|
}), 128))]),
|
|
_: 3
|
|
}, 8, [
|
|
"id",
|
|
"wrap-class",
|
|
"view-class",
|
|
"aria-label"
|
|
]), [[vShow, __props.options.length > 0 && !__props.loading]]),
|
|
__props.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);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/mention/src/mention-dropdown2.mjs
|
|
var mention_dropdown_default = mention_dropdown_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/mention/src/mention.vue_vue_type_script_setup_true_lang.mjs
|
|
var mention_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElMention",
|
|
inheritAttrs: false,
|
|
__name: "mention",
|
|
props: mentionProps,
|
|
emits: mentionEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const passInputProps = computed(() => {
|
|
var _a;
|
|
const inputProps2 = (_a = ElInput.props) != null ? _a : [];
|
|
return pick_default(props2, isArray(inputProps2) ? inputProps2 : Object.keys(inputProps2));
|
|
});
|
|
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 aliasProps = computed(() => ({
|
|
...mentionDefaultProps,
|
|
...props2.props
|
|
}));
|
|
const mapOption = (option) => {
|
|
const base = {
|
|
label: option[aliasProps.value.label],
|
|
value: option[aliasProps.value.value],
|
|
disabled: option[aliasProps.value.disabled]
|
|
};
|
|
return {
|
|
...option,
|
|
...base
|
|
};
|
|
};
|
|
const options = computed(() => props2.options.map(mapOption));
|
|
const filteredOptions = computed(() => {
|
|
const { filterOption: filterOption2 } = props2;
|
|
if (!mentionCtx.value || !filterOption2)
|
|
return options.value;
|
|
return options.value.filter((option) => filterOption2(mentionCtx.value.pattern, option));
|
|
});
|
|
const dropdownVisible = computed(() => {
|
|
return visible.value && (!!filteredOptions.value.length || props2.loading);
|
|
});
|
|
const hoveringId = computed(() => {
|
|
var _a;
|
|
return `${contentId.value}-${(_a = dropdownRef.value) == null ? void 0 : _a.hoveringIndex}`;
|
|
});
|
|
const handleInputChange = (value) => {
|
|
emit(UPDATE_MODEL_EVENT, value);
|
|
emit(INPUT_EVENT, value);
|
|
syncAfterCursorMove();
|
|
};
|
|
const handleInputKeyDown = (event) => {
|
|
var _a, _b, _c, _d;
|
|
if ((_a = elInputRef.value) == null ? void 0 : _a.isComposing)
|
|
return;
|
|
const code = getEventCode(event);
|
|
switch (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(code === EVENT_CODE.up ? "prev" : "next");
|
|
break;
|
|
case EVENT_CODE.enter:
|
|
case EVENT_CODE.numpadEnter:
|
|
if (!visible.value) {
|
|
props2.type !== "textarea" && syncAfterCursorMove();
|
|
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 = options.value.find((item) => item.value === pattern4);
|
|
if ((isFunction(props2.checkIsWhole) ? props2.checkIsWhole(pattern4, prefix) : matchOption) && 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);
|
|
emit("whole-remove", pattern4, prefix);
|
|
const newSelectionEnd = prefixIndex;
|
|
nextTick(() => {
|
|
inputEl.selectionStart = newSelectionEnd;
|
|
inputEl.selectionEnd = newSelectionEnd;
|
|
syncDropdownVisible();
|
|
});
|
|
}
|
|
}
|
|
}
|
|
};
|
|
const { wrapperRef } = useFocusController(elInputRef, {
|
|
disabled,
|
|
afterFocus() {
|
|
syncAfterCursorMove();
|
|
},
|
|
beforeBlur(event) {
|
|
var _a;
|
|
return (_a = tooltipRef.value) == null ? void 0 : _a.isFocusInsideContent(event);
|
|
},
|
|
afterBlur() {
|
|
visible.value = false;
|
|
}
|
|
});
|
|
const handleInputMouseDown = () => {
|
|
syncAfterCursorMove();
|
|
};
|
|
const getOriginalOption = (mentionOption) => {
|
|
return props2.options.find((option) => {
|
|
return mentionOption.value === option[aliasProps.value.value];
|
|
});
|
|
};
|
|
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", getOriginalOption(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 _a, _b;
|
|
return props2.type === "textarea" ? (_a = elInputRef.value) == null ? void 0 : _a.textarea : (_b = elInputRef.value) == null ? void 0 : _b.input;
|
|
};
|
|
const syncAfterCursorMove = () => {
|
|
setTimeout(() => {
|
|
syncCursor();
|
|
syncDropdownVisible();
|
|
nextTick(() => {
|
|
var _a;
|
|
return (_a = tooltipRef.value) == null ? void 0 : _a.updatePopper();
|
|
});
|
|
}, 0);
|
|
};
|
|
const syncCursor = () => {
|
|
const inputEl = getInputEl();
|
|
if (!inputEl)
|
|
return;
|
|
const caretPosition = getCursorPosition(inputEl);
|
|
const inputRect = inputEl.getBoundingClientRect();
|
|
const wrapperRect = wrapperRef.value.getBoundingClientRect();
|
|
cursorStyle.value = {
|
|
position: "absolute",
|
|
width: 0,
|
|
height: `${caretPosition.height}px`,
|
|
left: `${caretPosition.left + inputRect.left - wrapperRect.left}px`,
|
|
top: `${caretPosition.top + inputRect.top - wrapperRect.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(passInputProps.value, _ctx.$attrs), {
|
|
ref_key: "elInputRef",
|
|
ref: elInputRef,
|
|
"model-value": __props.modelValue,
|
|
disabled: unref(disabled),
|
|
role: dropdownVisible.value ? "combobox" : void 0,
|
|
"aria-activedescendant": dropdownVisible.value ? hoveringId.value || "" : void 0,
|
|
"aria-controls": dropdownVisible.value ? unref(contentId) : void 0,
|
|
"aria-expanded": dropdownVisible.value || void 0,
|
|
"aria-label": __props.ariaLabel,
|
|
"aria-autocomplete": dropdownVisible.value ? "none" : void 0,
|
|
"aria-haspopup": dropdownVisible.value ? "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: dropdownVisible.value,
|
|
"popper-class": [unref(ns).e("popper"), __props.popperClass],
|
|
"popper-style": __props.popperStyle,
|
|
"popper-options": __props.popperOptions,
|
|
placement: computedPlacement.value,
|
|
"fallback-placements": computedFallbackPlacements.value,
|
|
effect: "light",
|
|
pure: "",
|
|
offset: __props.offset,
|
|
"show-arrow": __props.showArrow
|
|
}, {
|
|
default: withCtx(() => [createBaseVNode("div", { style: normalizeStyle(cursorStyle.value) }, null, 4)]),
|
|
content: withCtx(() => [createVNode(mention_dropdown_default, {
|
|
ref_key: "dropdownRef",
|
|
ref: dropdownRef,
|
|
options: filteredOptions.value,
|
|
disabled: unref(disabled),
|
|
loading: __props.loading,
|
|
"content-id": unref(contentId),
|
|
"aria-label": __props.ariaLabel,
|
|
onSelect: handleSelect,
|
|
onClick: _cache[0] || (_cache[0] = withModifiers(($event) => {
|
|
var _a;
|
|
return (_a = elInputRef.value) == null ? void 0 : _a.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"
|
|
])]),
|
|
_: 3
|
|
}, 8, [
|
|
"visible",
|
|
"popper-class",
|
|
"popper-style",
|
|
"popper-options",
|
|
"placement",
|
|
"fallback-placements",
|
|
"offset",
|
|
"show-arrow"
|
|
])], 2);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/mention/src/mention2.mjs
|
|
var mention_default = mention_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/mention/index.mjs
|
|
var ElMention = withInstall(mention_default);
|
|
|
|
// node_modules/element-plus/es/components/splitter/src/splitter.mjs
|
|
var splitterProps = buildProps({
|
|
layout: {
|
|
type: String,
|
|
default: "horizontal",
|
|
values: ["horizontal", "vertical"]
|
|
},
|
|
lazy: Boolean
|
|
});
|
|
var splitterEmits = {
|
|
resizeStart: (index, sizes) => true,
|
|
resize: (index, sizes) => true,
|
|
resizeEnd: (index, sizes) => true,
|
|
collapse: (index, type4, sizes) => true
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/splitter/src/split-panel.mjs
|
|
var splitterPanelProps = buildProps({
|
|
min: { type: [String, Number] },
|
|
max: { type: [String, Number] },
|
|
size: { type: [String, Number] },
|
|
resizable: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
collapsible: Boolean
|
|
});
|
|
var splitterPanelEmits = { "update:size": (value) => typeof value === "number" || typeof value === "string" };
|
|
|
|
// node_modules/element-plus/es/components/splitter/src/hooks/useContainer.mjs
|
|
function useContainer(layout2) {
|
|
const containerEl = ref();
|
|
const { width, height } = useElementSize(containerEl);
|
|
return {
|
|
containerEl,
|
|
containerSize: computed(() => {
|
|
return layout2.value === "horizontal" ? width.value : height.value;
|
|
})
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/splitter/src/hooks/useSize.mjs
|
|
function getPct(str) {
|
|
return Number(str.slice(0, -1)) / 100;
|
|
}
|
|
function getPx(str) {
|
|
return Number(str.slice(0, -2));
|
|
}
|
|
function isPct(itemSize3) {
|
|
return isString(itemSize3) && itemSize3.endsWith("%");
|
|
}
|
|
function isPx(itemSize3) {
|
|
return isString(itemSize3) && itemSize3.endsWith("px");
|
|
}
|
|
function useSize2(panels, containerSize) {
|
|
const propSizes = computed(() => panels.value.map((i) => i.size));
|
|
const panelCounts = computed(() => panels.value.length);
|
|
const percentSizes = ref([]);
|
|
watch([
|
|
propSizes,
|
|
panelCounts,
|
|
containerSize
|
|
], () => {
|
|
var _a;
|
|
let ptgList = [];
|
|
let emptyCount = 0;
|
|
for (let i = 0; i < panelCounts.value; i += 1) {
|
|
const itemSize3 = (_a = panels.value[i]) == null ? void 0 : _a.size;
|
|
if (isPct(itemSize3))
|
|
ptgList[i] = getPct(itemSize3);
|
|
else if (isPx(itemSize3))
|
|
ptgList[i] = getPx(itemSize3) / containerSize.value;
|
|
else if (itemSize3 || itemSize3 === 0) {
|
|
const num = Number(itemSize3);
|
|
if (!Number.isNaN(num))
|
|
ptgList[i] = num / containerSize.value;
|
|
} else {
|
|
emptyCount += 1;
|
|
ptgList[i] = void 0;
|
|
}
|
|
}
|
|
const totalPtg = ptgList.reduce((acc, ptg) => acc + (ptg || 0), 0);
|
|
if (totalPtg > 1 || !emptyCount) {
|
|
const scale = 1 / totalPtg;
|
|
ptgList = ptgList.map((ptg) => ptg === void 0 ? 0 : ptg * scale);
|
|
} else {
|
|
const avgRest = (1 - totalPtg) / emptyCount;
|
|
ptgList = ptgList.map((ptg) => ptg === void 0 ? avgRest : ptg);
|
|
}
|
|
percentSizes.value = ptgList;
|
|
});
|
|
const ptg2px = (ptg) => ptg * containerSize.value;
|
|
return {
|
|
percentSizes,
|
|
pxSizes: computed(() => percentSizes.value.map(ptg2px))
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/splitter/src/hooks/useResize.mjs
|
|
function useResize(panels, containerSize, pxSizes, lazy) {
|
|
const ptg2px = (ptg) => ptg * containerSize.value || 0;
|
|
function getLimitSize(str, defaultLimit) {
|
|
if (isPct(str))
|
|
return ptg2px(getPct(str));
|
|
else if (isPx(str))
|
|
return getPx(str);
|
|
return str != null ? str : defaultLimit;
|
|
}
|
|
const lazyOffset = ref(0);
|
|
const movingIndex = ref(null);
|
|
let cachePxSizes = [];
|
|
let updatePanelSizes = NOOP;
|
|
const limitSizes = computed(() => panels.value.map((item) => [item.min, item.max]));
|
|
watch(lazy, () => {
|
|
if (lazyOffset.value) {
|
|
const mouseup = new MouseEvent("mouseup", { bubbles: true });
|
|
window.dispatchEvent(mouseup);
|
|
}
|
|
});
|
|
const onMoveStart = (index) => {
|
|
lazyOffset.value = 0;
|
|
movingIndex.value = {
|
|
index,
|
|
confirmed: false
|
|
};
|
|
cachePxSizes = pxSizes.value;
|
|
};
|
|
const onMoving = (index, offset3) => {
|
|
var _a, _b;
|
|
let confirmedIndex = null;
|
|
if ((!movingIndex.value || !movingIndex.value.confirmed) && offset3 !== 0) {
|
|
if (offset3 > 0) {
|
|
confirmedIndex = index;
|
|
movingIndex.value = {
|
|
index,
|
|
confirmed: true
|
|
};
|
|
} else
|
|
for (let i = index; i >= 0; i -= 1)
|
|
if (cachePxSizes[i] > 0) {
|
|
confirmedIndex = i;
|
|
movingIndex.value = {
|
|
index: i,
|
|
confirmed: true
|
|
};
|
|
break;
|
|
}
|
|
}
|
|
const mergedIndex = (_b = confirmedIndex != null ? confirmedIndex : (_a = movingIndex.value) == null ? void 0 : _a.index) != null ? _b : index;
|
|
const numSizes = [...cachePxSizes];
|
|
const nextIndex = mergedIndex + 1;
|
|
const startMinSize = getLimitSize(limitSizes.value[mergedIndex][0], 0);
|
|
const endMinSize = getLimitSize(limitSizes.value[nextIndex][0], 0);
|
|
const startMaxSize = getLimitSize(limitSizes.value[mergedIndex][1], containerSize.value || 0);
|
|
const endMaxSize = getLimitSize(limitSizes.value[nextIndex][1], containerSize.value || 0);
|
|
let mergedOffset = offset3;
|
|
if (numSizes[mergedIndex] + mergedOffset < startMinSize)
|
|
mergedOffset = startMinSize - numSizes[mergedIndex];
|
|
if (numSizes[nextIndex] - mergedOffset < endMinSize)
|
|
mergedOffset = numSizes[nextIndex] - endMinSize;
|
|
if (numSizes[mergedIndex] + mergedOffset > startMaxSize)
|
|
mergedOffset = startMaxSize - numSizes[mergedIndex];
|
|
if (numSizes[nextIndex] - mergedOffset > endMaxSize)
|
|
mergedOffset = numSizes[nextIndex] - endMaxSize;
|
|
numSizes[mergedIndex] += mergedOffset;
|
|
numSizes[nextIndex] -= mergedOffset;
|
|
lazyOffset.value = mergedOffset;
|
|
updatePanelSizes = () => {
|
|
panels.value.forEach((panel, index2) => {
|
|
panel.size = numSizes[index2];
|
|
});
|
|
updatePanelSizes = NOOP;
|
|
};
|
|
if (!lazy.value)
|
|
updatePanelSizes();
|
|
};
|
|
const onMoveEnd = () => {
|
|
if (lazy.value)
|
|
updatePanelSizes();
|
|
lazyOffset.value = 0;
|
|
movingIndex.value = null;
|
|
cachePxSizes = [];
|
|
};
|
|
const cacheCollapsedSize = [];
|
|
const onCollapse = (index, type4) => {
|
|
if (!cacheCollapsedSize.length)
|
|
cacheCollapsedSize.push(...pxSizes.value);
|
|
const currentSizes = pxSizes.value;
|
|
const currentIndex = type4 === "start" ? index : index + 1;
|
|
const targetIndex = type4 === "start" ? index + 1 : index;
|
|
const currentSize = currentSizes[currentIndex];
|
|
const targetSize = currentSizes[targetIndex];
|
|
if (currentSize !== 0 && targetSize !== 0) {
|
|
currentSizes[currentIndex] = 0;
|
|
currentSizes[targetIndex] += currentSize;
|
|
cacheCollapsedSize[index] = currentSize;
|
|
} else {
|
|
const totalSize = currentSize + targetSize;
|
|
const targetCacheCollapsedSize = cacheCollapsedSize[index];
|
|
const currentCacheCollapsedSize = totalSize - targetCacheCollapsedSize;
|
|
currentSizes[targetIndex] = targetCacheCollapsedSize;
|
|
currentSizes[currentIndex] = currentCacheCollapsedSize;
|
|
}
|
|
panels.value.forEach((panel, index2) => {
|
|
panel.size = currentSizes[index2];
|
|
});
|
|
};
|
|
return {
|
|
lazyOffset,
|
|
onMoveStart,
|
|
onMoving,
|
|
onMoveEnd,
|
|
movingIndex,
|
|
onCollapse
|
|
};
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/splitter/src/type.mjs
|
|
var splitterRootContextKey = Symbol("splitterRootContextKey");
|
|
|
|
// node_modules/element-plus/es/components/splitter/src/splitter.vue_vue_type_script_setup_true_lang.mjs
|
|
var splitter_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElSplitter",
|
|
__name: "splitter",
|
|
props: splitterProps,
|
|
emits: splitterEmits,
|
|
setup(__props, { emit: __emit }) {
|
|
const ns = useNamespace("splitter");
|
|
const emits = __emit;
|
|
const props2 = __props;
|
|
const layout2 = toRef(props2, "layout");
|
|
const lazy = toRef(props2, "lazy");
|
|
const { containerEl, containerSize } = useContainer(layout2);
|
|
const { removeChild: unregisterPanel, children: panels, addChild: registerPanel, ChildrenSorter: PanelsSorter } = useOrderedChildren(getCurrentInstance(), "ElSplitterPanel");
|
|
watch(panels, () => {
|
|
movingIndex.value = null;
|
|
panels.value.forEach((instance, index) => {
|
|
instance.setIndex(index);
|
|
});
|
|
});
|
|
const { percentSizes, pxSizes } = useSize2(panels, containerSize);
|
|
const { lazyOffset, movingIndex, onMoveStart, onMoving, onMoveEnd, onCollapse } = useResize(panels, containerSize, pxSizes, lazy);
|
|
const splitterStyles = computed(() => {
|
|
return { [ns.cssVarBlockName("bar-offset")]: lazy.value ? `${lazyOffset.value}px` : void 0 };
|
|
});
|
|
const onResizeStart = (index) => {
|
|
onMoveStart(index);
|
|
emits("resizeStart", index, pxSizes.value);
|
|
};
|
|
const onResize = (index, offset3) => {
|
|
onMoving(index, offset3);
|
|
if (!lazy.value)
|
|
emits("resize", index, pxSizes.value);
|
|
};
|
|
const onResizeEnd = async (index) => {
|
|
onMoveEnd();
|
|
await nextTick();
|
|
emits("resizeEnd", index, pxSizes.value);
|
|
};
|
|
const onCollapsible = (index, type4) => {
|
|
onCollapse(index, type4);
|
|
emits("collapse", index, type4, pxSizes.value);
|
|
};
|
|
provide(splitterRootContextKey, reactive({
|
|
panels,
|
|
percentSizes,
|
|
pxSizes,
|
|
layout: layout2,
|
|
lazy,
|
|
movingIndex,
|
|
containerSize,
|
|
onMoveStart: onResizeStart,
|
|
onMoving: onResize,
|
|
onMoveEnd: onResizeEnd,
|
|
onCollapse: onCollapsible,
|
|
registerPanel,
|
|
unregisterPanel
|
|
}));
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
ref_key: "containerEl",
|
|
ref: containerEl,
|
|
class: normalizeClass([unref(ns).b(), unref(ns).e(layout2.value)]),
|
|
style: normalizeStyle(splitterStyles.value)
|
|
}, [
|
|
renderSlot(_ctx.$slots, "default"),
|
|
createVNode(unref(PanelsSorter)),
|
|
createCommentVNode(" Prevent iframe touch events from breaking "),
|
|
unref(movingIndex) ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("mask"), unref(ns).e(`mask-${layout2.value}`)])
|
|
}, null, 2)) : createCommentVNode("v-if", true)
|
|
], 6);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/splitter/src/splitter2.mjs
|
|
var splitter_default = splitter_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/splitter/src/hooks/usePanel.mjs
|
|
function getCollapsible(collapsible) {
|
|
if (collapsible && isObject(collapsible))
|
|
return collapsible;
|
|
return {
|
|
start: !!collapsible,
|
|
end: !!collapsible
|
|
};
|
|
}
|
|
function isCollapsible(panel, size3, nextPanel, nextSize) {
|
|
if ((panel == null ? void 0 : panel.collapsible.end) && size3 > 0)
|
|
return true;
|
|
if ((nextPanel == null ? void 0 : nextPanel.collapsible.start) && nextSize === 0 && size3 > 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
// node_modules/element-plus/es/components/splitter/src/split-bar.vue_vue_type_script_setup_true_lang.mjs
|
|
var split_bar_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElSplitterBar",
|
|
__name: "split-bar",
|
|
props: {
|
|
index: {
|
|
type: Number,
|
|
required: true
|
|
},
|
|
layout: {
|
|
type: String,
|
|
values: ["horizontal", "vertical"],
|
|
default: "horizontal"
|
|
},
|
|
resizable: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
lazy: Boolean,
|
|
startCollapsible: Boolean,
|
|
endCollapsible: Boolean
|
|
},
|
|
emits: [
|
|
"moveStart",
|
|
"moving",
|
|
"moveEnd",
|
|
"collapse"
|
|
],
|
|
setup(__props, { emit: __emit }) {
|
|
const ns = useNamespace("splitter-bar");
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
const isHorizontal2 = computed(() => props2.layout === "horizontal");
|
|
const barWrapStyles = computed(() => {
|
|
if (isHorizontal2.value)
|
|
return { width: 0 };
|
|
return { height: 0 };
|
|
});
|
|
const draggerStyles = computed(() => {
|
|
return {
|
|
width: isHorizontal2.value ? "16px" : "100%",
|
|
height: isHorizontal2.value ? "100%" : "16px",
|
|
cursor: !props2.resizable ? "auto" : isHorizontal2.value ? "ew-resize" : "ns-resize",
|
|
touchAction: "none"
|
|
};
|
|
});
|
|
const draggerPseudoClass = computed(() => {
|
|
const prefix = ns.e("dragger");
|
|
return {
|
|
[`${prefix}-horizontal`]: isHorizontal2.value,
|
|
[`${prefix}-vertical`]: !isHorizontal2.value,
|
|
[`${prefix}-active`]: !!startPos.value
|
|
};
|
|
});
|
|
const startPos = ref(null);
|
|
const onMousedown = (e) => {
|
|
if (!props2.resizable)
|
|
return;
|
|
startPos.value = [e.pageX, e.pageY];
|
|
emit("moveStart", props2.index);
|
|
window.addEventListener("mouseup", onMouseUp);
|
|
window.addEventListener("mousemove", onMouseMove);
|
|
};
|
|
const onTouchStart = (e) => {
|
|
if (props2.resizable && e.touches.length === 1) {
|
|
e.preventDefault();
|
|
const touch = e.touches[0];
|
|
startPos.value = [touch.pageX, touch.pageY];
|
|
emit("moveStart", props2.index);
|
|
window.addEventListener("touchend", onTouchEnd);
|
|
window.addEventListener("touchmove", onTouchMove);
|
|
}
|
|
};
|
|
const onMouseMove = (e) => {
|
|
const { pageX, pageY } = e;
|
|
const offsetX = pageX - startPos.value[0];
|
|
const offsetY = pageY - startPos.value[1];
|
|
const offset3 = isHorizontal2.value ? offsetX : offsetY;
|
|
emit("moving", props2.index, offset3);
|
|
};
|
|
const onTouchMove = (e) => {
|
|
if (e.touches.length === 1) {
|
|
e.preventDefault();
|
|
const touch = e.touches[0];
|
|
const offsetX = touch.pageX - startPos.value[0];
|
|
const offsetY = touch.pageY - startPos.value[1];
|
|
const offset3 = isHorizontal2.value ? offsetX : offsetY;
|
|
emit("moving", props2.index, offset3);
|
|
}
|
|
};
|
|
const onMouseUp = () => {
|
|
startPos.value = null;
|
|
window.removeEventListener("mouseup", onMouseUp);
|
|
window.removeEventListener("mousemove", onMouseMove);
|
|
emit("moveEnd", props2.index);
|
|
};
|
|
const onTouchEnd = () => {
|
|
startPos.value = null;
|
|
window.removeEventListener("touchend", onTouchEnd);
|
|
window.removeEventListener("touchmove", onTouchMove);
|
|
emit("moveEnd", props2.index);
|
|
};
|
|
const StartIcon = computed(() => isHorizontal2.value ? arrow_left_default : arrow_up_default);
|
|
const EndIcon = computed(() => isHorizontal2.value ? arrow_right_default : arrow_down_default);
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock("div", {
|
|
class: normalizeClass([unref(ns).b()]),
|
|
style: normalizeStyle(barWrapStyles.value)
|
|
}, [
|
|
__props.startCollapsible ? (openBlock(), createElementBlock("div", {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("collapse-icon"), unref(ns).e(`${__props.layout}-collapse-icon-start`)]),
|
|
onClick: _cache[0] || (_cache[0] = ($event) => emit("collapse", __props.index, "start"))
|
|
}, [renderSlot(_ctx.$slots, "start-collapsible", {}, () => [(openBlock(), createBlock(resolveDynamicComponent(StartIcon.value), { style: {
|
|
"width": "12px",
|
|
"height": "12px"
|
|
} }))])], 2)) : createCommentVNode("v-if", true),
|
|
createBaseVNode("div", {
|
|
class: normalizeClass([
|
|
unref(ns).e("dragger"),
|
|
draggerPseudoClass.value,
|
|
unref(ns).is("disabled", !__props.resizable),
|
|
unref(ns).is("lazy", __props.resizable && __props.lazy)
|
|
]),
|
|
style: normalizeStyle(draggerStyles.value),
|
|
onMousedown,
|
|
onTouchstart: onTouchStart
|
|
}, null, 38),
|
|
__props.endCollapsible ? (openBlock(), createElementBlock("div", {
|
|
key: 1,
|
|
class: normalizeClass([unref(ns).e("collapse-icon"), unref(ns).e(`${__props.layout}-collapse-icon-end`)]),
|
|
onClick: _cache[1] || (_cache[1] = ($event) => emit("collapse", __props.index, "end"))
|
|
}, [renderSlot(_ctx.$slots, "end-collapsible", {}, () => [(openBlock(), createBlock(resolveDynamicComponent(EndIcon.value), { style: {
|
|
"width": "12px",
|
|
"height": "12px"
|
|
} }))])], 2)) : createCommentVNode("v-if", true)
|
|
], 6);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/splitter/src/split-bar.mjs
|
|
var split_bar_default = split_bar_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/splitter/src/split-panel.vue_vue_type_script_setup_true_lang.mjs
|
|
var COMPONENT_NAME23 = "ElSplitterPanel";
|
|
var split_panel_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: COMPONENT_NAME23,
|
|
__name: "split-panel",
|
|
props: splitterPanelProps,
|
|
emits: splitterPanelEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const ns = useNamespace("splitter-panel");
|
|
const props2 = __props;
|
|
const emits = __emit;
|
|
const splitterContext = inject(splitterRootContextKey);
|
|
if (!splitterContext)
|
|
throwError(COMPONENT_NAME23, "usage: <el-splitter><el-splitter-panel /></el-splitter/>");
|
|
const { panels, layout: layout2, lazy, containerSize, pxSizes } = toRefs(splitterContext);
|
|
const { registerPanel, unregisterPanel, onCollapse, onMoveEnd, onMoveStart, onMoving } = splitterContext;
|
|
const panelEl = ref();
|
|
const instance = getCurrentInstance();
|
|
const uid2 = instance.uid;
|
|
const index = ref(0);
|
|
const panel = computed(() => panels.value[index.value]);
|
|
const setIndex = (val) => {
|
|
index.value = val;
|
|
};
|
|
const panelSize = computed(() => {
|
|
var _a;
|
|
if (!panel.value)
|
|
return 0;
|
|
return (_a = pxSizes.value[index.value]) != null ? _a : 0;
|
|
});
|
|
const nextSize = computed(() => {
|
|
var _a;
|
|
if (!panel.value)
|
|
return 0;
|
|
return (_a = pxSizes.value[index.value + 1]) != null ? _a : 0;
|
|
});
|
|
const nextPanel = computed(() => {
|
|
if (panel.value)
|
|
return panels.value[index.value + 1];
|
|
return null;
|
|
});
|
|
const isResizable = computed(() => {
|
|
var _a;
|
|
if (!nextPanel.value)
|
|
return false;
|
|
return props2.resizable && ((_a = nextPanel.value) == null ? void 0 : _a.resizable) && (panelSize.value !== 0 || !props2.min) && (nextSize.value !== 0 || !nextPanel.value.min);
|
|
});
|
|
const isShowBar = computed(() => {
|
|
if (!panel.value)
|
|
return false;
|
|
return index.value !== panels.value.length - 1;
|
|
});
|
|
const startCollapsible = computed(() => isCollapsible(panel.value, panelSize.value, nextPanel.value, nextSize.value));
|
|
const endCollapsible = computed(() => isCollapsible(nextPanel.value, nextSize.value, panel.value, panelSize.value));
|
|
function sizeToPx(str) {
|
|
if (isPct(str))
|
|
return getPct(str) * containerSize.value || 0;
|
|
else if (isPx(str))
|
|
return getPx(str);
|
|
return str != null ? str : 0;
|
|
}
|
|
let isSizeUpdating = false;
|
|
watch(() => props2.size, () => {
|
|
if (!isSizeUpdating && panel.value) {
|
|
if (!containerSize.value) {
|
|
panel.value.size = props2.size;
|
|
return;
|
|
}
|
|
const size3 = sizeToPx(props2.size);
|
|
const maxSize = sizeToPx(props2.max);
|
|
const minSize = sizeToPx(props2.min);
|
|
const finalSize = Math.min(Math.max(size3, minSize || 0), maxSize || size3);
|
|
if (finalSize !== size3)
|
|
emits("update:size", finalSize);
|
|
panel.value.size = finalSize;
|
|
}
|
|
});
|
|
watch(() => {
|
|
var _a;
|
|
return (_a = panel.value) == null ? void 0 : _a.size;
|
|
}, (val) => {
|
|
if (val !== props2.size) {
|
|
isSizeUpdating = true;
|
|
emits("update:size", val);
|
|
nextTick(() => isSizeUpdating = false);
|
|
}
|
|
});
|
|
watch(() => props2.resizable, (val) => {
|
|
if (panel.value)
|
|
panel.value.resizable = val;
|
|
});
|
|
const _panel = reactive({
|
|
uid: uid2,
|
|
getVnode: () => instance.vnode,
|
|
setIndex,
|
|
...props2,
|
|
collapsible: computed(() => getCollapsible(props2.collapsible))
|
|
});
|
|
registerPanel(_panel);
|
|
onBeforeUnmount(() => unregisterPanel(_panel));
|
|
__expose({ splitterPanelRef: panelEl });
|
|
return (_ctx, _cache) => {
|
|
return openBlock(), createElementBlock(Fragment, null, [createBaseVNode("div", mergeProps({
|
|
ref_key: "panelEl",
|
|
ref: panelEl,
|
|
class: [unref(ns).b()],
|
|
style: { flexBasis: `${panelSize.value}px` }
|
|
}, _ctx.$attrs), [renderSlot(_ctx.$slots, "default")], 16), isShowBar.value ? (openBlock(), createBlock(split_bar_default, {
|
|
key: 0,
|
|
index: index.value,
|
|
layout: unref(layout2),
|
|
lazy: unref(lazy),
|
|
resizable: isResizable.value,
|
|
"start-collapsible": startCollapsible.value,
|
|
"end-collapsible": endCollapsible.value,
|
|
onMoveStart: unref(onMoveStart),
|
|
onMoving: unref(onMoving),
|
|
onMoveEnd: unref(onMoveEnd),
|
|
onCollapse: unref(onCollapse)
|
|
}, {
|
|
"start-collapsible": withCtx(() => [renderSlot(_ctx.$slots, "start-collapsible")]),
|
|
"end-collapsible": withCtx(() => [renderSlot(_ctx.$slots, "end-collapsible")]),
|
|
_: 3
|
|
}, 8, [
|
|
"index",
|
|
"layout",
|
|
"lazy",
|
|
"resizable",
|
|
"start-collapsible",
|
|
"end-collapsible",
|
|
"onMoveStart",
|
|
"onMoving",
|
|
"onMoveEnd",
|
|
"onCollapse"
|
|
])) : createCommentVNode("v-if", true)], 64);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/splitter/src/split-panel2.mjs
|
|
var split_panel_default = split_panel_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/splitter/index.mjs
|
|
var ElSplitter = withInstall(splitter_default, { SplitPanel: split_panel_default });
|
|
var ElSplitterPanel = withNoopInstall(split_panel_default);
|
|
|
|
// node_modules/element-plus/es/version.mjs
|
|
var version = "2.13.7";
|
|
|
|
// 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,
|
|
install: install2
|
|
};
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/infinite-scroll/src/index.mjs
|
|
var SCOPE13 = "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 _a, _b;
|
|
const { type: type4, default: defaultValue } = option;
|
|
const attrVal = el.getAttribute(`infinite-scroll-${name}`);
|
|
let value = (_b = (_a = instance[attrVal]) != null ? _a : 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[SCOPE13];
|
|
if (observer) {
|
|
observer.disconnect();
|
|
delete el[SCOPE13].observer;
|
|
}
|
|
};
|
|
var handleScroll = (el, cb) => {
|
|
const { container, containerEl, instance, observer, lastScrollTop } = el[SCOPE13];
|
|
const { disabled, distance } = getScrollOptions(el, instance);
|
|
const { clientHeight, scrollHeight, scrollTop } = containerEl;
|
|
const delta = scrollTop - lastScrollTop;
|
|
el[SCOPE13].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[SCOPE13];
|
|
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;
|
|
useDeprecated({
|
|
scope: SCOPE13,
|
|
from: "the directive v-infinite-scroll",
|
|
replacement: "the el-scrollbar infinite scroll",
|
|
version: "3.0.0",
|
|
ref: "https://element-plus.org/en-US/component/scrollbar#infinite-scroll"
|
|
}, true);
|
|
if (!isFunction(cb))
|
|
throwError(SCOPE13, "'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[SCOPE13] = {
|
|
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[SCOPE13].observer = observer;
|
|
observer.observe(el, {
|
|
childList: true,
|
|
subtree: true
|
|
});
|
|
checkFull(el, cb);
|
|
}
|
|
container.addEventListener("scroll", onScroll);
|
|
},
|
|
unmounted(el) {
|
|
if (!el[SCOPE13])
|
|
return;
|
|
const { container, onScroll } = el[SCOPE13];
|
|
container == null ? void 0 : container.removeEventListener("scroll", onScroll);
|
|
destroyObserver(el);
|
|
},
|
|
async updated(el) {
|
|
if (!el[SCOPE13])
|
|
await nextTick();
|
|
else {
|
|
const { containerEl, cb, observer } = el[SCOPE13];
|
|
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 _a, _b;
|
|
(_b = (_a = vm.$el) == null ? void 0 : _a.parentNode) == null ? void 0 : _b.removeChild(vm.$el);
|
|
}
|
|
function close2() {
|
|
var _a;
|
|
if (options.beforeClose && !options.beforeClose())
|
|
return;
|
|
afterLeaveFlag.value = true;
|
|
clearTimeout(afterLeaveTimer);
|
|
afterLeaveTimer = setTimeout(handleAfterLeave, 400);
|
|
data.visible = false;
|
|
(_a = options.closed) == null ? void 0 : _a.call(options);
|
|
}
|
|
function handleAfterLeave() {
|
|
if (!afterLeaveFlag.value)
|
|
return;
|
|
const target2 = data.parent;
|
|
afterLeaveFlag.value = false;
|
|
target2.vLoadingAddClassList = void 0;
|
|
destroySelf();
|
|
}
|
|
const loadingInstance = createApp(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,
|
|
ns.is("fullscreen", data.fullscreen)
|
|
]
|
|
}, [h("div", { class: ns.b("spinner") }, [spinner, spinnerText])]), [[vShow, data.visible]])]) });
|
|
};
|
|
}
|
|
}));
|
|
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 = {}, context) {
|
|
if (!isClient)
|
|
return void 0;
|
|
const resolved = resolveOptions(options);
|
|
if (resolved.fullscreen && fullscreenInstance)
|
|
return fullscreenInstance;
|
|
const instance = createLoadingComponent({
|
|
...resolved,
|
|
closed: () => {
|
|
var _a;
|
|
(_a = resolved.closed) == null ? void 0 : _a.call(resolved);
|
|
if (resolved.fullscreen)
|
|
fullscreenInstance = void 0;
|
|
}
|
|
}, context != null ? context : 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 _a, _b, _c, _d;
|
|
let target2;
|
|
if (isString(options.target))
|
|
target2 = (_a = document.querySelector(options.target)) != null ? _a : 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 getAttributeName = (name) => {
|
|
return `element-loading-${hyphenate(name)}`;
|
|
};
|
|
var createInstance = (el, binding) => {
|
|
var _a, _b, _c, _d;
|
|
const vm = binding.instance;
|
|
const getBindingProp = (key) => isObject(binding.value) ? binding.value[key] : void 0;
|
|
const resolveExpression = (key) => {
|
|
return ref(isString(key) && (vm == null ? void 0 : vm[key]) || key);
|
|
};
|
|
const getProp2 = (name) => resolveExpression(getBindingProp(name) || el.getAttribute(getAttributeName(name)));
|
|
const fullscreen = (_a = getBindingProp("fullscreen")) != null ? _a : 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 = (originalOptions, newOptions) => {
|
|
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.value) {
|
|
instance == null ? void 0 : instance.instance.close();
|
|
el[INSTANCE_KEY] = null;
|
|
return;
|
|
}
|
|
if (!instance)
|
|
createInstance(el, binding);
|
|
else
|
|
updateOptions(instance.options, isObject(binding.value) ? binding.value : {
|
|
text: el.getAttribute(getAttributeName("text")),
|
|
svg: el.getAttribute(getAttributeName("svg")),
|
|
svgViewBox: el.getAttribute(getAttributeName("svgViewBox")),
|
|
spinner: el.getAttribute(getAttributeName("spinner")),
|
|
background: el.getAttribute(getAttributeName("background")),
|
|
customClass: el.getAttribute(getAttributeName("customClass"))
|
|
});
|
|
},
|
|
unmounted(el) {
|
|
var _a;
|
|
(_a = el[INSTANCE_KEY]) == null ? void 0 : _a.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 messagePlacement = [
|
|
"top",
|
|
"top-left",
|
|
"top-right",
|
|
"bottom",
|
|
"bottom-left",
|
|
"bottom-right"
|
|
];
|
|
var MESSAGE_DEFAULT_PLACEMENT = "top";
|
|
var messageDefaults = mutable({
|
|
customClass: "",
|
|
dangerouslyUseHTMLString: false,
|
|
duration: 3e3,
|
|
icon: void 0,
|
|
id: "",
|
|
message: "",
|
|
onClose: void 0,
|
|
showClose: false,
|
|
type: "info",
|
|
plain: false,
|
|
offset: 16,
|
|
placement: void 0,
|
|
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
|
|
},
|
|
placement: {
|
|
type: String,
|
|
values: messagePlacement,
|
|
default: messageDefaults.placement
|
|
},
|
|
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 placementInstances = shallowReactive({});
|
|
var getOrCreatePlacementInstances = (placement) => {
|
|
if (!placementInstances[placement])
|
|
placementInstances[placement] = shallowReactive([]);
|
|
return placementInstances[placement];
|
|
};
|
|
var getInstance = (id, placement) => {
|
|
const instances = placementInstances[placement] || [];
|
|
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, placement) => {
|
|
const { prev } = getInstance(id, placement);
|
|
if (!prev)
|
|
return 0;
|
|
return prev.vm.exposed.bottom.value;
|
|
};
|
|
var getOffsetOrSpace = (id, offset3, placement) => {
|
|
return (placementInstances[placement] || []).findIndex((instance) => instance.id === id) > 0 ? 16 : offset3;
|
|
};
|
|
|
|
// node_modules/element-plus/es/components/message/src/message.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_183 = ["id"];
|
|
var _hoisted_244 = ["innerHTML"];
|
|
var message_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElMessage",
|
|
__name: "message",
|
|
props: messageProps,
|
|
emits: messageEmits,
|
|
setup(__props, { expose: __expose, emit: __emit }) {
|
|
const { Close } = TypeComponents;
|
|
const props2 = __props;
|
|
const emit = __emit;
|
|
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 placement = computed(() => props2.placement || MESSAGE_DEFAULT_PLACEMENT);
|
|
const lastOffset = computed(() => getLastOffset(props2.id, placement.value));
|
|
const offset3 = computed(() => {
|
|
return Math.max(getOffsetOrSpace(props2.id, props2.offset, placement.value) + lastOffset.value, props2.offset);
|
|
});
|
|
const bottom = computed(() => height.value + offset3.value);
|
|
const horizontalClass = computed(() => {
|
|
if (placement.value.includes("left"))
|
|
return ns.is("left");
|
|
if (placement.value.includes("right"))
|
|
return ns.is("right");
|
|
return ns.is("center");
|
|
});
|
|
const verticalProperty = computed(() => placement.value.startsWith("top") ? "top" : "bottom");
|
|
const customStyle = computed(() => ({
|
|
[verticalProperty.value]: `${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 _a;
|
|
if (!isStartTransition.value) {
|
|
(_a = props2.onClose) == null ? void 0 : _a.call(props2);
|
|
emit("destroy");
|
|
}
|
|
});
|
|
}
|
|
function keydown(event) {
|
|
if (getEventCode(event) === 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: _cache[0] || (_cache[0] = ($event) => isStartTransition.value = true),
|
|
onBeforeLeave: __props.onClose,
|
|
onAfterLeave: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("destroy")),
|
|
persisted: ""
|
|
}, {
|
|
default: withCtx(() => [withDirectives(createBaseVNode("div", {
|
|
id: __props.id,
|
|
ref_key: "messageRef",
|
|
ref: messageRef,
|
|
class: normalizeClass([
|
|
unref(ns).b(),
|
|
{ [unref(ns).m(__props.type)]: __props.type },
|
|
unref(ns).is("closable", __props.showClose),
|
|
unref(ns).is("plain", __props.plain),
|
|
unref(ns).is("bottom", verticalProperty.value === "bottom"),
|
|
horizontalClass.value,
|
|
__props.customClass
|
|
]),
|
|
style: normalizeStyle(customStyle.value),
|
|
role: "alert",
|
|
onMouseenter: clearTimer,
|
|
onMouseleave: startTimer
|
|
}, [
|
|
__props.repeatNum > 1 ? (openBlock(), createBlock(unref(ElBadge), {
|
|
key: 0,
|
|
value: __props.repeatNum,
|
|
type: badgeType.value,
|
|
class: normalizeClass(unref(ns).e("badge"))
|
|
}, null, 8, [
|
|
"value",
|
|
"type",
|
|
"class"
|
|
])) : createCommentVNode("v-if", true),
|
|
iconComponent.value ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 1,
|
|
class: normalizeClass([unref(ns).e("icon"), typeClass.value])
|
|
}, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(iconComponent.value)))]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true),
|
|
renderSlot(_ctx.$slots, "default", {}, () => [!__props.dangerouslyUseHTMLString ? (openBlock(), createElementBlock("p", {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("content"))
|
|
}, toDisplayString(__props.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: __props.message
|
|
}, null, 10, _hoisted_244)], 2112))]),
|
|
__props.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"])) : createCommentVNode("v-if", true)
|
|
], 46, _hoisted_183), [[vShow, visible.value]])]),
|
|
_: 3
|
|
}, 8, ["name", "onBeforeLeave"]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/message/src/message2.mjs
|
|
var message_default = message_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// node_modules/element-plus/es/components/message/src/method.mjs
|
|
var seed = 1;
|
|
var normalizeAppendTo = (normalized) => {
|
|
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;
|
|
}
|
|
};
|
|
var normalizePlacement = (normalized) => {
|
|
if (!normalized.placement && isString(messageConfig.placement) && messageConfig.placement)
|
|
normalized.placement = messageConfig.placement;
|
|
if (!normalized.placement)
|
|
normalized.placement = MESSAGE_DEFAULT_PLACEMENT;
|
|
if (!messagePlacement.includes(normalized.placement)) {
|
|
debugWarn("ElMessage", `Invalid placement: ${normalized.placement}. Falling back to '${MESSAGE_DEFAULT_PLACEMENT}'.`);
|
|
normalized.placement = MESSAGE_DEFAULT_PLACEMENT;
|
|
}
|
|
};
|
|
var normalizeOptions = (params) => {
|
|
const options = !params || isString(params) || isVNode(params) || isFunction(params) ? { message: params } : params;
|
|
const normalized = {
|
|
...messageDefaults,
|
|
...options
|
|
};
|
|
normalizeAppendTo(normalized);
|
|
normalizePlacement(normalized);
|
|
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 instances = placementInstances[instance.props.placement || MESSAGE_DEFAULT_PLACEMENT];
|
|
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(message_default, 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 instance = {
|
|
id,
|
|
vnode,
|
|
vm,
|
|
handler: { close: () => {
|
|
vm.exposed.close();
|
|
} },
|
|
props: vnode.component.props
|
|
};
|
|
return instance;
|
|
};
|
|
var message = (options = {}, context) => {
|
|
if (!isClient)
|
|
return { close: () => void 0 };
|
|
const normalized = normalizeOptions(options);
|
|
const instances = getOrCreatePlacementInstances(normalized.placement || MESSAGE_DEFAULT_PLACEMENT);
|
|
if (normalized.grouping && instances.length) {
|
|
const instance2 = instances.find(({ vnode: vm }) => {
|
|
var _a;
|
|
return ((_a = vm.props) == null ? void 0 : _a.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) => {
|
|
return message({
|
|
...normalizeOptions(options),
|
|
type: type4
|
|
}, appContext);
|
|
};
|
|
});
|
|
function closeAll(type4) {
|
|
for (const placement in placementInstances)
|
|
if (hasOwn(placementInstances, placement)) {
|
|
const instances = [...placementInstances[placement]];
|
|
for (const instance of instances)
|
|
if (!type4 || type4 === instance.props.type)
|
|
instance.handler.close();
|
|
}
|
|
}
|
|
function closeAllByPlacement(placement) {
|
|
if (!placementInstances[placement])
|
|
return;
|
|
[...placementInstances[placement]].forEach((instance) => instance.handler.close());
|
|
}
|
|
message.closeAll = closeAll;
|
|
message.closeAllByPlacement = closeAllByPlacement;
|
|
message._context = null;
|
|
|
|
// node_modules/element-plus/es/components/message/index.mjs
|
|
var ElMessage = withInstallFunction(message, "$message");
|
|
|
|
// node_modules/element-plus/es/components/message-box/src/index.vue_vue_type_script_lang.mjs
|
|
var index_vue_vue_type_script_lang_default = defineComponent({
|
|
name: "ElMessageBox",
|
|
directives: { TrapFocus },
|
|
components: {
|
|
ElButton,
|
|
ElFocusTrap: focus_trap_default$1,
|
|
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: 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: "",
|
|
cancelButtonType: "",
|
|
confirmButtonType: "primary",
|
|
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 _a, _b;
|
|
if (val) {
|
|
if (props2.boxType !== "prompt")
|
|
if (state.autofocus)
|
|
focusStartRef.value = (_b = (_a = confirmRef.value) == null ? void 0 : _a.$el) != null ? _b : rootRef.value;
|
|
else
|
|
focusStartRef.value = rootRef.value;
|
|
state.zIndex = nextZIndex();
|
|
}
|
|
if (props2.boxType !== "prompt")
|
|
return;
|
|
if (val)
|
|
nextTick().then(() => {
|
|
var _a2;
|
|
if (inputRef.value && inputRef.value.$el)
|
|
if (state.autofocus)
|
|
focusStartRef.value = (_a2 = getInputElement()) != null ? _a2 : rootRef.value;
|
|
else
|
|
focusStartRef.value = rootRef.value;
|
|
});
|
|
else {
|
|
state.editorErrorMessage = "";
|
|
state.validateError = false;
|
|
}
|
|
});
|
|
const { isDragging: isDragging2 } = useDraggable(rootRef, headerRef, computed(() => props2.draggable), computed(() => props2.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) => {
|
|
var _a;
|
|
if (state.inputType !== "textarea" && !((_a = inputRef.value) == null ? void 0 : _a.isComposing)) {
|
|
e.preventDefault();
|
|
return handleAction("confirm");
|
|
}
|
|
};
|
|
const handleAction = (action) => {
|
|
var _a;
|
|
if (props2.boxType === "prompt" && action === "confirm" && !validate())
|
|
return;
|
|
state.action = action;
|
|
if (state.beforeClose)
|
|
(_a = state.beforeClose) == null ? void 0 : _a.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 _a, _b;
|
|
const inputRefs = (_a = inputRef.value) == null ? void 0 : _a.$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, { ns });
|
|
return {
|
|
...toRefs(state),
|
|
ns,
|
|
overlayEvent,
|
|
visible,
|
|
hasMessage,
|
|
typeClass,
|
|
contentId,
|
|
inputId,
|
|
btnSize,
|
|
iconComponent,
|
|
confirmButtonClasses,
|
|
rootRef,
|
|
focusStartRef,
|
|
headerRef,
|
|
inputRef,
|
|
isDragging: isDragging2,
|
|
confirmRef,
|
|
doClose,
|
|
handleClose,
|
|
onCloseRequested,
|
|
handleWrapperClick,
|
|
handleInputEnter,
|
|
handleAction,
|
|
t
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/message-box/src/index.mjs
|
|
var _hoisted_184 = ["aria-label", "aria-describedby"];
|
|
var _hoisted_245 = ["aria-label"];
|
|
var _hoisted_318 = ["id"];
|
|
function _sfc_render22(_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: _cache[11] || (_cache[11] = ($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: _cache[8] || (_cache[8] = (...args) => _ctx.overlayEvent.onClick && _ctx.overlayEvent.onClick(...args)),
|
|
onMousedown: _cache[9] || (_cache[9] = (...args) => _ctx.overlayEvent.onMousedown && _ctx.overlayEvent.onMousedown(...args)),
|
|
onMouseup: _cache[10] || (_cache[10] = (...args) => _ctx.overlayEvent.onMouseup && _ctx.overlayEvent.onMouseup(...args))
|
|
}, [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.is("dragging", _ctx.isDragging),
|
|
{ [_ctx.ns.m("center")]: _ctx.center }
|
|
]),
|
|
style: normalizeStyle(_ctx.customStyle),
|
|
tabindex: "-1",
|
|
onClick: _cache[7] || (_cache[7] = 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: _cache[0] || (_cache[0] = ($event) => _ctx.handleAction(_ctx.distinguishCancelAndClose ? "close" : "cancel")),
|
|
onKeydown: _cache[1] || (_cache[1] = 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, _hoisted_245)) : 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,
|
|
textContent: toDisplayString(_ctx.message)
|
|
}, null, 8, ["for", "textContent"])) : (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": _cache[2] || (_cache[2] = ($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",
|
|
"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, _hoisted_318),
|
|
createBaseVNode("div", { class: normalizeClass(_ctx.ns.e("btns")) }, [_ctx.showCancelButton ? (openBlock(), createBlock(_component_el_button, {
|
|
key: 0,
|
|
type: _ctx.cancelButtonType === "text" ? "" : _ctx.cancelButtonType,
|
|
text: _ctx.cancelButtonType === "text",
|
|
loading: _ctx.cancelButtonLoading,
|
|
"loading-icon": _ctx.cancelButtonLoadingIcon,
|
|
class: normalizeClass([_ctx.cancelButtonClass]),
|
|
round: _ctx.roundButton,
|
|
size: _ctx.btnSize,
|
|
onClick: _cache[3] || (_cache[3] = ($event) => _ctx.handleAction("cancel")),
|
|
onKeydown: _cache[4] || (_cache[4] = withKeys(withModifiers(($event) => _ctx.handleAction("cancel"), ["prevent"]), ["enter"]))
|
|
}, {
|
|
default: withCtx(() => [createTextVNode(toDisplayString(_ctx.cancelButtonText || _ctx.t("el.messagebox.cancel")), 1)]),
|
|
_: 1
|
|
}, 8, [
|
|
"type",
|
|
"text",
|
|
"loading",
|
|
"loading-icon",
|
|
"class",
|
|
"round",
|
|
"size"
|
|
])) : createCommentVNode("v-if", true), withDirectives(createVNode(_component_el_button, {
|
|
ref: "confirmRef",
|
|
type: _ctx.confirmButtonType === "text" ? "" : _ctx.confirmButtonType,
|
|
text: _ctx.confirmButtonType === "text",
|
|
loading: _ctx.confirmButtonLoading,
|
|
"loading-icon": _ctx.confirmButtonLoadingIcon,
|
|
class: normalizeClass([_ctx.confirmButtonClasses]),
|
|
round: _ctx.roundButton,
|
|
disabled: _ctx.confirmButtonDisabled,
|
|
size: _ctx.btnSize,
|
|
onClick: _cache[5] || (_cache[5] = ($event) => _ctx.handleAction("confirm")),
|
|
onKeydown: _cache[6] || (_cache[6] = withKeys(withModifiers(($event) => _ctx.handleAction("confirm"), ["prevent"]), ["enter"]))
|
|
}, {
|
|
default: withCtx(() => [createTextVNode(toDisplayString(_ctx.confirmButtonText || _ctx.t("el.messagebox.confirm")), 1)]),
|
|
_: 1
|
|
}, 8, [
|
|
"type",
|
|
"text",
|
|
"loading",
|
|
"loading-icon",
|
|
"class",
|
|
"round",
|
|
"disabled",
|
|
"size"
|
|
]), [[vShow, _ctx.showConfirmButton]])], 2)
|
|
], 6)]),
|
|
_: 3
|
|
}, 8, [
|
|
"trapped",
|
|
"focus-trap-el",
|
|
"focus-start-el",
|
|
"onReleaseRequested"
|
|
])], 42, _hoisted_184)]),
|
|
_: 3
|
|
}, 8, [
|
|
"z-index",
|
|
"overlay-class",
|
|
"mask"
|
|
]), [[vShow, _ctx.visible]])]),
|
|
_: 3
|
|
});
|
|
}
|
|
var src_default2 = _plugin_vue_export_helper_default(index_vue_vue_type_script_lang_default, [["render", _sfc_render22]]);
|
|
|
|
// node_modules/element-plus/es/components/message-box/src/messageBox.mjs
|
|
var messageInstance = /* @__PURE__ */ 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(src_default2, 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/notification.vue_vue_type_script_setup_true_lang.mjs
|
|
var _hoisted_185 = ["id"];
|
|
var _hoisted_246 = ["textContent"];
|
|
var _hoisted_319 = { key: 0 };
|
|
var _hoisted_413 = ["innerHTML"];
|
|
var notification_vue_vue_type_script_setup_true_lang_default = defineComponent({
|
|
name: "ElNotification",
|
|
__name: "notification",
|
|
props: notificationProps,
|
|
emits: notificationEmits,
|
|
setup(__props, { expose: __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 _a;
|
|
return {
|
|
[verticalProperty.value]: `${props2.offset}px`,
|
|
zIndex: (_a = props2.zIndex) != null ? _a : 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(event) {
|
|
switch (getEventCode(event)) {
|
|
case EVENT_CODE.delete:
|
|
case EVENT_CODE.backspace:
|
|
clearTimer();
|
|
break;
|
|
case EVENT_CODE.esc:
|
|
if (visible.value)
|
|
close2();
|
|
break;
|
|
default:
|
|
startTimer();
|
|
break;
|
|
}
|
|
}
|
|
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: __props.onClose,
|
|
onAfterLeave: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("destroy")),
|
|
persisted: ""
|
|
}, {
|
|
default: withCtx(() => [withDirectives(createBaseVNode("div", {
|
|
id: __props.id,
|
|
class: normalizeClass([
|
|
unref(ns).b(),
|
|
__props.customClass,
|
|
horizontalClass.value
|
|
]),
|
|
style: normalizeStyle(positionStyle.value),
|
|
role: "alert",
|
|
onMouseenter: clearTimer,
|
|
onMouseleave: startTimer,
|
|
onClick: _cache[0] || (_cache[0] = (...args) => __props.onClick && __props.onClick(...args))
|
|
}, [iconComponent.value ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass([unref(ns).e("icon"), typeClass.value])
|
|
}, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(iconComponent.value)))]),
|
|
_: 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(__props.title)
|
|
}, null, 10, _hoisted_246),
|
|
withDirectives(createBaseVNode("div", {
|
|
class: normalizeClass(unref(ns).e("content")),
|
|
style: normalizeStyle(!!__props.title ? void 0 : { margin: 0 })
|
|
}, [renderSlot(_ctx.$slots, "default", {}, () => [!__props.dangerouslyUseHTMLString ? (openBlock(), createElementBlock("p", _hoisted_319, toDisplayString(__props.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: __props.message }, null, 8, _hoisted_413)], 2112))])], 6), [[vShow, __props.message]]),
|
|
__props.showClose ? (openBlock(), createBlock(unref(ElIcon), {
|
|
key: 0,
|
|
class: normalizeClass(unref(ns).e("closeBtn")),
|
|
onClick: withModifiers(close2, ["stop"])
|
|
}, {
|
|
default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(__props.closeIcon)))]),
|
|
_: 1
|
|
}, 8, ["class"])) : createCommentVNode("v-if", true)
|
|
], 2)], 46, _hoisted_185), [[vShow, visible.value]])]),
|
|
_: 3
|
|
}, 8, ["name", "onBeforeLeave"]);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/element-plus/es/components/notification/src/notification2.mjs
|
|
var notification_default = notification_vue_vue_type_script_setup_true_lang_default;
|
|
|
|
// 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 _a;
|
|
verticalOffset += (((_a = vm2.el) == null ? void 0 : _a.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(notification_default, 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 _a;
|
|
return ((_a = vm2.component) == null ? void 0 : _a.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;
|
|
});
|
|
}
|
|
function updateOffsets(position = "top-right") {
|
|
var _a, _b, _c, _d;
|
|
let verticalOffset = ((_c = (_b = (_a = notifications[position][0]) == null ? void 0 : _a.vm.component) == null ? void 0 : _b.props) == null ? void 0 : _c.offset) || 0;
|
|
for (const { vm } of notifications[position]) {
|
|
vm.component.props.offset = verticalOffset;
|
|
verticalOffset += (((_d = vm.el) == null ? void 0 : _d.offsetHeight) || 0) + GAP_SIZE;
|
|
}
|
|
}
|
|
notify.closeAll = closeAll2;
|
|
notify.updateOffsets = updateOffsets;
|
|
notify._context = null;
|
|
|
|
// node_modules/element-plus/es/components/notification/index.mjs
|
|
var ElNotification = withInstallFunction(notify, "$notify");
|
|
|
|
// node_modules/element-plus/es/component.mjs
|
|
var component_default = [
|
|
ElAffix,
|
|
ElAlert,
|
|
ElAutocomplete,
|
|
ElAutoResizer,
|
|
ElAvatar,
|
|
ElAvatarGroup,
|
|
ElBacktop,
|
|
ElBadge,
|
|
ElBreadcrumb,
|
|
ElBreadcrumbItem,
|
|
ElButton,
|
|
ElButtonGroup,
|
|
ElCalendar,
|
|
ElCard,
|
|
ElCarousel,
|
|
ElCarouselItem,
|
|
ElCascader,
|
|
ElCascaderPanel,
|
|
ElCheckTag,
|
|
ElCheckbox,
|
|
ElCheckboxButton,
|
|
ElCheckboxGroup,
|
|
ElCol,
|
|
ElCollapse,
|
|
ElCollapseItem,
|
|
ElCollapseTransition,
|
|
ElColorPickerPanel,
|
|
ElColorPicker,
|
|
ElConfigProvider,
|
|
ElContainer,
|
|
ElAside,
|
|
ElFooter,
|
|
ElHeader,
|
|
ElMain,
|
|
ElDatePicker,
|
|
ElDatePickerPanel,
|
|
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,
|
|
ElTableColumn,
|
|
ElTableV2,
|
|
ElTabs,
|
|
ElTabPane,
|
|
ElTag,
|
|
ElText,
|
|
ElTimePicker,
|
|
ElTimeSelect,
|
|
ElTimeline,
|
|
ElTimelineItem,
|
|
ElTooltip,
|
|
ElTransfer,
|
|
ElTree,
|
|
ElTreeSelect,
|
|
ElTreeV2,
|
|
ElUpload,
|
|
ElWatermark,
|
|
ElTour,
|
|
ElTourStep,
|
|
ElAnchor,
|
|
ElAnchorLink,
|
|
ElSegmented,
|
|
ElMention,
|
|
ElSplitter,
|
|
ElSplitterPanel
|
|
];
|
|
|
|
// node_modules/element-plus/es/plugin.mjs
|
|
var plugin_default = [
|
|
ElInfiniteScroll,
|
|
ElLoading,
|
|
ElMessage,
|
|
ElMessageBox,
|
|
ElNotification,
|
|
ElPopoverDirective
|
|
];
|
|
|
|
// node_modules/element-plus/es/defaults.mjs
|
|
var defaults_default4 = makeInstaller([...component_default, ...plugin_default]);
|
|
|
|
// node_modules/element-plus/es/index.mjs
|
|
var import_dayjs20 = __toESM(require_dayjs_min(), 1);
|
|
var install = defaults_default4.install;
|
|
var version2 = defaults_default4.version;
|
|
var element_plus_default = defaults_default4;
|
|
|
|
// dep:element-plus
|
|
var element_plus_default2 = element_plus_default;
|
|
var export_dayjs = import_dayjs20.default;
|
|
export {
|
|
BAR_MAP,
|
|
BORDER_HORIZONTAL_WIDTH,
|
|
CAROUSEL_ITEM_NAME,
|
|
CASCADER_PANEL_INJECTION_KEY,
|
|
CHANGE_EVENT,
|
|
ClickOutside,
|
|
picker_default as CommonPicker,
|
|
CommonProps,
|
|
DEFAULT_DIALOG_TRANSITION,
|
|
DEFAULT_EMPTY_VALUES,
|
|
DEFAULT_FORMATS_DATE,
|
|
DEFAULT_FORMATS_DATEPICKER,
|
|
DEFAULT_FORMATS_TIME,
|
|
DEFAULT_STEP,
|
|
DEFAULT_VALUE_ON_CLEAR,
|
|
DROPDOWN_INJECTION_KEY,
|
|
DROPDOWN_INSTANCE_INJECTION_KEY,
|
|
DefaultProps,
|
|
DynamicSizeGrid,
|
|
DynamicSizeList,
|
|
EVENT_CODE,
|
|
Effect,
|
|
ElAffix,
|
|
ElAlert,
|
|
ElAnchor,
|
|
ElAnchorLink,
|
|
ElAside,
|
|
ElAutoResizer,
|
|
ElAutocomplete,
|
|
ElAvatar,
|
|
ElAvatarGroup,
|
|
ElBacktop,
|
|
ElBadge,
|
|
ElBreadcrumb,
|
|
ElBreadcrumbItem,
|
|
ElButton,
|
|
ElButtonGroup,
|
|
ElCalendar,
|
|
ElCard,
|
|
ElCarousel,
|
|
ElCarouselItem,
|
|
ElCascader,
|
|
ElCascaderPanel,
|
|
ElCheckTag,
|
|
ElCheckbox,
|
|
ElCheckboxButton,
|
|
ElCheckboxGroup,
|
|
ElCol,
|
|
ElCollapse,
|
|
ElCollapseItem,
|
|
ElCollapseTransition,
|
|
ElColorPicker,
|
|
ElColorPickerPanel,
|
|
ElConfigProvider,
|
|
ElContainer,
|
|
ElCountdown,
|
|
ElDatePicker,
|
|
ElDatePickerPanel,
|
|
ElDescriptions,
|
|
ElDescriptionsItem,
|
|
ElDialog,
|
|
ElDivider,
|
|
ElDrawer,
|
|
ElDropdown,
|
|
ElDropdownItem,
|
|
ElDropdownMenu,
|
|
ElEmpty,
|
|
ElFooter,
|
|
ElForm,
|
|
ElFormItem,
|
|
ElHeader,
|
|
ElIcon,
|
|
ElImage,
|
|
ElImageViewer,
|
|
ElInfiniteScroll,
|
|
ElInput,
|
|
ElInputNumber,
|
|
ElInputTag,
|
|
ElLink,
|
|
ElLoading,
|
|
vLoading as ElLoadingDirective,
|
|
Loading as ElLoadingService,
|
|
ElMain,
|
|
ElMention,
|
|
ElMenu,
|
|
ElMenuItem,
|
|
ElMenuItemGroup,
|
|
ElMessage,
|
|
ElMessageBox,
|
|
ElNotification,
|
|
ElOption,
|
|
ElOptionGroup,
|
|
ElOverlay,
|
|
ElPageHeader,
|
|
ElPagination,
|
|
ElPopconfirm,
|
|
ElPopover,
|
|
ElPopoverDirective,
|
|
ElPopper,
|
|
arrow_default as ElPopperArrow,
|
|
content_default as ElPopperContent,
|
|
trigger_default as ElPopperTrigger,
|
|
ElProgress,
|
|
ElRadio,
|
|
ElRadioButton,
|
|
ElRadioGroup,
|
|
ElRate,
|
|
ElResult,
|
|
ElRow,
|
|
ElScrollbar,
|
|
ElSegmented,
|
|
ElSelect,
|
|
ElSelectV2,
|
|
ElSkeleton,
|
|
ElSkeletonItem,
|
|
ElSlider,
|
|
ElSpace,
|
|
ElSplitter,
|
|
ElSplitterPanel,
|
|
ElStatistic,
|
|
ElStep,
|
|
ElSteps,
|
|
ElSubMenu,
|
|
ElSwitch,
|
|
ElTabPane,
|
|
ElTable,
|
|
ElTableColumn,
|
|
ElTableV2,
|
|
ElTabs,
|
|
ElTag,
|
|
ElText,
|
|
ElTimePicker,
|
|
ElTimeSelect,
|
|
ElTimeline,
|
|
ElTimelineItem,
|
|
ElTooltip,
|
|
ElTour,
|
|
ElTourStep,
|
|
ElTransfer,
|
|
ElTree,
|
|
ElTreeSelect,
|
|
ElTreeV2,
|
|
ElUpload,
|
|
ElWatermark,
|
|
FIRST_KEYS,
|
|
FIRST_LAST_KEYS,
|
|
FORWARD_REF_INJECTION_KEY,
|
|
FixedSizeGrid,
|
|
FixedSizeList,
|
|
GAP,
|
|
ID_INJECTION_KEY,
|
|
INPUT_EVENT,
|
|
INSTALLED_KEY,
|
|
IconComponentMap,
|
|
IconMap,
|
|
LAST_KEYS,
|
|
LEFT_CHECK_CHANGE_EVENT,
|
|
MENU_INJECTION_KEY,
|
|
MESSAGE_DEFAULT_PLACEMENT,
|
|
MINIMUM_INPUT_WIDTH,
|
|
Mousewheel,
|
|
NODE_INSTANCE_INJECTION_KEY,
|
|
PICKER_BASE_INJECTION_KEY,
|
|
PICKER_POPPER_OPTIONS_INJECTION_KEY,
|
|
POPPER_CONTENT_INJECTION_KEY,
|
|
POPPER_INJECTION_KEY,
|
|
RIGHT_CHECK_CHANGE_EVENT,
|
|
ROOT_COMMON_COLOR_INJECTION_KEY,
|
|
ROOT_COMMON_PICKER_INJECTION_KEY,
|
|
ROOT_PICKER_INJECTION_KEY,
|
|
ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY,
|
|
ROOT_TREE_INJECTION_KEY,
|
|
RowAlign,
|
|
RowJustify,
|
|
SCOPE5 as SCOPE,
|
|
SIZE_INJECTION_KEY,
|
|
STEPS_INJECTION_KEY,
|
|
SUB_MENU_INJECTION_KEY,
|
|
TIMELINE_INJECTION_KEY,
|
|
TOOLTIP_INJECTION_KEY,
|
|
TREE_NODE_MAP_INJECTION_KEY,
|
|
TableV2,
|
|
Alignment as TableV2Alignment,
|
|
FixedDir as TableV2FixedDir,
|
|
placeholderSign as TableV2Placeholder,
|
|
SortOrder as TableV2SortOrder,
|
|
panel_time_pick_default as TimePickPanel,
|
|
TrapFocus,
|
|
UPDATE_MODEL_EVENT,
|
|
WEEK_DAYS,
|
|
ZINDEX_INJECTION_KEY,
|
|
affixEmits,
|
|
affixProps,
|
|
alertEffects,
|
|
alertEmits,
|
|
alertProps,
|
|
anchorEmits,
|
|
anchorProps,
|
|
ariaProps,
|
|
arrowMiddleware,
|
|
autoResizerProps,
|
|
autocompleteEmits,
|
|
autocompleteProps,
|
|
avatarEmits,
|
|
avatarGroupContextKey,
|
|
avatarGroupProps,
|
|
avatarProps,
|
|
backtopEmits,
|
|
backtopProps,
|
|
badgeProps,
|
|
breadcrumbItemProps,
|
|
breadcrumbKey,
|
|
breadcrumbProps,
|
|
buildLocaleContext,
|
|
buildTimeList,
|
|
buildTranslator,
|
|
buttonEmits,
|
|
buttonGroupContextKey,
|
|
buttonNativeTypes,
|
|
buttonProps,
|
|
buttonTypes,
|
|
calendarEmits,
|
|
calendarProps,
|
|
cardContextKey,
|
|
cardProps,
|
|
carouselContextKey,
|
|
carouselEmits,
|
|
carouselItemProps,
|
|
carouselProps,
|
|
cascaderEmits,
|
|
cascaderPanelEmits,
|
|
cascaderPanelProps,
|
|
cascaderProps,
|
|
checkTagEmits,
|
|
checkTagProps,
|
|
checkboxDefaultProps,
|
|
checkboxEmits,
|
|
checkboxGroupContextKey,
|
|
checkboxGroupEmits,
|
|
checkboxGroupProps,
|
|
checkboxProps,
|
|
checkboxPropsDefaults,
|
|
colProps,
|
|
collapseContextKey,
|
|
collapseEmits,
|
|
collapseItemProps,
|
|
collapseProps,
|
|
colorPickerEmits,
|
|
colorPickerPanelContextKey,
|
|
colorPickerPanelEmits,
|
|
colorPickerPanelProps,
|
|
colorPickerProps,
|
|
colorPickerPropsDefaults,
|
|
columnAlignment,
|
|
componentSizeMap,
|
|
componentSizes,
|
|
configProviderContextKey,
|
|
configProviderProps,
|
|
countdownEmits,
|
|
countdownProps,
|
|
createModelToggleComposable,
|
|
dateEquals,
|
|
datePickTypes,
|
|
datePickerPanelProps,
|
|
datePickerProps,
|
|
dayOrDaysToDate,
|
|
export_dayjs as dayjs,
|
|
element_plus_default2 as default,
|
|
defaultInitialZIndex,
|
|
defaultNamespace,
|
|
defaultProps3 as defaultProps,
|
|
descriptionItemProps,
|
|
descriptionProps,
|
|
dialogContextKey,
|
|
dialogEmits,
|
|
dialogInjectionKey,
|
|
dialogProps,
|
|
dialogPropsDefaults,
|
|
dividerProps,
|
|
drawerEmits,
|
|
drawerProps,
|
|
dropdownItemProps,
|
|
dropdownMenuProps,
|
|
dropdownProps,
|
|
elPaginationKey,
|
|
emitChangeFn3 as emitChangeFn,
|
|
emptyProps,
|
|
emptyValuesContextKey,
|
|
extractDateFormat,
|
|
extractTimeFormat,
|
|
formContextKey,
|
|
formEmits,
|
|
formItemContextKey,
|
|
formItemProps,
|
|
formItemValidateStates,
|
|
formMetaProps,
|
|
formProps,
|
|
formatter,
|
|
genFileId,
|
|
getPositionDataWithUnit,
|
|
iconProps,
|
|
imageEmits,
|
|
imageProps,
|
|
imageViewerEmits,
|
|
imageViewerProps,
|
|
inputEmits,
|
|
inputNumberEmits,
|
|
inputNumberProps,
|
|
inputProps,
|
|
inputPropsDefaults,
|
|
inputTagEmits,
|
|
inputTagProps,
|
|
install,
|
|
linkEmits,
|
|
linkProps,
|
|
localeContextKey,
|
|
makeInstaller,
|
|
makeList,
|
|
mentionDefaultProps,
|
|
mentionEmits,
|
|
mentionProps,
|
|
menuEmits,
|
|
menuItemEmits,
|
|
menuItemGroupProps,
|
|
menuItemProps,
|
|
menuProps,
|
|
messageConfig,
|
|
messageDefaults,
|
|
messageEmits,
|
|
messagePlacement,
|
|
messageProps,
|
|
messageTypes,
|
|
namespaceContextKey,
|
|
notificationEmits,
|
|
notificationProps,
|
|
notificationTypes,
|
|
overlayEmits,
|
|
overlayProps,
|
|
pageHeaderEmits,
|
|
pageHeaderProps,
|
|
paginationEmits,
|
|
paginationProps,
|
|
parseDate,
|
|
popconfirmEmits,
|
|
popconfirmProps,
|
|
popoverEmits,
|
|
popoverProps,
|
|
popoverPropsDefaults,
|
|
popperArrowProps,
|
|
popperArrowPropsDefaults,
|
|
popperContentEmits,
|
|
popperContentProps,
|
|
popperContentPropsDefaults,
|
|
popperCoreConfigProps,
|
|
popperCoreConfigPropsDefaults,
|
|
popperProps,
|
|
popperTriggerProps,
|
|
progressProps,
|
|
provideGlobalConfig,
|
|
radioButtonProps,
|
|
radioButtonPropsDefaults,
|
|
radioDefaultProps,
|
|
radioEmits,
|
|
radioGroupEmits,
|
|
radioGroupKey,
|
|
radioGroupProps,
|
|
radioGroupPropsDefaults,
|
|
radioProps,
|
|
radioPropsBase,
|
|
radioPropsDefaults,
|
|
rangeArr,
|
|
rateEmits,
|
|
rateProps,
|
|
renderThumbStyle,
|
|
resultProps,
|
|
roleTypes,
|
|
rowContextKey,
|
|
rowProps,
|
|
scrollbarContextKey,
|
|
scrollbarEmits,
|
|
scrollbarProps,
|
|
segmentedEmits,
|
|
segmentedProps,
|
|
selectEmits,
|
|
selectGroupKey,
|
|
selectKey,
|
|
selectProps,
|
|
selectV2InjectionKey,
|
|
skeletonItemProps,
|
|
skeletonProps,
|
|
sliderContextKey,
|
|
sliderEmits,
|
|
sliderProps,
|
|
spaceItemProps,
|
|
spaceProps,
|
|
splitterEmits,
|
|
splitterPanelEmits,
|
|
splitterPanelProps,
|
|
splitterProps,
|
|
statisticProps,
|
|
stepProps,
|
|
stepsEmits,
|
|
stepsProps,
|
|
subMenuProps,
|
|
switchEmits,
|
|
switchProps,
|
|
tabBarProps,
|
|
tabNavEmits,
|
|
tabNavProps,
|
|
tabPaneProps,
|
|
tableV2Props,
|
|
tableV2RowProps,
|
|
tabsEmits,
|
|
tabsProps,
|
|
tabsRootContextKey,
|
|
tagEmits,
|
|
tagProps,
|
|
textProps,
|
|
thumbProps,
|
|
timePickerDefaultProps,
|
|
timePickerRangeTriggerProps,
|
|
timePickerRngeTriggerProps,
|
|
timeSelectProps,
|
|
timeUnits,
|
|
timelineItemProps,
|
|
timelineProps,
|
|
tooltipEmits,
|
|
tourContentEmits,
|
|
tourContentProps,
|
|
tourEmits,
|
|
tourPlacements,
|
|
tourProps,
|
|
tourStepEmits,
|
|
tourStepProps,
|
|
tourStrategies,
|
|
transferCheckedChangeFn,
|
|
transferEmits,
|
|
transferProps,
|
|
translate,
|
|
treeEmits,
|
|
treeProps,
|
|
uploadBaseProps,
|
|
uploadBasePropsDefaults,
|
|
uploadContentProps,
|
|
uploadContentPropsDefaults,
|
|
uploadContextKey,
|
|
uploadDraggerEmits,
|
|
uploadDraggerProps,
|
|
uploadListEmits,
|
|
uploadListProps,
|
|
uploadListTypes,
|
|
uploadProps,
|
|
uploadPropsDefaults,
|
|
useAriaProps,
|
|
useAttrs2 as useAttrs,
|
|
useCalcInputWidth,
|
|
useCascaderConfig,
|
|
useComposition,
|
|
useCursor,
|
|
useDelayedRender,
|
|
useDelayedToggle,
|
|
useDelayedToggleProps,
|
|
useDelayedTogglePropsDefaults,
|
|
useDeprecated,
|
|
useDialog,
|
|
useDisabled,
|
|
useDraggable,
|
|
useEmptyValues,
|
|
useEmptyValuesProps,
|
|
useEscapeKeydown,
|
|
useFloating,
|
|
useFloatingProps,
|
|
useFocus,
|
|
useFocusController,
|
|
useFormDisabled,
|
|
useFormItem,
|
|
useFormItemInputId,
|
|
useFormSize,
|
|
useForwardRef,
|
|
useForwardRefDirective,
|
|
useGetDerivedNamespace,
|
|
useGlobalComponentSettings,
|
|
useGlobalConfig,
|
|
useGlobalSize,
|
|
useId,
|
|
useIdInjection,
|
|
useLocale,
|
|
useLockscreen,
|
|
useModal,
|
|
useModelToggle,
|
|
useModelToggleEmits,
|
|
useModelToggleProps,
|
|
useNamespace,
|
|
useOrderedChildren,
|
|
usePopper,
|
|
usePopperArrowProps,
|
|
usePopperContainer,
|
|
usePopperContainerId,
|
|
usePopperContentEmits,
|
|
usePopperContentProps,
|
|
usePopperCoreConfigProps,
|
|
usePopperProps,
|
|
usePopperTriggerProps,
|
|
usePreventGlobal,
|
|
useProp,
|
|
useSameTarget,
|
|
useSize,
|
|
useSizeProp,
|
|
useSizeProps,
|
|
useSpace,
|
|
useTeleport,
|
|
useThrottleRender,
|
|
useTimeout,
|
|
useTooltipContentProps,
|
|
useTooltipContentPropsDefaults,
|
|
useTooltipModelToggle,
|
|
useTooltipModelToggleEmits,
|
|
useTooltipModelToggleProps,
|
|
useTooltipProps,
|
|
useTooltipTriggerProps,
|
|
useTooltipTriggerPropsDefaults,
|
|
useTransitionFallthrough,
|
|
useTransitionFallthroughEmits,
|
|
useZIndex,
|
|
vLoading,
|
|
vRepeatClick,
|
|
valueEquals,
|
|
version2 as version,
|
|
virtualizedGridProps,
|
|
virtualizedListProps,
|
|
virtualizedProps,
|
|
virtualizedScrollbarProps,
|
|
watermarkProps,
|
|
zIndexContextKey
|
|
};
|
|
/**
|
|
* @license
|
|
* Lodash (Custom Build) <https://lodash.com/>
|
|
* Build: `lodash modularize exports="es" --repo lodash/lodash#4.18.1 -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=element-plus.js.map
|