@flux-ui/components 3.0.0-next.72 → 3.0.0-next.73
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/component/FluxFormField.vue.d.ts +2 -2
- package/dist/index.css +303 -303
- package/dist/index.js +1119 -1082
- package/dist/index.js.map +1 -1
- package/dist/util/index.d.ts +1 -0
- package/dist/util/sanitizeUrl.d.ts +7 -0
- package/package.json +3 -3
- package/src/component/FluxColorPicker.vue +1 -1
- package/src/component/FluxFormField.vue +4 -2
- package/src/component/FluxKanbanColumn.vue +1 -1
- package/src/component/FluxPressable.vue +14 -5
- package/src/component/primitive/DialogLayout.vue +3 -3
- package/src/util/index.ts +1 -0
- package/src/util/sanitizeUrl.ts +40 -0
package/dist/index.js
CHANGED
|
@@ -7204,7 +7204,7 @@ function ye$1(e, t, n) {
|
|
|
7204
7204
|
onScopeDispose(o);
|
|
7205
7205
|
}
|
|
7206
7206
|
//#endregion
|
|
7207
|
-
//#region ../internals/dist/composable-
|
|
7207
|
+
//#region ../internals/dist/composable-BLswOqxr.js
|
|
7208
7208
|
function _$1(e, t) {
|
|
7209
7209
|
let n = ref(!1), r = ref(e), i = computed(() => {
|
|
7210
7210
|
let e = [], t = unref(r).month, n = unref(r).startOf(`month`);
|
|
@@ -7410,11 +7410,13 @@ function O$1(t, n = {}) {
|
|
|
7410
7410
|
function k$1(e, t) {
|
|
7411
7411
|
let n = `flux/${e}`, r = ref(i() ?? t);
|
|
7412
7412
|
function i() {
|
|
7413
|
-
if (n in localStorage)
|
|
7413
|
+
if (!(n in localStorage)) return null;
|
|
7414
|
+
try {
|
|
7414
7415
|
let e = JSON.parse(localStorage.getItem(n));
|
|
7415
7416
|
return Array.isArray(e) && e[0] === `DateTime` && (e = DateTime.fromISO(e[1])), e;
|
|
7417
|
+
} catch {
|
|
7418
|
+
return null;
|
|
7416
7419
|
}
|
|
7417
|
-
return null;
|
|
7418
7420
|
}
|
|
7419
7421
|
return watch(r, (e) => {
|
|
7420
7422
|
let t = e;
|
|
@@ -7691,818 +7693,442 @@ var FluxIcon_default = /* @__PURE__ */ defineComponent({
|
|
|
7691
7693
|
};
|
|
7692
7694
|
}
|
|
7693
7695
|
});
|
|
7694
|
-
|
|
7695
|
-
|
|
7696
|
-
|
|
7697
|
-
|
|
7698
|
-
|
|
7699
|
-
|
|
7700
|
-
|
|
7701
|
-
|
|
7702
|
-
|
|
7703
|
-
|
|
7704
|
-
|
|
7705
|
-
|
|
7706
|
-
|
|
7707
|
-
|
|
7708
|
-
|
|
7709
|
-
|
|
7710
|
-
|
|
7711
|
-
|
|
7712
|
-
|
|
7713
|
-
|
|
7714
|
-
|
|
7715
|
-
|
|
7716
|
-
|
|
7717
|
-
|
|
7718
|
-
const emit = __emit;
|
|
7719
|
-
const hoverListeners = {
|
|
7720
|
-
onMouseenter: (evt) => emit("mouseenter", evt),
|
|
7721
|
-
onMouseleave: (evt) => emit("mouseleave", evt)
|
|
7722
|
-
};
|
|
7723
|
-
function onClick(evt, navigate) {
|
|
7724
|
-
emit("click", evt);
|
|
7725
|
-
if (evt.defaultPrevented) return;
|
|
7726
|
-
navigate?.(evt);
|
|
7727
|
-
}
|
|
7728
|
-
return (_ctx, _cache) => {
|
|
7729
|
-
const _component_router_link = resolveComponent("router-link");
|
|
7730
|
-
return __props.componentType === "route" ? (openBlock(), createBlock(_component_router_link, mergeProps({ key: 0 }, $attrs, toHandlers(hoverListeners), {
|
|
7731
|
-
rel: __props.rel,
|
|
7732
|
-
target: __props.target,
|
|
7733
|
-
to: __props.to,
|
|
7734
|
-
onClick: _cache[0] || (_cache[0] = ($event) => onClick($event))
|
|
7735
|
-
}), {
|
|
7736
|
-
default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
|
|
7737
|
-
_: 3
|
|
7738
|
-
}, 16, [
|
|
7739
|
-
"rel",
|
|
7740
|
-
"target",
|
|
7741
|
-
"to"
|
|
7742
|
-
])) : __props.componentType === "link" ? (openBlock(), createElementBlock("a", mergeProps({ key: 1 }, $attrs, toHandlers(hoverListeners, true), {
|
|
7743
|
-
href: __props.href,
|
|
7744
|
-
rel: __props.rel,
|
|
7745
|
-
target: __props.target,
|
|
7746
|
-
onClick: _cache[1] || (_cache[1] = ($event) => onClick($event))
|
|
7747
|
-
}), [renderSlot(_ctx.$slots, "default")], 16, _hoisted_1$61)) : __props.componentType === "button" ? (openBlock(), createElementBlock("button", mergeProps({ key: 2 }, $attrs, toHandlers(hoverListeners, true), { onClick: _cache[2] || (_cache[2] = ($event) => onClick($event)) }), [renderSlot(_ctx.$slots, "default")], 16)) : (openBlock(), createElementBlock("div", mergeProps({ key: 3 }, $attrs, toHandlers(hoverListeners, true), { onClick }), [renderSlot(_ctx.$slots, "default")], 16));
|
|
7748
|
-
};
|
|
7749
|
-
}
|
|
7750
|
-
});
|
|
7751
|
-
var Spinner_module_default = {
|
|
7752
|
-
spinner: `spinner`,
|
|
7753
|
-
spinnerTrack: `spinner-track`,
|
|
7754
|
-
spinnerEffect: `spinner-effect`,
|
|
7755
|
-
spinnerValue: `spinner-value`
|
|
7696
|
+
var Overlay_module_default = {
|
|
7697
|
+
overlayView: `overlay-view`,
|
|
7698
|
+
overlayProvider: `overlay-provider overlay-view`,
|
|
7699
|
+
overlayShade: `overlay-shade overlay-view`,
|
|
7700
|
+
overlay: `overlay`,
|
|
7701
|
+
overlayTransitionLeaveActive: `overlay-transition-leave-active`,
|
|
7702
|
+
slideOverTransitionLeaveActive: `slide-over-transition-leave-active`,
|
|
7703
|
+
basePaneStructure: `base-pane-structure`,
|
|
7704
|
+
paneFooter: `pane-footer`,
|
|
7705
|
+
isCurrent: `is-current`,
|
|
7706
|
+
overlaySmall: `overlay-small overlay`,
|
|
7707
|
+
overlayMedium: `overlay-medium overlay`,
|
|
7708
|
+
overlayLarge: `overlay-large overlay`,
|
|
7709
|
+
slideOver: `slide-over overlay`,
|
|
7710
|
+
paneHeader: `pane-header`,
|
|
7711
|
+
tabs: `tabs`,
|
|
7712
|
+
tabBarDefault: `tab-bar-default`,
|
|
7713
|
+
paneHeaderCaption: `pane-header-caption`,
|
|
7714
|
+
overlayTransitionEnterActive: `overlay-transition-enter-active`,
|
|
7715
|
+
overlayTransitionEnterFrom: `overlay-transition-enter-from`,
|
|
7716
|
+
overlayTransitionLeaveTo: `overlay-transition-leave-to`,
|
|
7717
|
+
slideOverTransitionEnterActive: `slide-over-transition-enter-active`,
|
|
7718
|
+
slideOverTransitionEnterFrom: `slide-over-transition-enter-from`,
|
|
7719
|
+
slideOverTransitionLeaveTo: `slide-over-transition-leave-to`
|
|
7756
7720
|
};
|
|
7757
7721
|
//#endregion
|
|
7758
|
-
//#region src/
|
|
7759
|
-
var
|
|
7760
|
-
|
|
7761
|
-
|
|
7762
|
-
|
|
7763
|
-
|
|
7764
|
-
|
|
7765
|
-
|
|
7766
|
-
|
|
7767
|
-
|
|
7768
|
-
|
|
7769
|
-
|
|
7770
|
-
|
|
7771
|
-
|
|
7772
|
-
|
|
7773
|
-
|
|
7774
|
-
|
|
7775
|
-
|
|
7776
|
-
|
|
7777
|
-
|
|
7778
|
-
|
|
7779
|
-
|
|
7780
|
-
cy: "12",
|
|
7781
|
-
r: "10",
|
|
7782
|
-
fill: "transparent",
|
|
7783
|
-
"stroke-width": "4",
|
|
7784
|
-
"stroke-dasharray": "21 45",
|
|
7785
|
-
"stroke-dashoffset": "30",
|
|
7786
|
-
"stroke-linecap": "round"
|
|
7787
|
-
}, null, 2),
|
|
7788
|
-
createElementVNode("circle", {
|
|
7789
|
-
class: normalizeClass(unref(Spinner_module_default).spinnerValue),
|
|
7790
|
-
cx: "12",
|
|
7791
|
-
cy: "12",
|
|
7792
|
-
r: "10",
|
|
7793
|
-
fill: "transparent",
|
|
7794
|
-
"stroke-width": "4",
|
|
7795
|
-
"stroke-dasharray": "21 45",
|
|
7796
|
-
"stroke-dashoffset": "30",
|
|
7797
|
-
"stroke-linecap": "round"
|
|
7798
|
-
}, null, 2)
|
|
7799
|
-
], 6);
|
|
7800
|
-
};
|
|
7722
|
+
//#region src/util/createDialogRenderer.ts
|
|
7723
|
+
var TARGET_SELECTOR = `.${Overlay_module_default.overlayProvider.replaceAll(" ", ".")}`;
|
|
7724
|
+
var DIALOG_ID = 0;
|
|
7725
|
+
function createDialogRenderer_default(attrs, props, emit, slots, className, transition) {
|
|
7726
|
+
const dialogId = `flux-dialog:${DIALOG_ID++}`;
|
|
7727
|
+
let unregister = null;
|
|
7728
|
+
let zIndex = 0;
|
|
7729
|
+
const dialogRef = ref();
|
|
7730
|
+
F$1(dialogRef);
|
|
7731
|
+
onUnmounted(() => {
|
|
7732
|
+
unregister?.();
|
|
7733
|
+
});
|
|
7734
|
+
watch(dialogRef, (dialog, _, onCleanup) => {
|
|
7735
|
+
if (!dialog) return;
|
|
7736
|
+
dialog.addEventListener("keydown", onKeyDown, { passive: true });
|
|
7737
|
+
onCleanup(() => {
|
|
7738
|
+
dialog.removeEventListener("keydown", onKeyDown);
|
|
7739
|
+
});
|
|
7740
|
+
});
|
|
7741
|
+
function onKeyDown(evt) {
|
|
7742
|
+
if (evt.key !== "Escape" || !unregister || !props.isCloseable) return;
|
|
7743
|
+
emit("close");
|
|
7801
7744
|
}
|
|
7802
|
-
|
|
7803
|
-
|
|
7804
|
-
|
|
7805
|
-
|
|
7806
|
-
|
|
7807
|
-
|
|
7808
|
-
|
|
7809
|
-
|
|
7810
|
-
|
|
7811
|
-
|
|
7812
|
-
|
|
7813
|
-
|
|
7814
|
-
|
|
7745
|
+
return () => {
|
|
7746
|
+
const { dialogCount } = useFluxStore();
|
|
7747
|
+
const children = a$2(slots.default?.() ?? []);
|
|
7748
|
+
const isVisible = children.length > 0 && children.some((child) => child.type !== Comment);
|
|
7749
|
+
let content;
|
|
7750
|
+
if (isVisible) {
|
|
7751
|
+
if (!unregister) [zIndex, unregister] = registerDialog();
|
|
7752
|
+
content = h("div", {
|
|
7753
|
+
key: props.viewKey ?? dialogId,
|
|
7754
|
+
ref: dialogRef,
|
|
7755
|
+
class: [className, zIndex === dialogCount && Overlay_module_default.isCurrent],
|
|
7756
|
+
style: { zIndex: zIndex + 1e3 },
|
|
7757
|
+
tabindex: 0
|
|
7758
|
+
}, children);
|
|
7759
|
+
} else {
|
|
7760
|
+
unregister?.();
|
|
7761
|
+
unregister = null;
|
|
7762
|
+
}
|
|
7763
|
+
return h(Teleport, {
|
|
7764
|
+
defer: true,
|
|
7765
|
+
disabled: !content,
|
|
7766
|
+
to: TARGET_SELECTOR
|
|
7767
|
+
}, [h(transition, attrs, { default: () => content })]);
|
|
7768
|
+
};
|
|
7769
|
+
}
|
|
7815
7770
|
//#endregion
|
|
7816
|
-
//#region src/
|
|
7817
|
-
|
|
7818
|
-
|
|
7819
|
-
|
|
7820
|
-
|
|
7821
|
-
|
|
7822
|
-
|
|
7823
|
-
|
|
7824
|
-
];
|
|
7771
|
+
//#region src/composable/private/useAsyncFilterOptions.ts
|
|
7772
|
+
function useAsyncFilterOptions_default(params) {
|
|
7773
|
+
const { isLoading, loaded } = X$1();
|
|
7774
|
+
const debouncedModelSearch = Y$1(params.modelSearch, 150);
|
|
7775
|
+
const fetchOptions = computed(() => loaded(params.fetchOptions));
|
|
7776
|
+
const fetchRelevant = computed(() => loaded(params.fetchRelevant));
|
|
7777
|
+
const fetchSearch = computed(() => loaded(params.fetchSearch));
|
|
7778
|
+
const selectedOptions = ref([]);
|
|
7779
|
+
const visibleOptions = ref([]);
|
|
7780
|
+
const options = computed(() => {
|
|
7781
|
+
const options = [];
|
|
7782
|
+
const search = unref(params.modelSearch);
|
|
7783
|
+
const selected = unref(selectedOptions);
|
|
7784
|
+
const visible = unref(visibleOptions);
|
|
7785
|
+
visible.forEach((vo) => options.push(vo));
|
|
7786
|
+
selected.forEach((so) => {
|
|
7787
|
+
if (isFluxFilterOptionItem(so) && visible.find((vo) => isFluxFilterOptionItem(vo) && vo.value === so.value)) return;
|
|
7788
|
+
if (isFluxFilterOptionItem(so) && !so.label.toLowerCase().includes(search.toLowerCase())) return;
|
|
7789
|
+
options.push(so);
|
|
7790
|
+
});
|
|
7791
|
+
return options;
|
|
7792
|
+
});
|
|
7793
|
+
watch(params.currentValueIds, async (ids) => {
|
|
7794
|
+
if (ids.length === 0) return;
|
|
7795
|
+
selectedOptions.value = await unref(fetchOptions)(ids);
|
|
7796
|
+
}, { immediate: true });
|
|
7797
|
+
watch(debouncedModelSearch, async (searchQuery) => {
|
|
7798
|
+
if (searchQuery.length > 0) visibleOptions.value = await unref(fetchSearch)(searchQuery);
|
|
7799
|
+
else visibleOptions.value = await unref(fetchRelevant)();
|
|
7800
|
+
}, { immediate: true });
|
|
7801
|
+
return {
|
|
7802
|
+
isLoading,
|
|
7803
|
+
options
|
|
7804
|
+
};
|
|
7805
|
+
}
|
|
7825
7806
|
//#endregion
|
|
7826
|
-
//#region src/
|
|
7827
|
-
|
|
7828
|
-
|
|
7829
|
-
|
|
7830
|
-
|
|
7831
|
-
|
|
7832
|
-
|
|
7833
|
-
|
|
7834
|
-
|
|
7835
|
-
|
|
7836
|
-
|
|
7837
|
-
|
|
7838
|
-
|
|
7839
|
-
|
|
7840
|
-
|
|
7841
|
-
|
|
7842
|
-
|
|
7843
|
-
|
|
7844
|
-
|
|
7845
|
-
|
|
7846
|
-
|
|
7847
|
-
|
|
7848
|
-
|
|
7849
|
-
|
|
7850
|
-
|
|
7851
|
-
|
|
7852
|
-
|
|
7853
|
-
|
|
7854
|
-
|
|
7855
|
-
|
|
7856
|
-
|
|
7857
|
-
|
|
7858
|
-
|
|
7859
|
-
|
|
7860
|
-
|
|
7861
|
-
|
|
7862
|
-
|
|
7807
|
+
//#region src/composable/private/useDateFlyout.ts
|
|
7808
|
+
function useDateFlyout_default(modelValue, flyoutRef, options = {}) {
|
|
7809
|
+
const localValue = ref(null);
|
|
7810
|
+
watch(modelValue, (value) => {
|
|
7811
|
+
localValue.value = options.transformIn ? options.transformIn(value) : value;
|
|
7812
|
+
}, { immediate: true });
|
|
7813
|
+
watch(localValue, (value) => {
|
|
7814
|
+
unref(flyoutRef)?.close();
|
|
7815
|
+
if (options.compareKey && options.compareKey(modelValue.value) === options.compareKey(value)) return;
|
|
7816
|
+
modelValue.value = value;
|
|
7817
|
+
});
|
|
7818
|
+
return localValue;
|
|
7819
|
+
}
|
|
7820
|
+
//#endregion
|
|
7821
|
+
//#region src/composable/private/useDropdownPopup.ts
|
|
7822
|
+
/**
|
|
7823
|
+
* Shared dropdown-popup infrastructure for select-like components. Manages:
|
|
7824
|
+
* - open/close state
|
|
7825
|
+
* - click-outside (close when clicking outside popup + anchor)
|
|
7826
|
+
* - focus-back-to-anchor on close
|
|
7827
|
+
* - focus-the-inner-focus-element on open
|
|
7828
|
+
* - Escape/Tab keyboard handling
|
|
7829
|
+
*/
|
|
7830
|
+
function useDropdownPopup(options) {
|
|
7831
|
+
const isOpen = ref(false);
|
|
7832
|
+
function open() {
|
|
7833
|
+
if (unref(options.disabled) || unref(options.readonly)) return;
|
|
7834
|
+
isOpen.value = true;
|
|
7835
|
+
}
|
|
7836
|
+
function close() {
|
|
7837
|
+
isOpen.value = false;
|
|
7838
|
+
}
|
|
7839
|
+
function toggle() {
|
|
7840
|
+
if (unref(options.disabled) || unref(options.readonly)) return;
|
|
7841
|
+
isOpen.value = !unref(isOpen);
|
|
7842
|
+
}
|
|
7843
|
+
function focusAnchor() {
|
|
7844
|
+
nextTick(() => _$2(options.anchorRef)?.focus());
|
|
7845
|
+
}
|
|
7846
|
+
function onKeyDownBase(evt) {
|
|
7847
|
+
if (evt.key === "Escape" && unref(isOpen)) {
|
|
7848
|
+
evt.preventDefault();
|
|
7849
|
+
isOpen.value = false;
|
|
7850
|
+
focusAnchor();
|
|
7851
|
+
return true;
|
|
7863
7852
|
}
|
|
7864
|
-
|
|
7865
|
-
|
|
7853
|
+
if (evt.key === "Tab" && unref(isOpen)) {
|
|
7854
|
+
isOpen.value = false;
|
|
7855
|
+
return true;
|
|
7866
7856
|
}
|
|
7867
|
-
|
|
7868
|
-
|
|
7857
|
+
return false;
|
|
7858
|
+
}
|
|
7859
|
+
if (typeof window !== "undefined") {
|
|
7860
|
+
K$1([options.anchorRef, options.popupRef], isOpen, () => isOpen.value = false);
|
|
7861
|
+
K$1(options.anchorRef, isOpen, () => unref(options.focusElement)?.focus());
|
|
7862
|
+
}
|
|
7863
|
+
watch(isOpen, (opened) => {
|
|
7864
|
+
if (!opened) {
|
|
7865
|
+
options.onClose?.();
|
|
7866
|
+
return;
|
|
7869
7867
|
}
|
|
7870
|
-
|
|
7871
|
-
|
|
7872
|
-
|
|
7873
|
-
|
|
7874
|
-
|
|
7875
|
-
|
|
7876
|
-
|
|
7877
|
-
|
|
7878
|
-
|
|
7879
|
-
|
|
7880
|
-
|
|
7881
|
-
|
|
7882
|
-
|
|
7883
|
-
|
|
7884
|
-
|
|
7885
|
-
|
|
7886
|
-
|
|
7887
|
-
|
|
7888
|
-
|
|
7889
|
-
|
|
7890
|
-
|
|
7891
|
-
|
|
7892
|
-
|
|
7893
|
-
|
|
7894
|
-
|
|
7895
|
-
|
|
7896
|
-
|
|
7897
|
-
|
|
7898
|
-
|
|
7899
|
-
|
|
7900
|
-
|
|
7901
|
-
|
|
7902
|
-
|
|
7903
|
-
|
|
7904
|
-
|
|
7905
|
-
|
|
7906
|
-
|
|
7907
|
-
|
|
7908
|
-
|
|
7909
|
-
|
|
7910
|
-
|
|
7911
|
-
|
|
7912
|
-
|
|
7913
|
-
|
|
7914
|
-
|
|
7915
|
-
|
|
7916
|
-
|
|
7917
|
-
|
|
7918
|
-
|
|
7919
|
-
|
|
7920
|
-
|
|
7921
|
-
|
|
7922
|
-
|
|
7868
|
+
nextTick(() => unref(options.focusElement)?.focus());
|
|
7869
|
+
options.onOpen?.();
|
|
7870
|
+
});
|
|
7871
|
+
return {
|
|
7872
|
+
isOpen,
|
|
7873
|
+
open,
|
|
7874
|
+
close,
|
|
7875
|
+
toggle,
|
|
7876
|
+
focusAnchor,
|
|
7877
|
+
onKeyDownBase
|
|
7878
|
+
};
|
|
7879
|
+
}
|
|
7880
|
+
//#endregion
|
|
7881
|
+
//#region src/composable/private/useFormSelect.ts
|
|
7882
|
+
function useFormSelect_default(modelValue, isMultiple, options, searchQuery) {
|
|
7883
|
+
const values = computed(() => {
|
|
7884
|
+
const model = unref(modelValue);
|
|
7885
|
+
return Array.isArray(model) ? model : [model];
|
|
7886
|
+
});
|
|
7887
|
+
const groups = computed(() => {
|
|
7888
|
+
const groups = [];
|
|
7889
|
+
const search = unref(searchQuery)?.trim().toLowerCase();
|
|
7890
|
+
const available = unref(options).filter((o) => isFluxFormSelectGroup(o) || !search || o.label.toLowerCase().includes(search)).filter((o) => isFluxFormSelectGroup(o) || !isMultiple || !unref(selected).find((s) => s.value === o.value));
|
|
7891
|
+
if (available.length === 0) return [];
|
|
7892
|
+
if (!available.find(isFluxFormSelectGroup)) return [[null, available]];
|
|
7893
|
+
for (let i = 0; i < available.length;) {
|
|
7894
|
+
const item = available[i];
|
|
7895
|
+
if (isFluxFormSelectOption(item)) {
|
|
7896
|
+
++i;
|
|
7897
|
+
groups.push([null, [item]]);
|
|
7898
|
+
continue;
|
|
7899
|
+
}
|
|
7900
|
+
const subItems = [];
|
|
7901
|
+
for (++i; i <= available.length; ++i) {
|
|
7902
|
+
const subItem = available[i];
|
|
7903
|
+
if (isFluxFormSelectGroup(subItem) || i === available.length) {
|
|
7904
|
+
if (subItems.length > 0) groups.push([item, subItems]);
|
|
7905
|
+
break;
|
|
7906
|
+
}
|
|
7907
|
+
subItems.push(subItem);
|
|
7908
|
+
}
|
|
7909
|
+
}
|
|
7910
|
+
return groups;
|
|
7911
|
+
});
|
|
7912
|
+
const selected = computed(() => unref(values).map((v) => unref(options).find((o) => isFluxFormSelectOption(o) && o.value === v)).filter(isFluxFormSelectOption));
|
|
7913
|
+
return {
|
|
7914
|
+
groups,
|
|
7915
|
+
selected,
|
|
7916
|
+
values
|
|
7917
|
+
};
|
|
7918
|
+
}
|
|
7919
|
+
//#endregion
|
|
7920
|
+
//#region src/composable/private/useKanbanAutoScroll.ts
|
|
7921
|
+
var AUTOSCROLL_ZONE = 40;
|
|
7922
|
+
var AUTOSCROLL_MAX_SPEED = 12;
|
|
7923
|
+
/**
|
|
7924
|
+
* Drives horizontal (board) and vertical (column body) auto-scroll while a drag
|
|
7925
|
+
* is in progress. Reads the active scroll containers via the option callbacks.
|
|
7926
|
+
*/
|
|
7927
|
+
function useKanbanAutoScroll(options) {
|
|
7928
|
+
let frame = null;
|
|
7929
|
+
let deltaX = 0;
|
|
7930
|
+
let deltaY = 0;
|
|
7931
|
+
let verticalTarget = null;
|
|
7932
|
+
function onPointerMove(clientX, clientY) {
|
|
7933
|
+
const board = options.getBoardElement();
|
|
7934
|
+
const target = options.getVerticalTarget();
|
|
7935
|
+
deltaX = board ? computeScrollDelta(board.getBoundingClientRect(), clientX, "horizontal") : 0;
|
|
7936
|
+
deltaY = target ? computeScrollDelta(target.getBoundingClientRect(), clientY, "vertical") : 0;
|
|
7937
|
+
verticalTarget = target;
|
|
7938
|
+
if (deltaX !== 0 || deltaY !== 0) start();
|
|
7939
|
+
else stop();
|
|
7940
|
+
}
|
|
7941
|
+
function start() {
|
|
7942
|
+
if (frame !== null) return;
|
|
7943
|
+
const tick = () => {
|
|
7944
|
+
const board = options.getBoardElement();
|
|
7945
|
+
if (deltaX !== 0 && board) board.scrollLeft += deltaX;
|
|
7946
|
+
if (deltaY !== 0 && verticalTarget) verticalTarget.scrollTop += deltaY;
|
|
7947
|
+
if (deltaX === 0 && deltaY === 0) {
|
|
7948
|
+
frame = null;
|
|
7949
|
+
return;
|
|
7950
|
+
}
|
|
7951
|
+
frame = requestAnimationFrame(tick);
|
|
7923
7952
|
};
|
|
7953
|
+
frame = requestAnimationFrame(tick);
|
|
7924
7954
|
}
|
|
7925
|
-
|
|
7955
|
+
function stop() {
|
|
7956
|
+
if (frame !== null) {
|
|
7957
|
+
cancelAnimationFrame(frame);
|
|
7958
|
+
frame = null;
|
|
7959
|
+
}
|
|
7960
|
+
deltaX = 0;
|
|
7961
|
+
deltaY = 0;
|
|
7962
|
+
verticalTarget = null;
|
|
7963
|
+
}
|
|
7964
|
+
return {
|
|
7965
|
+
onPointerMove,
|
|
7966
|
+
stop
|
|
7967
|
+
};
|
|
7968
|
+
}
|
|
7969
|
+
function computeScrollDelta(rect, position, axis) {
|
|
7970
|
+
const start = axis === "horizontal" ? rect.left : rect.top;
|
|
7971
|
+
const end = axis === "horizontal" ? rect.right : rect.bottom;
|
|
7972
|
+
if (position < start + AUTOSCROLL_ZONE) {
|
|
7973
|
+
const distance = Math.max(0, position - start);
|
|
7974
|
+
return -Math.round((AUTOSCROLL_ZONE - distance) / AUTOSCROLL_ZONE * AUTOSCROLL_MAX_SPEED);
|
|
7975
|
+
}
|
|
7976
|
+
if (position > end - AUTOSCROLL_ZONE) {
|
|
7977
|
+
const distance = Math.max(0, end - position);
|
|
7978
|
+
return Math.round((AUTOSCROLL_ZONE - distance) / AUTOSCROLL_ZONE * AUTOSCROLL_MAX_SPEED);
|
|
7979
|
+
}
|
|
7980
|
+
return 0;
|
|
7981
|
+
}
|
|
7926
7982
|
//#endregion
|
|
7927
|
-
//#region src/
|
|
7928
|
-
var
|
|
7929
|
-
var
|
|
7930
|
-
|
|
7931
|
-
|
|
7932
|
-
actionIcon: `action-icon ${_1$6}`,
|
|
7933
|
-
isDestructive: `is-destructive`,
|
|
7934
|
-
actionLabel: `action-label ${_2$5}`,
|
|
7935
|
-
actionBar: `action-bar`,
|
|
7936
|
-
separator: `separator`,
|
|
7937
|
-
formInput: `form-input`,
|
|
7938
|
-
basePaneStructure: `base-pane-structure`,
|
|
7939
|
-
actionPane: `action-pane`,
|
|
7940
|
-
actionPaneGrid: `action-pane-grid`,
|
|
7941
|
-
actionPaneBody: `action-pane-body`,
|
|
7942
|
-
paneBody: `pane-body`
|
|
7983
|
+
//#region src/composable/private/useKanban.ts
|
|
7984
|
+
var DRAG_LEAVE_GRACE_MS = 50;
|
|
7985
|
+
var WITHIN_COLUMN_DELTA = {
|
|
7986
|
+
up: -1,
|
|
7987
|
+
down: 1
|
|
7943
7988
|
};
|
|
7944
|
-
|
|
7945
|
-
|
|
7946
|
-
|
|
7947
|
-
__name: "FluxAction",
|
|
7948
|
-
props: {
|
|
7949
|
-
type: {},
|
|
7950
|
-
disabled: { type: Boolean },
|
|
7951
|
-
isLoading: { type: Boolean },
|
|
7952
|
-
isSubmit: { type: Boolean },
|
|
7953
|
-
label: {},
|
|
7954
|
-
tabindex: {},
|
|
7955
|
-
href: {},
|
|
7956
|
-
rel: {},
|
|
7957
|
-
target: {},
|
|
7958
|
-
to: {},
|
|
7959
|
-
icon: {},
|
|
7960
|
-
isDestructive: { type: Boolean }
|
|
7961
|
-
},
|
|
7962
|
-
emits: [
|
|
7963
|
-
"click",
|
|
7964
|
-
"mouseenter",
|
|
7965
|
-
"mouseleave"
|
|
7966
|
-
],
|
|
7967
|
-
setup(__props, { emit: $emit }) {
|
|
7968
|
-
return (_ctx, _cache) => {
|
|
7969
|
-
return openBlock(), createBlock(FluxButton_default, mergeProps({
|
|
7970
|
-
disabled: __props.disabled,
|
|
7971
|
-
isLoading: __props.isLoading,
|
|
7972
|
-
label: __props.label,
|
|
7973
|
-
href: __props.href,
|
|
7974
|
-
rel: __props.rel,
|
|
7975
|
-
target: __props.target,
|
|
7976
|
-
to: __props.to,
|
|
7977
|
-
type: __props.type
|
|
7978
|
-
}, {
|
|
7979
|
-
"css-class": unref(Action_module_default).action,
|
|
7980
|
-
"css-class-icon": unref(Action_module_default).actionIcon,
|
|
7981
|
-
"css-class-label": unref(Action_module_default).actionLabel,
|
|
7982
|
-
class: __props.isDestructive && unref(Action_module_default).isDestructive,
|
|
7983
|
-
"icon-leading": __props.icon,
|
|
7984
|
-
onClick: _cache[0] || (_cache[0] = ($event) => $emit("click", $event)),
|
|
7985
|
-
onMouseenter: _cache[1] || (_cache[1] = ($event) => $emit("mouseenter", $event)),
|
|
7986
|
-
onMouseleave: _cache[2] || (_cache[2] = ($event) => $emit("mouseleave", $event))
|
|
7987
|
-
}), null, 16, [
|
|
7988
|
-
"css-class",
|
|
7989
|
-
"css-class-icon",
|
|
7990
|
-
"css-class-label",
|
|
7991
|
-
"class",
|
|
7992
|
-
"icon-leading"
|
|
7993
|
-
]);
|
|
7994
|
-
};
|
|
7995
|
-
}
|
|
7996
|
-
});
|
|
7997
|
-
var Overlay_module_default = {
|
|
7998
|
-
overlayView: `overlay-view`,
|
|
7999
|
-
overlayProvider: `overlay-provider overlay-view`,
|
|
8000
|
-
overlayShade: `overlay-shade overlay-view`,
|
|
8001
|
-
overlay: `overlay`,
|
|
8002
|
-
overlayTransitionLeaveActive: `overlay-transition-leave-active`,
|
|
8003
|
-
slideOverTransitionLeaveActive: `slide-over-transition-leave-active`,
|
|
8004
|
-
basePaneStructure: `base-pane-structure`,
|
|
8005
|
-
paneFooter: `pane-footer`,
|
|
8006
|
-
isCurrent: `is-current`,
|
|
8007
|
-
overlaySmall: `overlay-small overlay`,
|
|
8008
|
-
overlayMedium: `overlay-medium overlay`,
|
|
8009
|
-
overlayLarge: `overlay-large overlay`,
|
|
8010
|
-
slideOver: `slide-over overlay`,
|
|
8011
|
-
paneHeader: `pane-header`,
|
|
8012
|
-
tabs: `tabs`,
|
|
8013
|
-
tabBarDefault: `tab-bar-default`,
|
|
8014
|
-
paneHeaderCaption: `pane-header-caption`,
|
|
8015
|
-
overlayTransitionEnterActive: `overlay-transition-enter-active`,
|
|
8016
|
-
overlayTransitionEnterFrom: `overlay-transition-enter-from`,
|
|
8017
|
-
overlayTransitionLeaveTo: `overlay-transition-leave-to`,
|
|
8018
|
-
slideOverTransitionEnterActive: `slide-over-transition-enter-active`,
|
|
8019
|
-
slideOverTransitionEnterFrom: `slide-over-transition-enter-from`,
|
|
8020
|
-
slideOverTransitionLeaveTo: `slide-over-transition-leave-to`
|
|
7989
|
+
var ACROSS_COLUMN_DELTA = {
|
|
7990
|
+
left: -1,
|
|
7991
|
+
right: 1
|
|
8021
7992
|
};
|
|
8022
|
-
|
|
8023
|
-
|
|
8024
|
-
|
|
8025
|
-
|
|
8026
|
-
|
|
8027
|
-
|
|
8028
|
-
|
|
8029
|
-
|
|
8030
|
-
const
|
|
8031
|
-
|
|
8032
|
-
|
|
8033
|
-
|
|
7993
|
+
/**
|
|
7994
|
+
* Internal composable for managing kanban drag-and-drop state.
|
|
7995
|
+
* Provides item registration, drag tracking, drop target management,
|
|
7996
|
+
* keyboard drag-and-drop, column reordering, drop validation and auto-scroll.
|
|
7997
|
+
*/
|
|
7998
|
+
function useKanban(options) {
|
|
7999
|
+
const dragState = ref(null);
|
|
8000
|
+
const columnDragState = ref(null);
|
|
8001
|
+
const isOverColumnId = ref(null);
|
|
8002
|
+
const itemRegistry = /* @__PURE__ */ new WeakMap();
|
|
8003
|
+
const itemElementsById = /* @__PURE__ */ new Map();
|
|
8004
|
+
const columnRegistry = /* @__PURE__ */ new WeakMap();
|
|
8005
|
+
const columnElementsById = /* @__PURE__ */ new Map();
|
|
8006
|
+
const columnBodyById = /* @__PURE__ */ new Map();
|
|
8007
|
+
const dragEnterCounts = /* @__PURE__ */ new Map();
|
|
8008
|
+
let boardElement = null;
|
|
8009
|
+
let clearTimer = null;
|
|
8010
|
+
const autoScroll = useKanbanAutoScroll({
|
|
8011
|
+
getBoardElement: () => boardElement,
|
|
8012
|
+
getVerticalTarget: () => {
|
|
8013
|
+
const state = unref(dragState);
|
|
8014
|
+
return state && state.dropColumnId !== null ? columnBodyById.get(state.dropColumnId) ?? null : null;
|
|
8015
|
+
}
|
|
8034
8016
|
});
|
|
8035
|
-
|
|
8036
|
-
|
|
8037
|
-
|
|
8038
|
-
onCleanup(() => {
|
|
8039
|
-
dialog.removeEventListener("keydown", onKeyDown);
|
|
8040
|
-
});
|
|
8017
|
+
const grabbedId = computed(() => {
|
|
8018
|
+
const state = unref(dragState);
|
|
8019
|
+
return state !== null && state.mode === "keyboard" ? state.itemId : null;
|
|
8041
8020
|
});
|
|
8042
|
-
|
|
8043
|
-
|
|
8044
|
-
|
|
8021
|
+
const currentMoveEvent = computed(() => tryBuildMoveEvent(unref(dragState)));
|
|
8022
|
+
const isDropAllowed = computed(() => {
|
|
8023
|
+
const event = unref(currentMoveEvent);
|
|
8024
|
+
return event === null || validateMove(event);
|
|
8025
|
+
});
|
|
8026
|
+
function tryBuildMoveEvent(state) {
|
|
8027
|
+
if (!state || state.dropColumnId === null) return null;
|
|
8028
|
+
return {
|
|
8029
|
+
itemId: state.itemId,
|
|
8030
|
+
fromColumnId: state.fromColumnId,
|
|
8031
|
+
toColumnId: state.dropColumnId,
|
|
8032
|
+
beforeItemId: state.beforeItemId ?? void 0
|
|
8033
|
+
};
|
|
8045
8034
|
}
|
|
8046
|
-
|
|
8047
|
-
const
|
|
8048
|
-
|
|
8049
|
-
|
|
8050
|
-
|
|
8051
|
-
if (
|
|
8052
|
-
|
|
8053
|
-
|
|
8054
|
-
key: props.viewKey ?? dialogId,
|
|
8055
|
-
ref: dialogRef,
|
|
8056
|
-
class: [className, zIndex === dialogCount && Overlay_module_default.isCurrent],
|
|
8057
|
-
style: { zIndex: zIndex + 1e3 },
|
|
8058
|
-
tabindex: 0
|
|
8059
|
-
}, children);
|
|
8060
|
-
} else {
|
|
8061
|
-
unregister?.();
|
|
8062
|
-
unregister = null;
|
|
8035
|
+
function validateMove(event) {
|
|
8036
|
+
const validate = unref(options.canMove);
|
|
8037
|
+
return validate ? validate(event) : true;
|
|
8038
|
+
}
|
|
8039
|
+
function clearTimerIfAny() {
|
|
8040
|
+
if (clearTimer !== null) {
|
|
8041
|
+
clearTimeout(clearTimer);
|
|
8042
|
+
clearTimer = null;
|
|
8063
8043
|
}
|
|
8064
|
-
return h(Teleport, {
|
|
8065
|
-
defer: true,
|
|
8066
|
-
disabled: !content,
|
|
8067
|
-
to: TARGET_SELECTOR
|
|
8068
|
-
}, [h(transition, attrs, { default: () => content })]);
|
|
8069
|
-
};
|
|
8070
|
-
}
|
|
8071
|
-
//#endregion
|
|
8072
|
-
//#region src/util/createLabelForDateRange.ts
|
|
8073
|
-
function createLabelForDateRange_default(start, end, preventCustom = false) {
|
|
8074
|
-
const translate = useTranslate_default();
|
|
8075
|
-
if (start.day === end.day && start.month === end.month && start.year === end.year) return start.toLocaleString({
|
|
8076
|
-
day: "numeric",
|
|
8077
|
-
month: "short",
|
|
8078
|
-
year: "numeric"
|
|
8079
|
-
});
|
|
8080
|
-
if (start.month === end.month && start.year === end.year) return `${start.toLocaleString({ day: "numeric" })} – ${end.toLocaleString({
|
|
8081
|
-
day: "numeric",
|
|
8082
|
-
month: "short",
|
|
8083
|
-
year: "numeric"
|
|
8084
|
-
})}`;
|
|
8085
|
-
if (start.year === end.year) return `${start.toLocaleString({
|
|
8086
|
-
day: "numeric",
|
|
8087
|
-
month: "short"
|
|
8088
|
-
})} – ${end.toLocaleString({
|
|
8089
|
-
day: "numeric",
|
|
8090
|
-
month: "short",
|
|
8091
|
-
year: "numeric"
|
|
8092
|
-
})}`;
|
|
8093
|
-
if (preventCustom) return `${start.toLocaleString({
|
|
8094
|
-
day: "numeric",
|
|
8095
|
-
month: "short",
|
|
8096
|
-
year: "numeric"
|
|
8097
|
-
})} – ${end.toLocaleString({
|
|
8098
|
-
day: "numeric",
|
|
8099
|
-
month: "short",
|
|
8100
|
-
year: "numeric"
|
|
8101
|
-
})}`;
|
|
8102
|
-
return translate("flux.customPeriod");
|
|
8103
|
-
}
|
|
8104
|
-
//#endregion
|
|
8105
|
-
//#region src/util/defineFilter.ts
|
|
8106
|
-
function defineFilter(factory) {
|
|
8107
|
-
return factory;
|
|
8108
|
-
}
|
|
8109
|
-
//#endregion
|
|
8110
|
-
//#region src/util/filter.ts
|
|
8111
|
-
function isFluxFilterOptionHeader(obj) {
|
|
8112
|
-
return "title" in obj;
|
|
8113
|
-
}
|
|
8114
|
-
function isFluxFilterOptionItem(obj) {
|
|
8115
|
-
return "label" in obj && "value" in obj;
|
|
8116
|
-
}
|
|
8117
|
-
function isResettable(definition, value) {
|
|
8118
|
-
if (!definition || definition.defaultValue === void 0) return false;
|
|
8119
|
-
return !isFilterValueEqual(value, definition.defaultValue);
|
|
8120
|
-
}
|
|
8121
|
-
function isFilterValueEqual(a, b) {
|
|
8122
|
-
if (a === b) return true;
|
|
8123
|
-
if (DateTime.isDateTime(a) && DateTime.isDateTime(b)) return a.equals(b);
|
|
8124
|
-
if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((value, index) => isFilterValueEqual(value, b[index]));
|
|
8125
|
-
return false;
|
|
8126
|
-
}
|
|
8127
|
-
function pickFilterCommon(props) {
|
|
8128
|
-
return {
|
|
8129
|
-
name: props.name,
|
|
8130
|
-
label: props.label,
|
|
8131
|
-
icon: props.icon,
|
|
8132
|
-
disabled: props.disabled,
|
|
8133
|
-
defaultValue: props.defaultValue,
|
|
8134
|
-
onChange: props.onChange,
|
|
8135
|
-
onClear: props.onClear
|
|
8136
|
-
};
|
|
8137
|
-
}
|
|
8138
|
-
function generateMultiOptionsLabel(translate, options, values) {
|
|
8139
|
-
const selected = options.filter((o) => values.includes(o.value)).length;
|
|
8140
|
-
if (selected <= 0) return null;
|
|
8141
|
-
if (selected === 1) return options.find((o) => values.includes(o.value)).label;
|
|
8142
|
-
return translate("flux.nSelected", { n: selected });
|
|
8143
|
-
}
|
|
8144
|
-
//#endregion
|
|
8145
|
-
//#region src/composable/private/useAsyncFilterOptions.ts
|
|
8146
|
-
function useAsyncFilterOptions_default(params) {
|
|
8147
|
-
const { isLoading, loaded } = X$1();
|
|
8148
|
-
const debouncedModelSearch = Y$1(params.modelSearch, 150);
|
|
8149
|
-
const fetchOptions = computed(() => loaded(params.fetchOptions));
|
|
8150
|
-
const fetchRelevant = computed(() => loaded(params.fetchRelevant));
|
|
8151
|
-
const fetchSearch = computed(() => loaded(params.fetchSearch));
|
|
8152
|
-
const selectedOptions = ref([]);
|
|
8153
|
-
const visibleOptions = ref([]);
|
|
8154
|
-
const options = computed(() => {
|
|
8155
|
-
const options = [];
|
|
8156
|
-
const search = unref(params.modelSearch);
|
|
8157
|
-
const selected = unref(selectedOptions);
|
|
8158
|
-
const visible = unref(visibleOptions);
|
|
8159
|
-
visible.forEach((vo) => options.push(vo));
|
|
8160
|
-
selected.forEach((so) => {
|
|
8161
|
-
if (isFluxFilterOptionItem(so) && visible.find((vo) => isFluxFilterOptionItem(vo) && vo.value === so.value)) return;
|
|
8162
|
-
if (isFluxFilterOptionItem(so) && !so.label.toLowerCase().includes(search.toLowerCase())) return;
|
|
8163
|
-
options.push(so);
|
|
8164
|
-
});
|
|
8165
|
-
return options;
|
|
8166
|
-
});
|
|
8167
|
-
watch(params.currentValueIds, async (ids) => {
|
|
8168
|
-
if (ids.length === 0) return;
|
|
8169
|
-
selectedOptions.value = await unref(fetchOptions)(ids);
|
|
8170
|
-
}, { immediate: true });
|
|
8171
|
-
watch(debouncedModelSearch, async (searchQuery) => {
|
|
8172
|
-
if (searchQuery.length > 0) visibleOptions.value = await unref(fetchSearch)(searchQuery);
|
|
8173
|
-
else visibleOptions.value = await unref(fetchRelevant)();
|
|
8174
|
-
}, { immediate: true });
|
|
8175
|
-
return {
|
|
8176
|
-
isLoading,
|
|
8177
|
-
options
|
|
8178
|
-
};
|
|
8179
|
-
}
|
|
8180
|
-
//#endregion
|
|
8181
|
-
//#region src/composable/private/useDateFlyout.ts
|
|
8182
|
-
function useDateFlyout_default(modelValue, flyoutRef, options = {}) {
|
|
8183
|
-
const localValue = ref(null);
|
|
8184
|
-
watch(modelValue, (value) => {
|
|
8185
|
-
localValue.value = options.transformIn ? options.transformIn(value) : value;
|
|
8186
|
-
}, { immediate: true });
|
|
8187
|
-
watch(localValue, (value) => {
|
|
8188
|
-
unref(flyoutRef)?.close();
|
|
8189
|
-
if (options.compareKey && options.compareKey(modelValue.value) === options.compareKey(value)) return;
|
|
8190
|
-
modelValue.value = value;
|
|
8191
|
-
});
|
|
8192
|
-
return localValue;
|
|
8193
|
-
}
|
|
8194
|
-
//#endregion
|
|
8195
|
-
//#region src/composable/private/useDropdownPopup.ts
|
|
8196
|
-
/**
|
|
8197
|
-
* Shared dropdown-popup infrastructure for select-like components. Manages:
|
|
8198
|
-
* - open/close state
|
|
8199
|
-
* - click-outside (close when clicking outside popup + anchor)
|
|
8200
|
-
* - focus-back-to-anchor on close
|
|
8201
|
-
* - focus-the-inner-focus-element on open
|
|
8202
|
-
* - Escape/Tab keyboard handling
|
|
8203
|
-
*/
|
|
8204
|
-
function useDropdownPopup(options) {
|
|
8205
|
-
const isOpen = ref(false);
|
|
8206
|
-
function open() {
|
|
8207
|
-
if (unref(options.disabled) || unref(options.readonly)) return;
|
|
8208
|
-
isOpen.value = true;
|
|
8209
8044
|
}
|
|
8210
|
-
function
|
|
8211
|
-
|
|
8045
|
+
function isSelfDrop(state) {
|
|
8046
|
+
return state.fromColumnId === state.dropColumnId && state.beforeItemId === (state.originBeforeItemId ?? null);
|
|
8212
8047
|
}
|
|
8213
|
-
function
|
|
8214
|
-
if (
|
|
8215
|
-
|
|
8048
|
+
function getColumnIndex(columnId) {
|
|
8049
|
+
if (!boardElement) return -1;
|
|
8050
|
+
return Array.from(boardElement.children).filter((child) => columnRegistry.has(child)).findIndex((elm) => columnRegistry.get(elm)?.columnId === columnId);
|
|
8216
8051
|
}
|
|
8217
|
-
function
|
|
8218
|
-
|
|
8052
|
+
function getColumnByIndex(index) {
|
|
8053
|
+
if (!boardElement) return null;
|
|
8054
|
+
const elm = Array.from(boardElement.children).filter((child) => columnRegistry.has(child))[index];
|
|
8055
|
+
return elm ? columnRegistry.get(elm) : null;
|
|
8219
8056
|
}
|
|
8220
|
-
function
|
|
8221
|
-
|
|
8222
|
-
|
|
8223
|
-
|
|
8224
|
-
|
|
8225
|
-
|
|
8226
|
-
}
|
|
8227
|
-
|
|
8228
|
-
|
|
8229
|
-
|
|
8057
|
+
function getItemsInColumn(columnId) {
|
|
8058
|
+
const body = columnBodyById.get(columnId);
|
|
8059
|
+
if (!body) return [];
|
|
8060
|
+
return Array.from(body.children).map((child) => itemRegistry.get(child)?.itemId).filter((id) => id !== void 0);
|
|
8061
|
+
}
|
|
8062
|
+
function registerItem(element, itemId) {
|
|
8063
|
+
itemRegistry.set(element, { itemId });
|
|
8064
|
+
itemElementsById.set(itemId, element);
|
|
8065
|
+
}
|
|
8066
|
+
function unregisterItem(element) {
|
|
8067
|
+
const info = itemRegistry.get(element);
|
|
8068
|
+
if (info) itemElementsById.delete(info.itemId);
|
|
8069
|
+
itemRegistry.delete(element);
|
|
8070
|
+
}
|
|
8071
|
+
function getItemInfo(element) {
|
|
8072
|
+
return itemRegistry.get(element);
|
|
8073
|
+
}
|
|
8074
|
+
function registerColumn(element, columnId) {
|
|
8075
|
+
columnRegistry.set(element, { columnId });
|
|
8076
|
+
columnElementsById.set(columnId, element);
|
|
8077
|
+
}
|
|
8078
|
+
function unregisterColumn(element) {
|
|
8079
|
+
const info = columnRegistry.get(element);
|
|
8080
|
+
if (info) {
|
|
8081
|
+
columnElementsById.delete(info.columnId);
|
|
8082
|
+
columnBodyById.delete(info.columnId);
|
|
8083
|
+
dragEnterCounts.delete(info.columnId);
|
|
8084
|
+
if (isOverColumnId.value === info.columnId) isOverColumnId.value = null;
|
|
8230
8085
|
}
|
|
8231
|
-
|
|
8086
|
+
columnRegistry.delete(element);
|
|
8232
8087
|
}
|
|
8233
|
-
|
|
8234
|
-
|
|
8235
|
-
K$1(options.anchorRef, isOpen, () => unref(options.focusElement)?.focus());
|
|
8088
|
+
function getColumnInfo(element) {
|
|
8089
|
+
return columnRegistry.get(element);
|
|
8236
8090
|
}
|
|
8237
|
-
|
|
8238
|
-
|
|
8239
|
-
|
|
8091
|
+
function setBoardElement(element) {
|
|
8092
|
+
boardElement = element;
|
|
8093
|
+
}
|
|
8094
|
+
function setColumnBodyElement(columnId, element) {
|
|
8095
|
+
if (element) columnBodyById.set(columnId, element);
|
|
8096
|
+
else columnBodyById.delete(columnId);
|
|
8097
|
+
}
|
|
8098
|
+
function enterColumn(columnId) {
|
|
8099
|
+
if (unref(options.disabled)) return;
|
|
8100
|
+
const count = (dragEnterCounts.get(columnId) ?? 0) + 1;
|
|
8101
|
+
dragEnterCounts.set(columnId, count);
|
|
8102
|
+
isOverColumnId.value = columnId;
|
|
8103
|
+
}
|
|
8104
|
+
function leaveColumn(columnId) {
|
|
8105
|
+
const next = (dragEnterCounts.get(columnId) ?? 0) - 1;
|
|
8106
|
+
if (next > 0) {
|
|
8107
|
+
dragEnterCounts.set(columnId, next);
|
|
8240
8108
|
return;
|
|
8241
8109
|
}
|
|
8242
|
-
|
|
8243
|
-
|
|
8244
|
-
|
|
8245
|
-
return {
|
|
8246
|
-
isOpen,
|
|
8247
|
-
open,
|
|
8248
|
-
close,
|
|
8249
|
-
toggle,
|
|
8250
|
-
focusAnchor,
|
|
8251
|
-
onKeyDownBase
|
|
8252
|
-
};
|
|
8253
|
-
}
|
|
8254
|
-
//#endregion
|
|
8255
|
-
//#region src/composable/private/useFormSelect.ts
|
|
8256
|
-
function useFormSelect_default(modelValue, isMultiple, options, searchQuery) {
|
|
8257
|
-
const values = computed(() => {
|
|
8258
|
-
const model = unref(modelValue);
|
|
8259
|
-
return Array.isArray(model) ? model : [model];
|
|
8260
|
-
});
|
|
8261
|
-
const groups = computed(() => {
|
|
8262
|
-
const groups = [];
|
|
8263
|
-
const search = unref(searchQuery)?.trim().toLowerCase();
|
|
8264
|
-
const available = unref(options).filter((o) => isFluxFormSelectGroup(o) || !search || o.label.toLowerCase().includes(search)).filter((o) => isFluxFormSelectGroup(o) || !isMultiple || !unref(selected).find((s) => s.value === o.value));
|
|
8265
|
-
if (available.length === 0) return [];
|
|
8266
|
-
if (!available.find(isFluxFormSelectGroup)) return [[null, available]];
|
|
8267
|
-
for (let i = 0; i < available.length;) {
|
|
8268
|
-
const item = available[i];
|
|
8269
|
-
if (isFluxFormSelectOption(item)) {
|
|
8270
|
-
++i;
|
|
8271
|
-
groups.push([null, [item]]);
|
|
8272
|
-
continue;
|
|
8273
|
-
}
|
|
8274
|
-
const subItems = [];
|
|
8275
|
-
for (++i; i <= available.length; ++i) {
|
|
8276
|
-
const subItem = available[i];
|
|
8277
|
-
if (isFluxFormSelectGroup(subItem) || i === available.length) {
|
|
8278
|
-
if (subItems.length > 0) groups.push([item, subItems]);
|
|
8279
|
-
break;
|
|
8280
|
-
}
|
|
8281
|
-
subItems.push(subItem);
|
|
8282
|
-
}
|
|
8283
|
-
}
|
|
8284
|
-
return groups;
|
|
8285
|
-
});
|
|
8286
|
-
const selected = computed(() => unref(values).map((v) => unref(options).find((o) => isFluxFormSelectOption(o) && o.value === v)).filter(isFluxFormSelectOption));
|
|
8287
|
-
return {
|
|
8288
|
-
groups,
|
|
8289
|
-
selected,
|
|
8290
|
-
values
|
|
8291
|
-
};
|
|
8292
|
-
}
|
|
8293
|
-
//#endregion
|
|
8294
|
-
//#region src/composable/private/useKanbanAutoScroll.ts
|
|
8295
|
-
var AUTOSCROLL_ZONE = 40;
|
|
8296
|
-
var AUTOSCROLL_MAX_SPEED = 12;
|
|
8297
|
-
/**
|
|
8298
|
-
* Drives horizontal (board) and vertical (column body) auto-scroll while a drag
|
|
8299
|
-
* is in progress. Reads the active scroll containers via the option callbacks.
|
|
8300
|
-
*/
|
|
8301
|
-
function useKanbanAutoScroll(options) {
|
|
8302
|
-
let frame = null;
|
|
8303
|
-
let deltaX = 0;
|
|
8304
|
-
let deltaY = 0;
|
|
8305
|
-
let verticalTarget = null;
|
|
8306
|
-
function onPointerMove(clientX, clientY) {
|
|
8307
|
-
const board = options.getBoardElement();
|
|
8308
|
-
const target = options.getVerticalTarget();
|
|
8309
|
-
deltaX = board ? computeScrollDelta(board.getBoundingClientRect(), clientX, "horizontal") : 0;
|
|
8310
|
-
deltaY = target ? computeScrollDelta(target.getBoundingClientRect(), clientY, "vertical") : 0;
|
|
8311
|
-
verticalTarget = target;
|
|
8312
|
-
if (deltaX !== 0 || deltaY !== 0) start();
|
|
8313
|
-
else stop();
|
|
8110
|
+
dragEnterCounts.delete(columnId);
|
|
8111
|
+
if (isOverColumnId.value === columnId) isOverColumnId.value = null;
|
|
8112
|
+
clearDropTarget();
|
|
8314
8113
|
}
|
|
8315
|
-
function
|
|
8316
|
-
if (
|
|
8317
|
-
|
|
8318
|
-
|
|
8319
|
-
|
|
8320
|
-
|
|
8321
|
-
|
|
8322
|
-
|
|
8323
|
-
|
|
8324
|
-
|
|
8325
|
-
frame = requestAnimationFrame(tick);
|
|
8114
|
+
function startDrag(itemId, fromColumnId) {
|
|
8115
|
+
if (unref(options.disabled)) return;
|
|
8116
|
+
clearTimerIfAny();
|
|
8117
|
+
dragState.value = {
|
|
8118
|
+
mode: "pointer",
|
|
8119
|
+
itemId,
|
|
8120
|
+
fromColumnId,
|
|
8121
|
+
dropColumnId: null,
|
|
8122
|
+
beforeItemId: null,
|
|
8123
|
+
originBeforeItemId: findCurrentBeforeItemId(itemId, fromColumnId)
|
|
8326
8124
|
};
|
|
8327
|
-
frame = requestAnimationFrame(tick);
|
|
8328
8125
|
}
|
|
8329
|
-
function
|
|
8330
|
-
|
|
8331
|
-
|
|
8332
|
-
|
|
8333
|
-
|
|
8334
|
-
|
|
8335
|
-
deltaY = 0;
|
|
8336
|
-
verticalTarget = null;
|
|
8337
|
-
}
|
|
8338
|
-
return {
|
|
8339
|
-
onPointerMove,
|
|
8340
|
-
stop
|
|
8341
|
-
};
|
|
8342
|
-
}
|
|
8343
|
-
function computeScrollDelta(rect, position, axis) {
|
|
8344
|
-
const start = axis === "horizontal" ? rect.left : rect.top;
|
|
8345
|
-
const end = axis === "horizontal" ? rect.right : rect.bottom;
|
|
8346
|
-
if (position < start + AUTOSCROLL_ZONE) {
|
|
8347
|
-
const distance = Math.max(0, position - start);
|
|
8348
|
-
return -Math.round((AUTOSCROLL_ZONE - distance) / AUTOSCROLL_ZONE * AUTOSCROLL_MAX_SPEED);
|
|
8349
|
-
}
|
|
8350
|
-
if (position > end - AUTOSCROLL_ZONE) {
|
|
8351
|
-
const distance = Math.max(0, end - position);
|
|
8352
|
-
return Math.round((AUTOSCROLL_ZONE - distance) / AUTOSCROLL_ZONE * AUTOSCROLL_MAX_SPEED);
|
|
8353
|
-
}
|
|
8354
|
-
return 0;
|
|
8355
|
-
}
|
|
8356
|
-
//#endregion
|
|
8357
|
-
//#region src/composable/private/useKanban.ts
|
|
8358
|
-
var DRAG_LEAVE_GRACE_MS = 50;
|
|
8359
|
-
var WITHIN_COLUMN_DELTA = {
|
|
8360
|
-
up: -1,
|
|
8361
|
-
down: 1
|
|
8362
|
-
};
|
|
8363
|
-
var ACROSS_COLUMN_DELTA = {
|
|
8364
|
-
left: -1,
|
|
8365
|
-
right: 1
|
|
8366
|
-
};
|
|
8367
|
-
/**
|
|
8368
|
-
* Internal composable for managing kanban drag-and-drop state.
|
|
8369
|
-
* Provides item registration, drag tracking, drop target management,
|
|
8370
|
-
* keyboard drag-and-drop, column reordering, drop validation and auto-scroll.
|
|
8371
|
-
*/
|
|
8372
|
-
function useKanban(options) {
|
|
8373
|
-
const dragState = ref(null);
|
|
8374
|
-
const columnDragState = ref(null);
|
|
8375
|
-
const isOverColumnId = ref(null);
|
|
8376
|
-
const itemRegistry = /* @__PURE__ */ new WeakMap();
|
|
8377
|
-
const itemElementsById = /* @__PURE__ */ new Map();
|
|
8378
|
-
const columnRegistry = /* @__PURE__ */ new WeakMap();
|
|
8379
|
-
const columnElementsById = /* @__PURE__ */ new Map();
|
|
8380
|
-
const columnBodyById = /* @__PURE__ */ new Map();
|
|
8381
|
-
const dragEnterCounts = /* @__PURE__ */ new Map();
|
|
8382
|
-
let boardElement = null;
|
|
8383
|
-
let clearTimer = null;
|
|
8384
|
-
const autoScroll = useKanbanAutoScroll({
|
|
8385
|
-
getBoardElement: () => boardElement,
|
|
8386
|
-
getVerticalTarget: () => {
|
|
8387
|
-
const state = unref(dragState);
|
|
8388
|
-
return state && state.dropColumnId !== null ? columnBodyById.get(state.dropColumnId) ?? null : null;
|
|
8389
|
-
}
|
|
8390
|
-
});
|
|
8391
|
-
const grabbedId = computed(() => {
|
|
8392
|
-
const state = unref(dragState);
|
|
8393
|
-
return state !== null && state.mode === "keyboard" ? state.itemId : null;
|
|
8394
|
-
});
|
|
8395
|
-
const currentMoveEvent = computed(() => tryBuildMoveEvent(unref(dragState)));
|
|
8396
|
-
const isDropAllowed = computed(() => {
|
|
8397
|
-
const event = unref(currentMoveEvent);
|
|
8398
|
-
return event === null || validateMove(event);
|
|
8399
|
-
});
|
|
8400
|
-
function tryBuildMoveEvent(state) {
|
|
8401
|
-
if (!state || state.dropColumnId === null) return null;
|
|
8402
|
-
return {
|
|
8403
|
-
itemId: state.itemId,
|
|
8404
|
-
fromColumnId: state.fromColumnId,
|
|
8405
|
-
toColumnId: state.dropColumnId,
|
|
8406
|
-
beforeItemId: state.beforeItemId ?? void 0
|
|
8407
|
-
};
|
|
8408
|
-
}
|
|
8409
|
-
function validateMove(event) {
|
|
8410
|
-
const validate = unref(options.canMove);
|
|
8411
|
-
return validate ? validate(event) : true;
|
|
8412
|
-
}
|
|
8413
|
-
function clearTimerIfAny() {
|
|
8414
|
-
if (clearTimer !== null) {
|
|
8415
|
-
clearTimeout(clearTimer);
|
|
8416
|
-
clearTimer = null;
|
|
8417
|
-
}
|
|
8418
|
-
}
|
|
8419
|
-
function isSelfDrop(state) {
|
|
8420
|
-
return state.fromColumnId === state.dropColumnId && state.beforeItemId === (state.originBeforeItemId ?? null);
|
|
8421
|
-
}
|
|
8422
|
-
function getColumnIndex(columnId) {
|
|
8423
|
-
if (!boardElement) return -1;
|
|
8424
|
-
return Array.from(boardElement.children).filter((child) => columnRegistry.has(child)).findIndex((elm) => columnRegistry.get(elm)?.columnId === columnId);
|
|
8425
|
-
}
|
|
8426
|
-
function getColumnByIndex(index) {
|
|
8427
|
-
if (!boardElement) return null;
|
|
8428
|
-
const elm = Array.from(boardElement.children).filter((child) => columnRegistry.has(child))[index];
|
|
8429
|
-
return elm ? columnRegistry.get(elm) : null;
|
|
8430
|
-
}
|
|
8431
|
-
function getItemsInColumn(columnId) {
|
|
8432
|
-
const body = columnBodyById.get(columnId);
|
|
8433
|
-
if (!body) return [];
|
|
8434
|
-
return Array.from(body.children).map((child) => itemRegistry.get(child)?.itemId).filter((id) => id !== void 0);
|
|
8435
|
-
}
|
|
8436
|
-
function registerItem(element, itemId) {
|
|
8437
|
-
itemRegistry.set(element, { itemId });
|
|
8438
|
-
itemElementsById.set(itemId, element);
|
|
8439
|
-
}
|
|
8440
|
-
function unregisterItem(element) {
|
|
8441
|
-
const info = itemRegistry.get(element);
|
|
8442
|
-
if (info) itemElementsById.delete(info.itemId);
|
|
8443
|
-
itemRegistry.delete(element);
|
|
8444
|
-
}
|
|
8445
|
-
function getItemInfo(element) {
|
|
8446
|
-
return itemRegistry.get(element);
|
|
8447
|
-
}
|
|
8448
|
-
function registerColumn(element, columnId) {
|
|
8449
|
-
columnRegistry.set(element, { columnId });
|
|
8450
|
-
columnElementsById.set(columnId, element);
|
|
8451
|
-
}
|
|
8452
|
-
function unregisterColumn(element) {
|
|
8453
|
-
const info = columnRegistry.get(element);
|
|
8454
|
-
if (info) {
|
|
8455
|
-
columnElementsById.delete(info.columnId);
|
|
8456
|
-
columnBodyById.delete(info.columnId);
|
|
8457
|
-
dragEnterCounts.delete(info.columnId);
|
|
8458
|
-
if (isOverColumnId.value === info.columnId) isOverColumnId.value = null;
|
|
8459
|
-
}
|
|
8460
|
-
columnRegistry.delete(element);
|
|
8461
|
-
}
|
|
8462
|
-
function getColumnInfo(element) {
|
|
8463
|
-
return columnRegistry.get(element);
|
|
8464
|
-
}
|
|
8465
|
-
function setBoardElement(element) {
|
|
8466
|
-
boardElement = element;
|
|
8467
|
-
}
|
|
8468
|
-
function setColumnBodyElement(columnId, element) {
|
|
8469
|
-
if (element) columnBodyById.set(columnId, element);
|
|
8470
|
-
else columnBodyById.delete(columnId);
|
|
8471
|
-
}
|
|
8472
|
-
function enterColumn(columnId) {
|
|
8473
|
-
if (unref(options.disabled)) return;
|
|
8474
|
-
const count = (dragEnterCounts.get(columnId) ?? 0) + 1;
|
|
8475
|
-
dragEnterCounts.set(columnId, count);
|
|
8476
|
-
isOverColumnId.value = columnId;
|
|
8477
|
-
}
|
|
8478
|
-
function leaveColumn(columnId) {
|
|
8479
|
-
const next = (dragEnterCounts.get(columnId) ?? 0) - 1;
|
|
8480
|
-
if (next > 0) {
|
|
8481
|
-
dragEnterCounts.set(columnId, next);
|
|
8482
|
-
return;
|
|
8483
|
-
}
|
|
8484
|
-
dragEnterCounts.delete(columnId);
|
|
8485
|
-
if (isOverColumnId.value === columnId) isOverColumnId.value = null;
|
|
8486
|
-
clearDropTarget();
|
|
8487
|
-
}
|
|
8488
|
-
function startDrag(itemId, fromColumnId) {
|
|
8489
|
-
if (unref(options.disabled)) return;
|
|
8490
|
-
clearTimerIfAny();
|
|
8491
|
-
dragState.value = {
|
|
8492
|
-
mode: "pointer",
|
|
8493
|
-
itemId,
|
|
8494
|
-
fromColumnId,
|
|
8495
|
-
dropColumnId: null,
|
|
8496
|
-
beforeItemId: null,
|
|
8497
|
-
originBeforeItemId: findCurrentBeforeItemId(itemId, fromColumnId)
|
|
8498
|
-
};
|
|
8499
|
-
}
|
|
8500
|
-
function endDrag() {
|
|
8501
|
-
clearTimerIfAny();
|
|
8502
|
-
autoScroll.stop();
|
|
8503
|
-
dragState.value = null;
|
|
8504
|
-
isOverColumnId.value = null;
|
|
8505
|
-
dragEnterCounts.clear();
|
|
8126
|
+
function endDrag() {
|
|
8127
|
+
clearTimerIfAny();
|
|
8128
|
+
autoScroll.stop();
|
|
8129
|
+
dragState.value = null;
|
|
8130
|
+
isOverColumnId.value = null;
|
|
8131
|
+
dragEnterCounts.clear();
|
|
8506
8132
|
}
|
|
8507
8133
|
function updateDropTarget(columnId, beforeItemId) {
|
|
8508
8134
|
if (!dragState.value) return;
|
|
@@ -9280,47 +8906,455 @@ function useTreeView(params) {
|
|
|
9280
8906
|
return false;
|
|
9281
8907
|
}
|
|
9282
8908
|
}
|
|
9283
|
-
watch(highlightedIndex, (index) => {
|
|
9284
|
-
if (index < 0) return;
|
|
9285
|
-
nextTick(() => unref(params.nodeElementRefs)?.[index]?.scrollIntoView({ block: "nearest" }));
|
|
9286
|
-
});
|
|
9287
|
-
watch(params.visibleNodes, (nodes) => {
|
|
9288
|
-
if (unref(highlightedIndex) >= nodes.length) highlightedIndex.value = Math.max(-1, nodes.length - 1);
|
|
9289
|
-
});
|
|
9290
|
-
return {
|
|
9291
|
-
highlightedIndex,
|
|
9292
|
-
toggleExpand,
|
|
9293
|
-
onExpandClick,
|
|
9294
|
-
onKeyNavigate
|
|
9295
|
-
};
|
|
9296
|
-
}
|
|
8909
|
+
watch(highlightedIndex, (index) => {
|
|
8910
|
+
if (index < 0) return;
|
|
8911
|
+
nextTick(() => unref(params.nodeElementRefs)?.[index]?.scrollIntoView({ block: "nearest" }));
|
|
8912
|
+
});
|
|
8913
|
+
watch(params.visibleNodes, (nodes) => {
|
|
8914
|
+
if (unref(highlightedIndex) >= nodes.length) highlightedIndex.value = Math.max(-1, nodes.length - 1);
|
|
8915
|
+
});
|
|
8916
|
+
return {
|
|
8917
|
+
highlightedIndex,
|
|
8918
|
+
toggleExpand,
|
|
8919
|
+
onExpandClick,
|
|
8920
|
+
onKeyNavigate
|
|
8921
|
+
};
|
|
8922
|
+
}
|
|
8923
|
+
//#endregion
|
|
8924
|
+
//#region src/util/createLabelForDateRange.ts
|
|
8925
|
+
function createLabelForDateRange_default(start, end, preventCustom = false) {
|
|
8926
|
+
const translate = useTranslate_default();
|
|
8927
|
+
if (start.day === end.day && start.month === end.month && start.year === end.year) return start.toLocaleString({
|
|
8928
|
+
day: "numeric",
|
|
8929
|
+
month: "short",
|
|
8930
|
+
year: "numeric"
|
|
8931
|
+
});
|
|
8932
|
+
if (start.month === end.month && start.year === end.year) return `${start.toLocaleString({ day: "numeric" })} – ${end.toLocaleString({
|
|
8933
|
+
day: "numeric",
|
|
8934
|
+
month: "short",
|
|
8935
|
+
year: "numeric"
|
|
8936
|
+
})}`;
|
|
8937
|
+
if (start.year === end.year) return `${start.toLocaleString({
|
|
8938
|
+
day: "numeric",
|
|
8939
|
+
month: "short"
|
|
8940
|
+
})} – ${end.toLocaleString({
|
|
8941
|
+
day: "numeric",
|
|
8942
|
+
month: "short",
|
|
8943
|
+
year: "numeric"
|
|
8944
|
+
})}`;
|
|
8945
|
+
if (preventCustom) return `${start.toLocaleString({
|
|
8946
|
+
day: "numeric",
|
|
8947
|
+
month: "short",
|
|
8948
|
+
year: "numeric"
|
|
8949
|
+
})} – ${end.toLocaleString({
|
|
8950
|
+
day: "numeric",
|
|
8951
|
+
month: "short",
|
|
8952
|
+
year: "numeric"
|
|
8953
|
+
})}`;
|
|
8954
|
+
return translate("flux.customPeriod");
|
|
8955
|
+
}
|
|
8956
|
+
//#endregion
|
|
8957
|
+
//#region src/util/defineFilter.ts
|
|
8958
|
+
function defineFilter(factory) {
|
|
8959
|
+
return factory;
|
|
8960
|
+
}
|
|
8961
|
+
//#endregion
|
|
8962
|
+
//#region src/util/filter.ts
|
|
8963
|
+
function isFluxFilterOptionHeader(obj) {
|
|
8964
|
+
return "title" in obj;
|
|
8965
|
+
}
|
|
8966
|
+
function isFluxFilterOptionItem(obj) {
|
|
8967
|
+
return "label" in obj && "value" in obj;
|
|
8968
|
+
}
|
|
8969
|
+
function isResettable(definition, value) {
|
|
8970
|
+
if (!definition || definition.defaultValue === void 0) return false;
|
|
8971
|
+
return !isFilterValueEqual(value, definition.defaultValue);
|
|
8972
|
+
}
|
|
8973
|
+
function isFilterValueEqual(a, b) {
|
|
8974
|
+
if (a === b) return true;
|
|
8975
|
+
if (DateTime.isDateTime(a) && DateTime.isDateTime(b)) return a.equals(b);
|
|
8976
|
+
if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((value, index) => isFilterValueEqual(value, b[index]));
|
|
8977
|
+
return false;
|
|
8978
|
+
}
|
|
8979
|
+
function pickFilterCommon(props) {
|
|
8980
|
+
return {
|
|
8981
|
+
name: props.name,
|
|
8982
|
+
label: props.label,
|
|
8983
|
+
icon: props.icon,
|
|
8984
|
+
disabled: props.disabled,
|
|
8985
|
+
defaultValue: props.defaultValue,
|
|
8986
|
+
onChange: props.onChange,
|
|
8987
|
+
onClear: props.onClear
|
|
8988
|
+
};
|
|
8989
|
+
}
|
|
8990
|
+
function generateMultiOptionsLabel(translate, options, values) {
|
|
8991
|
+
const selected = options.filter((o) => values.includes(o.value)).length;
|
|
8992
|
+
if (selected <= 0) return null;
|
|
8993
|
+
if (selected === 1) return options.find((o) => values.includes(o.value)).label;
|
|
8994
|
+
return translate("flux.nSelected", { n: selected });
|
|
8995
|
+
}
|
|
8996
|
+
//#endregion
|
|
8997
|
+
//#region src/util/sanitizeUrl.ts
|
|
8998
|
+
var DANGEROUS_PROTOCOL = /^(javascript|vbscript|data):/i;
|
|
8999
|
+
/**
|
|
9000
|
+
* Removes control characters (and the Unicode line/paragraph separators) that
|
|
9001
|
+
* browsers ignore inside URLs but which can be used to obfuscate the scheme,
|
|
9002
|
+
* e.g. `java\tscript:alert(1)`.
|
|
9003
|
+
*/
|
|
9004
|
+
function stripControlChars(value) {
|
|
9005
|
+
let out = "";
|
|
9006
|
+
for (let i = 0; i < value.length; i++) {
|
|
9007
|
+
const code = value.charCodeAt(i);
|
|
9008
|
+
if (code <= 32 || code >= 127 && code <= 159 || code === 8232 || code === 8233) continue;
|
|
9009
|
+
out += value[i];
|
|
9010
|
+
}
|
|
9011
|
+
return out;
|
|
9012
|
+
}
|
|
9013
|
+
/**
|
|
9014
|
+
* Sanitizes a URL intended for an `href` attribute. Returns `undefined` when the
|
|
9015
|
+
* URL uses a dangerous scheme (`javascript:`, `vbscript:`, `data:`) so the attribute
|
|
9016
|
+
* is omitted instead of becoming a script-execution or data-injection vector.
|
|
9017
|
+
* Safe and relative URLs are returned unchanged.
|
|
9018
|
+
*/
|
|
9019
|
+
function sanitizeUrl_default(href) {
|
|
9020
|
+
if (!href) return href;
|
|
9021
|
+
if (DANGEROUS_PROTOCOL.test(stripControlChars(href))) return;
|
|
9022
|
+
return href;
|
|
9023
|
+
}
|
|
9024
|
+
//#endregion
|
|
9025
|
+
//#region src/component/FluxPressable.vue?vue&type=script&setup=true&lang.ts
|
|
9026
|
+
var _hoisted_1$61 = [
|
|
9027
|
+
"href",
|
|
9028
|
+
"rel",
|
|
9029
|
+
"target"
|
|
9030
|
+
];
|
|
9031
|
+
//#endregion
|
|
9032
|
+
//#region src/component/FluxPressable.vue
|
|
9033
|
+
var FluxPressable_default = /* @__PURE__ */ defineComponent({
|
|
9034
|
+
__name: "FluxPressable",
|
|
9035
|
+
props: {
|
|
9036
|
+
componentType: {},
|
|
9037
|
+
href: {},
|
|
9038
|
+
rel: {},
|
|
9039
|
+
target: {},
|
|
9040
|
+
to: {}
|
|
9041
|
+
},
|
|
9042
|
+
emits: [
|
|
9043
|
+
"click",
|
|
9044
|
+
"mouseenter",
|
|
9045
|
+
"mouseleave"
|
|
9046
|
+
],
|
|
9047
|
+
setup(__props, { emit: __emit, attrs: $attrs }) {
|
|
9048
|
+
const emit = __emit;
|
|
9049
|
+
const resolvedRel = computed(() => {
|
|
9050
|
+
if (__props.rel) return __props.rel;
|
|
9051
|
+
return __props.target === "_blank" ? "noopener noreferrer" : void 0;
|
|
9052
|
+
});
|
|
9053
|
+
const hoverListeners = {
|
|
9054
|
+
onMouseenter: (evt) => emit("mouseenter", evt),
|
|
9055
|
+
onMouseleave: (evt) => emit("mouseleave", evt)
|
|
9056
|
+
};
|
|
9057
|
+
function onClick(evt, navigate) {
|
|
9058
|
+
emit("click", evt);
|
|
9059
|
+
if (evt.defaultPrevented) return;
|
|
9060
|
+
navigate?.(evt);
|
|
9061
|
+
}
|
|
9062
|
+
return (_ctx, _cache) => {
|
|
9063
|
+
const _component_router_link = resolveComponent("router-link");
|
|
9064
|
+
return __props.componentType === "route" ? (openBlock(), createBlock(_component_router_link, mergeProps({ key: 0 }, $attrs, toHandlers(hoverListeners), {
|
|
9065
|
+
rel: resolvedRel.value,
|
|
9066
|
+
target: __props.target,
|
|
9067
|
+
to: __props.to,
|
|
9068
|
+
onClick: _cache[0] || (_cache[0] = ($event) => onClick($event))
|
|
9069
|
+
}), {
|
|
9070
|
+
default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
|
|
9071
|
+
_: 3
|
|
9072
|
+
}, 16, [
|
|
9073
|
+
"rel",
|
|
9074
|
+
"target",
|
|
9075
|
+
"to"
|
|
9076
|
+
])) : __props.componentType === "link" ? (openBlock(), createElementBlock("a", mergeProps({ key: 1 }, $attrs, toHandlers(hoverListeners, true), {
|
|
9077
|
+
href: unref(sanitizeUrl_default)(__props.href),
|
|
9078
|
+
rel: resolvedRel.value,
|
|
9079
|
+
target: __props.target,
|
|
9080
|
+
onClick: _cache[1] || (_cache[1] = ($event) => onClick($event))
|
|
9081
|
+
}), [renderSlot(_ctx.$slots, "default")], 16, _hoisted_1$61)) : __props.componentType === "button" ? (openBlock(), createElementBlock("button", mergeProps({ key: 2 }, $attrs, toHandlers(hoverListeners, true), { onClick: _cache[2] || (_cache[2] = ($event) => onClick($event)) }), [renderSlot(_ctx.$slots, "default")], 16)) : (openBlock(), createElementBlock("div", mergeProps({ key: 3 }, $attrs, toHandlers(hoverListeners, true), { onClick }), [renderSlot(_ctx.$slots, "default")], 16));
|
|
9082
|
+
};
|
|
9083
|
+
}
|
|
9084
|
+
});
|
|
9085
|
+
var Spinner_module_default = {
|
|
9086
|
+
spinner: `spinner`,
|
|
9087
|
+
spinnerTrack: `spinner-track`,
|
|
9088
|
+
spinnerEffect: `spinner-effect`,
|
|
9089
|
+
spinnerValue: `spinner-value`
|
|
9090
|
+
};
|
|
9091
|
+
//#endregion
|
|
9092
|
+
//#region src/component/FluxSpinner.vue
|
|
9093
|
+
var FluxSpinner_default = /* @__PURE__ */ defineComponent({
|
|
9094
|
+
__name: "FluxSpinner",
|
|
9095
|
+
props: { size: {} },
|
|
9096
|
+
setup(__props) {
|
|
9097
|
+
return (_ctx, _cache) => {
|
|
9098
|
+
return openBlock(), createElementBlock("svg", {
|
|
9099
|
+
class: normalizeClass(unref(Spinner_module_default).spinner),
|
|
9100
|
+
viewBox: "0 0 24 24",
|
|
9101
|
+
style: normalizeStyle({ fontSize: __props.size && `${__props.size}px` })
|
|
9102
|
+
}, [
|
|
9103
|
+
createElementVNode("circle", {
|
|
9104
|
+
class: normalizeClass(unref(Spinner_module_default).spinnerTrack),
|
|
9105
|
+
cx: "12",
|
|
9106
|
+
cy: "12",
|
|
9107
|
+
r: "10",
|
|
9108
|
+
fill: "transparent",
|
|
9109
|
+
"stroke-width": "4"
|
|
9110
|
+
}, null, 2),
|
|
9111
|
+
createElementVNode("circle", {
|
|
9112
|
+
class: normalizeClass(unref(Spinner_module_default).spinnerEffect),
|
|
9113
|
+
cx: "12",
|
|
9114
|
+
cy: "12",
|
|
9115
|
+
r: "10",
|
|
9116
|
+
fill: "transparent",
|
|
9117
|
+
"stroke-width": "4",
|
|
9118
|
+
"stroke-dasharray": "21 45",
|
|
9119
|
+
"stroke-dashoffset": "30",
|
|
9120
|
+
"stroke-linecap": "round"
|
|
9121
|
+
}, null, 2),
|
|
9122
|
+
createElementVNode("circle", {
|
|
9123
|
+
class: normalizeClass(unref(Spinner_module_default).spinnerValue),
|
|
9124
|
+
cx: "12",
|
|
9125
|
+
cy: "12",
|
|
9126
|
+
r: "10",
|
|
9127
|
+
fill: "transparent",
|
|
9128
|
+
"stroke-width": "4",
|
|
9129
|
+
"stroke-dasharray": "21 45",
|
|
9130
|
+
"stroke-dashoffset": "30",
|
|
9131
|
+
"stroke-linecap": "round"
|
|
9132
|
+
}, null, 2)
|
|
9133
|
+
], 6);
|
|
9134
|
+
};
|
|
9135
|
+
}
|
|
9136
|
+
});
|
|
9137
|
+
var Button_module_default$1 = {
|
|
9138
|
+
button: `button`,
|
|
9139
|
+
isSmall: `is-small`,
|
|
9140
|
+
isMedium: `is-medium`,
|
|
9141
|
+
isLarge: `is-large`,
|
|
9142
|
+
isXl: `is-xl`,
|
|
9143
|
+
isFilled: `is-filled`,
|
|
9144
|
+
spinner: `spinner`,
|
|
9145
|
+
buttonIcon: `button-icon`,
|
|
9146
|
+
buttonLabel: `button-label`,
|
|
9147
|
+
badge: `badge`
|
|
9148
|
+
};
|
|
9149
|
+
//#endregion
|
|
9150
|
+
//#region src/component/FluxButton.vue?vue&type=script&setup=true&lang.ts
|
|
9151
|
+
var SLOTS = [
|
|
9152
|
+
"default",
|
|
9153
|
+
"after",
|
|
9154
|
+
"before",
|
|
9155
|
+
"iconLeading",
|
|
9156
|
+
"iconTrailing",
|
|
9157
|
+
"label"
|
|
9158
|
+
];
|
|
9159
|
+
//#endregion
|
|
9160
|
+
//#region src/component/FluxButton.vue
|
|
9161
|
+
var FluxButton_default = /* @__PURE__ */ defineComponent({
|
|
9162
|
+
__name: "FluxButton",
|
|
9163
|
+
props: {
|
|
9164
|
+
type: { default: "button" },
|
|
9165
|
+
disabled: { type: Boolean },
|
|
9166
|
+
iconLeading: {},
|
|
9167
|
+
iconTrailing: {},
|
|
9168
|
+
isFilled: { type: Boolean },
|
|
9169
|
+
isLoading: { type: Boolean },
|
|
9170
|
+
isSubmit: { type: Boolean },
|
|
9171
|
+
label: {},
|
|
9172
|
+
size: { default: "medium" },
|
|
9173
|
+
tabindex: { default: 0 },
|
|
9174
|
+
href: {},
|
|
9175
|
+
rel: {},
|
|
9176
|
+
target: {},
|
|
9177
|
+
to: {},
|
|
9178
|
+
cssClass: {},
|
|
9179
|
+
cssClassIcon: {},
|
|
9180
|
+
cssClassLabel: {}
|
|
9181
|
+
},
|
|
9182
|
+
emits: [
|
|
9183
|
+
"click",
|
|
9184
|
+
"mouseenter",
|
|
9185
|
+
"mouseleave"
|
|
9186
|
+
],
|
|
9187
|
+
setup(__props, { emit: __emit }) {
|
|
9188
|
+
const emit = __emit;
|
|
9189
|
+
const disabled = useDisabled_default(toRef(() => __props.disabled));
|
|
9190
|
+
function onClick(evt) {
|
|
9191
|
+
if (unref(disabled) || __props.isLoading) {
|
|
9192
|
+
evt.preventDefault();
|
|
9193
|
+
evt.stopPropagation();
|
|
9194
|
+
return;
|
|
9195
|
+
}
|
|
9196
|
+
emit("click", evt);
|
|
9197
|
+
}
|
|
9198
|
+
function onMouseEnter(evt) {
|
|
9199
|
+
emit("mouseenter", evt);
|
|
9200
|
+
}
|
|
9201
|
+
function onMouseLeave(evt) {
|
|
9202
|
+
emit("mouseleave", evt);
|
|
9203
|
+
}
|
|
9204
|
+
return (_ctx, _cache) => {
|
|
9205
|
+
return openBlock(), createBlock(FluxPressable_default, {
|
|
9206
|
+
"component-type": __props.type,
|
|
9207
|
+
class: normalizeClass(unref(clsx)(__props.cssClass, __props.isFilled && unref(Button_module_default$1).isFilled, __props.size === "small" && unref(Button_module_default$1).isSmall, __props.size === "medium" && unref(Button_module_default$1).isMedium, __props.size === "large" && unref(Button_module_default$1).isLarge, __props.size === "xl" && unref(Button_module_default$1).isXl)),
|
|
9208
|
+
type: __props.isSubmit ? "submit" : "button",
|
|
9209
|
+
"aria-disabled": unref(disabled) ? true : void 0,
|
|
9210
|
+
disabled: unref(disabled) ? true : void 0,
|
|
9211
|
+
tabindex: unref(disabled) ? -1 : __props.tabindex,
|
|
9212
|
+
href: __props.href,
|
|
9213
|
+
rel: __props.rel,
|
|
9214
|
+
target: __props.target,
|
|
9215
|
+
to: __props.to,
|
|
9216
|
+
onClick,
|
|
9217
|
+
onMouseenter: onMouseEnter,
|
|
9218
|
+
onMouseleave: onMouseLeave
|
|
9219
|
+
}, {
|
|
9220
|
+
default: withCtx(() => [
|
|
9221
|
+
renderSlot(_ctx.$slots, "before"),
|
|
9222
|
+
renderSlot(_ctx.$slots, "iconLeading", {}, () => [__props.isLoading && (__props.iconLeading || !__props.iconTrailing) ? (openBlock(), createBlock(FluxSpinner_default, {
|
|
9223
|
+
key: 0,
|
|
9224
|
+
size: 20
|
|
9225
|
+
})) : __props.iconLeading ? (openBlock(), createBlock(FluxIcon_default, {
|
|
9226
|
+
key: 1,
|
|
9227
|
+
class: normalizeClass(__props.cssClassIcon),
|
|
9228
|
+
name: __props.iconLeading
|
|
9229
|
+
}, null, 8, ["class", "name"])) : createCommentVNode("", true)]),
|
|
9230
|
+
renderSlot(_ctx.$slots, "label", {}, () => [__props.label ? (openBlock(), createElementBlock("span", {
|
|
9231
|
+
key: 0,
|
|
9232
|
+
class: normalizeClass(__props.cssClassLabel)
|
|
9233
|
+
}, toDisplayString(__props.label), 3)) : createCommentVNode("", true)]),
|
|
9234
|
+
renderSlot(_ctx.$slots, "iconTrailing", {}, () => [__props.isLoading && !__props.iconLeading && __props.iconTrailing ? (openBlock(), createBlock(FluxSpinner_default, {
|
|
9235
|
+
key: 0,
|
|
9236
|
+
size: 20
|
|
9237
|
+
})) : __props.iconTrailing ? (openBlock(), createBlock(FluxIcon_default, {
|
|
9238
|
+
key: 1,
|
|
9239
|
+
class: normalizeClass(__props.cssClassIcon),
|
|
9240
|
+
name: __props.iconTrailing
|
|
9241
|
+
}, null, 8, ["class", "name"])) : createCommentVNode("", true)]),
|
|
9242
|
+
renderSlot(_ctx.$slots, "after")
|
|
9243
|
+
]),
|
|
9244
|
+
_: 3
|
|
9245
|
+
}, 8, [
|
|
9246
|
+
"component-type",
|
|
9247
|
+
"class",
|
|
9248
|
+
"type",
|
|
9249
|
+
"aria-disabled",
|
|
9250
|
+
"disabled",
|
|
9251
|
+
"tabindex",
|
|
9252
|
+
"href",
|
|
9253
|
+
"rel",
|
|
9254
|
+
"target",
|
|
9255
|
+
"to"
|
|
9256
|
+
]);
|
|
9257
|
+
};
|
|
9258
|
+
}
|
|
9259
|
+
});
|
|
9260
|
+
//#endregion
|
|
9261
|
+
//#region src/css/component/Action.module.scss
|
|
9262
|
+
var { "button": _0$15, "buttonIcon": _1$6, "buttonLabel": _2$5 } = Button_module_default$1;
|
|
9263
|
+
var Action_module_default = {
|
|
9264
|
+
action: `action ${_0$15}`,
|
|
9265
|
+
spinner: `spinner`,
|
|
9266
|
+
actionIcon: `action-icon ${_1$6}`,
|
|
9267
|
+
isDestructive: `is-destructive`,
|
|
9268
|
+
actionLabel: `action-label ${_2$5}`,
|
|
9269
|
+
actionBar: `action-bar`,
|
|
9270
|
+
separator: `separator`,
|
|
9271
|
+
formInput: `form-input`,
|
|
9272
|
+
basePaneStructure: `base-pane-structure`,
|
|
9273
|
+
actionPane: `action-pane`,
|
|
9274
|
+
actionPaneGrid: `action-pane-grid`,
|
|
9275
|
+
actionPaneBody: `action-pane-body`,
|
|
9276
|
+
paneBody: `pane-body`
|
|
9277
|
+
};
|
|
9278
|
+
//#endregion
|
|
9279
|
+
//#region src/component/FluxAction.vue
|
|
9280
|
+
var FluxAction_default = /* @__PURE__ */ defineComponent({
|
|
9281
|
+
__name: "FluxAction",
|
|
9282
|
+
props: {
|
|
9283
|
+
type: {},
|
|
9284
|
+
disabled: { type: Boolean },
|
|
9285
|
+
isLoading: { type: Boolean },
|
|
9286
|
+
isSubmit: { type: Boolean },
|
|
9287
|
+
label: {},
|
|
9288
|
+
tabindex: {},
|
|
9289
|
+
href: {},
|
|
9290
|
+
rel: {},
|
|
9291
|
+
target: {},
|
|
9292
|
+
to: {},
|
|
9293
|
+
icon: {},
|
|
9294
|
+
isDestructive: { type: Boolean }
|
|
9295
|
+
},
|
|
9296
|
+
emits: [
|
|
9297
|
+
"click",
|
|
9298
|
+
"mouseenter",
|
|
9299
|
+
"mouseleave"
|
|
9300
|
+
],
|
|
9301
|
+
setup(__props, { emit: $emit }) {
|
|
9302
|
+
return (_ctx, _cache) => {
|
|
9303
|
+
return openBlock(), createBlock(FluxButton_default, mergeProps({
|
|
9304
|
+
disabled: __props.disabled,
|
|
9305
|
+
isLoading: __props.isLoading,
|
|
9306
|
+
label: __props.label,
|
|
9307
|
+
href: __props.href,
|
|
9308
|
+
rel: __props.rel,
|
|
9309
|
+
target: __props.target,
|
|
9310
|
+
to: __props.to,
|
|
9311
|
+
type: __props.type
|
|
9312
|
+
}, {
|
|
9313
|
+
"css-class": unref(Action_module_default).action,
|
|
9314
|
+
"css-class-icon": unref(Action_module_default).actionIcon,
|
|
9315
|
+
"css-class-label": unref(Action_module_default).actionLabel,
|
|
9316
|
+
class: __props.isDestructive && unref(Action_module_default).isDestructive,
|
|
9317
|
+
"icon-leading": __props.icon,
|
|
9318
|
+
onClick: _cache[0] || (_cache[0] = ($event) => $emit("click", $event)),
|
|
9319
|
+
onMouseenter: _cache[1] || (_cache[1] = ($event) => $emit("mouseenter", $event)),
|
|
9320
|
+
onMouseleave: _cache[2] || (_cache[2] = ($event) => $emit("mouseleave", $event))
|
|
9321
|
+
}), null, 16, [
|
|
9322
|
+
"css-class",
|
|
9323
|
+
"css-class-icon",
|
|
9324
|
+
"css-class-label",
|
|
9325
|
+
"class",
|
|
9326
|
+
"icon-leading"
|
|
9327
|
+
]);
|
|
9328
|
+
};
|
|
9329
|
+
}
|
|
9330
|
+
});
|
|
9297
9331
|
//#endregion
|
|
9298
9332
|
//#region src/css/component/Button.module.scss
|
|
9299
|
-
var { "
|
|
9333
|
+
var { "button": _0$14, "buttonIcon": _1$5, "buttonLabel": _2$4 } = Button_module_default$1;
|
|
9300
9334
|
var Button_module_default = {
|
|
9301
|
-
primaryButton: `primary-button ${
|
|
9335
|
+
primaryButton: `primary-button ${_0$14}`,
|
|
9302
9336
|
spinner: `spinner`,
|
|
9303
|
-
primaryButtonIcon: `primary-button-icon ${
|
|
9337
|
+
primaryButtonIcon: `primary-button-icon ${_1$5}`,
|
|
9304
9338
|
primaryButtonLabel: `primary-button-label ${_2$4}`,
|
|
9305
|
-
secondaryButton: `secondary-button ${
|
|
9306
|
-
secondaryButtonIcon: `secondary-button-icon ${
|
|
9339
|
+
secondaryButton: `secondary-button ${_0$14}`,
|
|
9340
|
+
secondaryButtonIcon: `secondary-button-icon ${_1$5}`,
|
|
9307
9341
|
secondaryButtonLabel: `secondary-button-label ${_2$4}`,
|
|
9308
|
-
destructiveButton: `destructive-button ${
|
|
9309
|
-
destructiveButtonIcon: `destructive-button-icon ${
|
|
9342
|
+
destructiveButton: `destructive-button ${_0$14}`,
|
|
9343
|
+
destructiveButtonIcon: `destructive-button-icon ${_1$5}`,
|
|
9310
9344
|
destructiveButtonLabel: `destructive-button-label ${_2$4}`,
|
|
9311
|
-
baseLinkButton: `base-link-button ${
|
|
9312
|
-
primaryLinkButton: `primary-link-button base-link-button ${
|
|
9313
|
-
primaryLinkButtonIcon: `primary-link-button-icon ${
|
|
9345
|
+
baseLinkButton: `base-link-button ${_0$14}`,
|
|
9346
|
+
primaryLinkButton: `primary-link-button base-link-button ${_0$14}`,
|
|
9347
|
+
primaryLinkButtonIcon: `primary-link-button-icon ${_1$5}`,
|
|
9314
9348
|
primaryLinkButtonLabel: `primary-link-button-label ${_2$4}`,
|
|
9315
|
-
secondaryLinkButton: `secondary-link-button base-link-button ${
|
|
9316
|
-
secondaryLinkButtonIcon: `secondary-link-button-icon ${
|
|
9349
|
+
secondaryLinkButton: `secondary-link-button base-link-button ${_0$14}`,
|
|
9350
|
+
secondaryLinkButtonIcon: `secondary-link-button-icon ${_1$5}`,
|
|
9317
9351
|
secondaryLinkButtonLabel: `secondary-link-button-label ${_2$4}`,
|
|
9318
|
-
linkButton: `link-button ${
|
|
9319
|
-
linkButtonIcon: `link-button-icon ${
|
|
9352
|
+
linkButton: `link-button ${_0$14}`,
|
|
9353
|
+
linkButtonIcon: `link-button-icon ${_1$5}`,
|
|
9320
9354
|
icon: `icon`,
|
|
9321
9355
|
linkButtonLabel: `link-button-label ${_2$4}`,
|
|
9322
|
-
publishButton: `publish-button primary-button ${
|
|
9323
|
-
publishButtonIcon: `publish-button-icon primary-button-icon ${
|
|
9356
|
+
publishButton: `publish-button primary-button ${_0$14}`,
|
|
9357
|
+
publishButtonIcon: `publish-button-icon primary-button-icon ${_1$5}`,
|
|
9324
9358
|
publishButtonLabel: `publish-button-label primary-button-label ${_2$4}`,
|
|
9325
9359
|
publishButtonAnimation: `publish-button-animation`,
|
|
9326
9360
|
isDone: `is-done`,
|
|
@@ -12998,249 +13032,64 @@ var Comment_module_default = {
|
|
|
12998
13032
|
isTyping: `is-typing`,
|
|
12999
13033
|
commentTyping: `comment-typing`
|
|
13000
13034
|
};
|
|
13001
|
-
//#endregion
|
|
13002
|
-
//#region src/component/FluxComment.vue?vue&type=script&setup=true&lang.ts
|
|
13003
|
-
var _hoisted_1$48 = { key: 0 };
|
|
13004
|
-
var _hoisted_2$17 = ["datetime"];
|
|
13005
|
-
//#endregion
|
|
13006
|
-
//#region src/component/FluxComment.vue
|
|
13007
|
-
var FluxComment_default = /* @__PURE__ */ defineComponent({
|
|
13008
|
-
__name: "FluxComment",
|
|
13009
|
-
props: {
|
|
13010
|
-
avatarAlt: {},
|
|
13011
|
-
avatarFallback: { default: "colorized" },
|
|
13012
|
-
avatarFallbackIcon: { default: "user" },
|
|
13013
|
-
avatarFallbackInitials: {},
|
|
13014
|
-
avatarSrc: {},
|
|
13015
|
-
isReceived: { type: Boolean },
|
|
13016
|
-
isTyping: { type: Boolean },
|
|
13017
|
-
postedBy: {},
|
|
13018
|
-
postedOn: {}
|
|
13019
|
-
},
|
|
13020
|
-
setup(__props) {
|
|
13021
|
-
const translate = useTranslate_default();
|
|
13022
|
-
const isJustNowVisible = computed(() => __props.postedOn && Math.abs(__props.postedOn.diffNow().as("seconds")) < 15);
|
|
13023
|
-
const iso = computed(() => __props.postedOn?.toISO() ?? null);
|
|
13024
|
-
const relative = computed(() => __props.postedOn?.toRelative() ?? null);
|
|
13025
|
-
return (_ctx, _cache) => {
|
|
13026
|
-
return openBlock(), createElementBlock("div", {
|
|
13027
|
-
class: normalizeClass(unref(clsx)(unref(Comment_module_default).comment, __props.isTyping && unref(Comment_module_default).isTyping, __props.isReceived && unref(Comment_module_default).isReceived)),
|
|
13028
|
-
role: "article"
|
|
13029
|
-
}, [
|
|
13030
|
-
createVNode(FluxAvatar_default, {
|
|
13031
|
-
alt: __props.avatarAlt,
|
|
13032
|
-
fallback: __props.avatarFallback,
|
|
13033
|
-
"fallback-icon": __props.avatarFallbackIcon,
|
|
13034
|
-
"fallback-initials": __props.avatarFallbackInitials,
|
|
13035
|
-
size: 42,
|
|
13036
|
-
src: __props.avatarSrc
|
|
13037
|
-
}, null, 8, [
|
|
13038
|
-
"alt",
|
|
13039
|
-
"fallback",
|
|
13040
|
-
"fallback-icon",
|
|
13041
|
-
"fallback-initials",
|
|
13042
|
-
"src"
|
|
13043
|
-
]),
|
|
13044
|
-
createElementVNode("div", { class: normalizeClass(unref(Comment_module_default).commentContent) }, [__props.isTyping ? (openBlock(), createElementBlock("div", {
|
|
13045
|
-
key: 0,
|
|
13046
|
-
class: normalizeClass(unref(Comment_module_default).commentTyping)
|
|
13047
|
-
}, null, 2)) : renderSlot(_ctx.$slots, "default", { key: 1 })], 2),
|
|
13048
|
-
createElementVNode("div", { class: normalizeClass(unref(Comment_module_default).commentFooter) }, [__props.isReceived && __props.postedBy ? (openBlock(), createElementBlock("span", _hoisted_1$48, toDisplayString(__props.postedBy), 1)) : createCommentVNode("", true), iso.value && relative.value && !__props.isTyping ? (openBlock(), createElementBlock("time", {
|
|
13049
|
-
key: 1,
|
|
13050
|
-
datetime: iso.value
|
|
13051
|
-
}, toDisplayString(isJustNowVisible.value ? unref(translate)("flux.justNow") : relative.value), 9, _hoisted_2$17)) : createCommentVNode("", true)], 2)
|
|
13052
|
-
], 2);
|
|
13053
|
-
};
|
|
13054
|
-
}
|
|
13055
|
-
});
|
|
13056
|
-
var Slider_module_default = {
|
|
13057
|
-
slider: `slider`,
|
|
13058
|
-
isDisabled: `is-disabled`,
|
|
13059
|
-
isDragging: `is-dragging`,
|
|
13060
|
-
sliderThumb: `slider-thumb`,
|
|
13061
|
-
sliderTrack: `slider-track`,
|
|
13062
|
-
sliderTrackValue: `slider-track-value`,
|
|
13063
|
-
tick: `tick`,
|
|
13064
|
-
tickLarge: `tick-large tick`,
|
|
13065
|
-
tickSmall: `tick-small tick`,
|
|
13066
|
-
ticks: `ticks`
|
|
13067
|
-
};
|
|
13068
|
-
//#endregion
|
|
13069
|
-
//#region src/css/component/primitive/CoordinatePicker.module.scss
|
|
13070
|
-
var { "sliderThumb": _0$10 } = Slider_module_default;
|
|
13071
|
-
var CoordinatePicker_module_default = {
|
|
13072
|
-
coordinatePicker: `coordinate-picker`,
|
|
13073
|
-
coordinatePickerThumb: `coordinate-picker-thumb ${_0$10}`,
|
|
13074
|
-
isDisabled: `is-disabled`,
|
|
13075
|
-
isDragging: `is-dragging`
|
|
13076
|
-
};
|
|
13077
|
-
//#endregion
|
|
13078
|
-
//#region src/component/primitive/CoordinatePickerThumb.vue?vue&type=script&setup=true&lang.ts
|
|
13079
|
-
var _hoisted_1$47 = [
|
|
13080
|
-
"aria-disabled",
|
|
13081
|
-
"aria-valuetext",
|
|
13082
|
-
"tabindex"
|
|
13083
|
-
];
|
|
13084
|
-
//#endregion
|
|
13085
|
-
//#region src/component/primitive/CoordinatePickerThumb.vue
|
|
13086
|
-
var CoordinatePickerThumb_default = /* @__PURE__ */ defineComponent({
|
|
13087
|
-
__name: "CoordinatePickerThumb",
|
|
13088
|
-
props: {
|
|
13089
|
-
disabled: { type: Boolean },
|
|
13090
|
-
isDragging: { type: Boolean },
|
|
13091
|
-
position: {}
|
|
13092
|
-
},
|
|
13093
|
-
emits: [
|
|
13094
|
-
"decrement",
|
|
13095
|
-
"grab",
|
|
13096
|
-
"increment"
|
|
13097
|
-
],
|
|
13098
|
-
setup(__props, { emit: __emit }) {
|
|
13099
|
-
const $emit = __emit;
|
|
13100
|
-
const emit = __emit;
|
|
13101
|
-
const disabled = useDisabled_default(toRef(() => __props.disabled));
|
|
13102
|
-
function onKeyDown(evt) {
|
|
13103
|
-
if (unref(disabled)) return;
|
|
13104
|
-
switch (evt.key) {
|
|
13105
|
-
case "ArrowUp":
|
|
13106
|
-
emit("decrement", false, true);
|
|
13107
|
-
break;
|
|
13108
|
-
case "ArrowDown":
|
|
13109
|
-
emit("increment", false, true);
|
|
13110
|
-
break;
|
|
13111
|
-
case "ArrowLeft":
|
|
13112
|
-
emit("decrement", true, false);
|
|
13113
|
-
break;
|
|
13114
|
-
case "ArrowRight":
|
|
13115
|
-
emit("increment", true, false);
|
|
13116
|
-
break;
|
|
13117
|
-
default: return;
|
|
13118
|
-
}
|
|
13119
|
-
evt.preventDefault();
|
|
13120
|
-
}
|
|
13121
|
-
return (_ctx, _cache) => {
|
|
13122
|
-
return openBlock(), createElementBlock("button", {
|
|
13123
|
-
class: normalizeClass(unref(clsx)(unref(CoordinatePicker_module_default).coordinatePickerThumb, unref(disabled) && unref(CoordinatePicker_module_default).isDisabled, __props.isDragging && unref(CoordinatePicker_module_default).isDragging)),
|
|
13124
|
-
style: normalizeStyle({
|
|
13125
|
-
top: `${__props.position[1] * 100}%`,
|
|
13126
|
-
left: `${__props.position[0] * 100}%`
|
|
13127
|
-
}),
|
|
13128
|
-
role: "slider",
|
|
13129
|
-
"aria-disabled": unref(disabled) ? true : void 0,
|
|
13130
|
-
"aria-valuetext": `X: ${Math.round(__props.position[0] * 100)}%, Y: ${Math.round(__props.position[1] * 100)}%`,
|
|
13131
|
-
tabindex: unref(disabled) ? -1 : 0,
|
|
13132
|
-
type: "button",
|
|
13133
|
-
onKeydown: onKeyDown,
|
|
13134
|
-
onPointerdown: _cache[0] || (_cache[0] = ($event) => $emit("grab", $event))
|
|
13135
|
-
}, null, 46, _hoisted_1$47);
|
|
13136
|
-
};
|
|
13137
|
-
}
|
|
13138
|
-
});
|
|
13139
|
-
//#endregion
|
|
13140
|
-
//#region src/component/primitive/CoordinatePicker.vue?vue&type=script&setup=true&lang.ts
|
|
13141
|
-
var _hoisted_1$46 = ["aria-disabled", "aria-label"];
|
|
13142
|
-
//#endregion
|
|
13143
|
-
//#region src/component/primitive/CoordinatePicker.vue
|
|
13144
|
-
var CoordinatePicker_default = /* @__PURE__ */ defineComponent({
|
|
13145
|
-
__name: "CoordinatePicker",
|
|
13146
|
-
props: /* @__PURE__ */ mergeModels({
|
|
13147
|
-
ariaLabel: {},
|
|
13148
|
-
disabled: { type: Boolean },
|
|
13149
|
-
max: { default: 100 },
|
|
13150
|
-
min: { default: 0 },
|
|
13151
|
-
step: { default: 1 }
|
|
13152
|
-
}, {
|
|
13153
|
-
"modelValue": { default: [0, 0] },
|
|
13154
|
-
"modelModifiers": {}
|
|
13155
|
-
}),
|
|
13156
|
-
emits: /* @__PURE__ */ mergeModels(["dragging"], ["update:modelValue"]),
|
|
13157
|
-
setup(__props, { emit: __emit }) {
|
|
13158
|
-
const emit = __emit;
|
|
13159
|
-
const modelValue = useModel(__props, "modelValue");
|
|
13160
|
-
const disabled = useDisabled_default(toRef(() => __props.disabled));
|
|
13161
|
-
const rootRef = useTemplateRef("root");
|
|
13162
|
-
const isDragging = ref(false);
|
|
13163
|
-
const max = computed(() => Array.isArray(__props.max) ? __props.max : [__props.max, __props.max]);
|
|
13164
|
-
const min = computed(() => Array.isArray(__props.min) ? __props.min : [__props.min, __props.min]);
|
|
13165
|
-
const step = computed(() => Array.isArray(__props.step) ? __props.step : [__props.step, __props.step]);
|
|
13166
|
-
const thumbPosition = computed(() => [(unref(modelValue)[0] - unref(min)[0]) / (unref(max)[0] - unref(min)[0]), (unref(modelValue)[1] - unref(min)[1]) / (unref(max)[1] - unref(min)[1])]);
|
|
13167
|
-
function onDecrement(x, y) {
|
|
13168
|
-
if (unref(disabled)) return;
|
|
13169
|
-
let [valueX, valueY] = unref(modelValue);
|
|
13170
|
-
const [maxX, maxY] = unref(max);
|
|
13171
|
-
const [minX, minY] = unref(min);
|
|
13172
|
-
const [stepX, stepY] = unref(step);
|
|
13173
|
-
if (x) valueX = +t$1(Math.max(minX, Math.min(maxX, valueX - stepX)), stepX).toPrecision(4);
|
|
13174
|
-
if (y) valueY = +t$1(Math.max(minY, Math.min(maxY, valueY - stepY)), stepY).toPrecision(4);
|
|
13175
|
-
modelValue.value = [valueX, valueY];
|
|
13176
|
-
}
|
|
13177
|
-
function onIncrement(x, y) {
|
|
13178
|
-
if (unref(disabled)) return;
|
|
13179
|
-
let [valueX, valueY] = unref(modelValue);
|
|
13180
|
-
const [maxX, maxY] = unref(max);
|
|
13181
|
-
const [minX, minY] = unref(min);
|
|
13182
|
-
const [stepX, stepY] = unref(step);
|
|
13183
|
-
if (x) valueX = +t$1(Math.max(minX, Math.min(maxX, valueX + stepX)), stepX).toPrecision(4);
|
|
13184
|
-
if (y) valueY = +t$1(Math.max(minY, Math.min(maxY, valueY + stepY)), stepY).toPrecision(4);
|
|
13185
|
-
modelValue.value = [valueX, valueY];
|
|
13186
|
-
}
|
|
13187
|
-
function onPointerDown(evt) {
|
|
13188
|
-
if (unref(disabled)) return;
|
|
13189
|
-
isDragging.value = true;
|
|
13190
|
-
document.addEventListener("pointermove", onPointerMove);
|
|
13191
|
-
document.addEventListener("pointerup", onPointerUp, { passive: true });
|
|
13192
|
-
requestAnimationFrame(() => onPointerMove(evt));
|
|
13193
|
-
}
|
|
13194
|
-
function onPointerMove(evt) {
|
|
13195
|
-
const root = _$2(rootRef);
|
|
13196
|
-
if (!unref(isDragging) || !root) return;
|
|
13197
|
-
const [maxX, maxY] = unref(max);
|
|
13198
|
-
const [minX, minY] = unref(min);
|
|
13199
|
-
const [stepX, stepY] = unref(step);
|
|
13200
|
-
let { top, left, width, height } = root.getBoundingClientRect();
|
|
13201
|
-
top += 6;
|
|
13202
|
-
left += 6;
|
|
13203
|
-
width -= 12;
|
|
13204
|
-
height -= 12;
|
|
13205
|
-
const x = Math.max(0, Math.min(1, (evt.clientX - left) / width));
|
|
13206
|
-
const y = Math.max(0, Math.min(1, (evt.clientY - top) / height));
|
|
13207
|
-
modelValue.value = [+t$1(x * (maxX - minX) + minX, stepX).toPrecision(4), +t$1(y * (maxY - minY) + minY, stepY).toPrecision(4)];
|
|
13208
|
-
evt.preventDefault();
|
|
13209
|
-
}
|
|
13210
|
-
function onPointerUp() {
|
|
13211
|
-
isDragging.value = false;
|
|
13212
|
-
document.removeEventListener("pointermove", onPointerMove);
|
|
13213
|
-
document.removeEventListener("pointerup", onPointerUp);
|
|
13214
|
-
}
|
|
13215
|
-
watch(isDragging, (isDragging) => emit("dragging", isDragging));
|
|
13216
|
-
onUnmounted(() => {
|
|
13217
|
-
document.removeEventListener("pointermove", onPointerMove);
|
|
13218
|
-
document.removeEventListener("pointerup", onPointerUp);
|
|
13219
|
-
});
|
|
13035
|
+
//#endregion
|
|
13036
|
+
//#region src/component/FluxComment.vue?vue&type=script&setup=true&lang.ts
|
|
13037
|
+
var _hoisted_1$48 = { key: 0 };
|
|
13038
|
+
var _hoisted_2$17 = ["datetime"];
|
|
13039
|
+
//#endregion
|
|
13040
|
+
//#region src/component/FluxComment.vue
|
|
13041
|
+
var FluxComment_default = /* @__PURE__ */ defineComponent({
|
|
13042
|
+
__name: "FluxComment",
|
|
13043
|
+
props: {
|
|
13044
|
+
avatarAlt: {},
|
|
13045
|
+
avatarFallback: { default: "colorized" },
|
|
13046
|
+
avatarFallbackIcon: { default: "user" },
|
|
13047
|
+
avatarFallbackInitials: {},
|
|
13048
|
+
avatarSrc: {},
|
|
13049
|
+
isReceived: { type: Boolean },
|
|
13050
|
+
isTyping: { type: Boolean },
|
|
13051
|
+
postedBy: {},
|
|
13052
|
+
postedOn: {}
|
|
13053
|
+
},
|
|
13054
|
+
setup(__props) {
|
|
13055
|
+
const translate = useTranslate_default();
|
|
13056
|
+
const isJustNowVisible = computed(() => __props.postedOn && Math.abs(__props.postedOn.diffNow().as("seconds")) < 15);
|
|
13057
|
+
const iso = computed(() => __props.postedOn?.toISO() ?? null);
|
|
13058
|
+
const relative = computed(() => __props.postedOn?.toRelative() ?? null);
|
|
13220
13059
|
return (_ctx, _cache) => {
|
|
13221
13060
|
return openBlock(), createElementBlock("div", {
|
|
13222
|
-
|
|
13223
|
-
|
|
13224
|
-
|
|
13225
|
-
|
|
13226
|
-
|
|
13227
|
-
|
|
13228
|
-
|
|
13229
|
-
|
|
13230
|
-
|
|
13231
|
-
|
|
13232
|
-
|
|
13233
|
-
|
|
13234
|
-
|
|
13235
|
-
|
|
13236
|
-
|
|
13237
|
-
|
|
13061
|
+
class: normalizeClass(unref(clsx)(unref(Comment_module_default).comment, __props.isTyping && unref(Comment_module_default).isTyping, __props.isReceived && unref(Comment_module_default).isReceived)),
|
|
13062
|
+
role: "article"
|
|
13063
|
+
}, [
|
|
13064
|
+
createVNode(FluxAvatar_default, {
|
|
13065
|
+
alt: __props.avatarAlt,
|
|
13066
|
+
fallback: __props.avatarFallback,
|
|
13067
|
+
"fallback-icon": __props.avatarFallbackIcon,
|
|
13068
|
+
"fallback-initials": __props.avatarFallbackInitials,
|
|
13069
|
+
size: 42,
|
|
13070
|
+
src: __props.avatarSrc
|
|
13071
|
+
}, null, 8, [
|
|
13072
|
+
"alt",
|
|
13073
|
+
"fallback",
|
|
13074
|
+
"fallback-icon",
|
|
13075
|
+
"fallback-initials",
|
|
13076
|
+
"src"
|
|
13077
|
+
]),
|
|
13078
|
+
createElementVNode("div", { class: normalizeClass(unref(Comment_module_default).commentContent) }, [__props.isTyping ? (openBlock(), createElementBlock("div", {
|
|
13079
|
+
key: 0,
|
|
13080
|
+
class: normalizeClass(unref(Comment_module_default).commentTyping)
|
|
13081
|
+
}, null, 2)) : renderSlot(_ctx.$slots, "default", { key: 1 })], 2),
|
|
13082
|
+
createElementVNode("div", { class: normalizeClass(unref(Comment_module_default).commentFooter) }, [__props.isReceived && __props.postedBy ? (openBlock(), createElementBlock("span", _hoisted_1$48, toDisplayString(__props.postedBy), 1)) : createCommentVNode("", true), iso.value && relative.value && !__props.isTyping ? (openBlock(), createElementBlock("time", {
|
|
13083
|
+
key: 1,
|
|
13084
|
+
datetime: iso.value
|
|
13085
|
+
}, toDisplayString(isJustNowVisible.value ? unref(translate)("flux.justNow") : relative.value), 9, _hoisted_2$17)) : createCommentVNode("", true)], 2)
|
|
13086
|
+
], 2);
|
|
13238
13087
|
};
|
|
13239
13088
|
}
|
|
13240
13089
|
});
|
|
13241
13090
|
//#endregion
|
|
13242
13091
|
//#region src/component/FluxFormFieldAddition.vue?vue&type=script&setup=true&lang.ts
|
|
13243
|
-
var _hoisted_1$
|
|
13092
|
+
var _hoisted_1$47 = { key: 1 };
|
|
13244
13093
|
//#endregion
|
|
13245
13094
|
//#region src/component/FluxFormFieldAddition.vue
|
|
13246
13095
|
var FluxFormFieldAddition_default = /* @__PURE__ */ defineComponent({
|
|
@@ -13262,7 +13111,7 @@ var FluxFormFieldAddition_default = /* @__PURE__ */ defineComponent({
|
|
|
13262
13111
|
name: __props.icon,
|
|
13263
13112
|
size: 16
|
|
13264
13113
|
}, null, 8, ["class", "name"])) : createCommentVNode("", true),
|
|
13265
|
-
__props.message ? (openBlock(), createElementBlock("span", _hoisted_1$
|
|
13114
|
+
__props.message ? (openBlock(), createElementBlock("span", _hoisted_1$47, toDisplayString(__props.message), 1)) : createCommentVNode("", true),
|
|
13266
13115
|
renderSlot(_ctx.$slots, "default")
|
|
13267
13116
|
], 2);
|
|
13268
13117
|
};
|
|
@@ -13270,7 +13119,7 @@ var FluxFormFieldAddition_default = /* @__PURE__ */ defineComponent({
|
|
|
13270
13119
|
});
|
|
13271
13120
|
//#endregion
|
|
13272
13121
|
//#region src/component/FluxFormField.vue?vue&type=script&setup=true&lang.ts
|
|
13273
|
-
var _hoisted_1$
|
|
13122
|
+
var _hoisted_1$46 = ["for"];
|
|
13274
13123
|
//#endregion
|
|
13275
13124
|
//#region src/component/FluxFormField.vue
|
|
13276
13125
|
var FluxFormField_default = /* @__PURE__ */ defineComponent({
|
|
@@ -13294,13 +13143,16 @@ var FluxFormField_default = /* @__PURE__ */ defineComponent({
|
|
|
13294
13143
|
for: unref(id),
|
|
13295
13144
|
class: normalizeClass(unref(Form_module_default).formFieldHeader)
|
|
13296
13145
|
}, [
|
|
13297
|
-
|
|
13298
|
-
__props.isOptional ? (openBlock(), createElementBlock("span", {
|
|
13146
|
+
__props.label ? (openBlock(), createElementBlock("span", {
|
|
13299
13147
|
key: 0,
|
|
13148
|
+
class: normalizeClass(unref(Form_module_default).formFieldLabel)
|
|
13149
|
+
}, toDisplayString(__props.label), 3)) : createCommentVNode("", true),
|
|
13150
|
+
__props.isOptional ? (openBlock(), createElementBlock("span", {
|
|
13151
|
+
key: 1,
|
|
13300
13152
|
class: normalizeClass(unref(Form_module_default).formFieldOptional)
|
|
13301
13153
|
}, " (" + toDisplayString(unref(translate)("flux.optional")) + ") ", 3)) : createCommentVNode("", true),
|
|
13302
13154
|
"value" in slots ? (openBlock(), createElementBlock("span", {
|
|
13303
|
-
key:
|
|
13155
|
+
key: 2,
|
|
13304
13156
|
class: normalizeClass(unref(Form_module_default).formFieldValue)
|
|
13305
13157
|
}, [renderSlot(_ctx.$slots, "value", normalizeProps(guardReactiveProps({
|
|
13306
13158
|
currentLength: __props.currentLength,
|
|
@@ -13311,7 +13163,7 @@ var FluxFormField_default = /* @__PURE__ */ defineComponent({
|
|
|
13311
13163
|
label: __props.label,
|
|
13312
13164
|
maxLength: __props.maxLength
|
|
13313
13165
|
})))], 2)) : createCommentVNode("", true)
|
|
13314
|
-
], 10, _hoisted_1$
|
|
13166
|
+
], 10, _hoisted_1$46),
|
|
13315
13167
|
renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps({ id: unref(id) }))),
|
|
13316
13168
|
__props.currentLength && __props.maxLength && __props.maxLength > 0 ? (openBlock(), createElementBlock("span", {
|
|
13317
13169
|
key: 0,
|
|
@@ -13343,7 +13195,7 @@ var FluxFormField_default = /* @__PURE__ */ defineComponent({
|
|
|
13343
13195
|
});
|
|
13344
13196
|
//#endregion
|
|
13345
13197
|
//#region src/component/FluxFormInput.vue?vue&type=script&setup=true&lang.ts
|
|
13346
|
-
var _hoisted_1$
|
|
13198
|
+
var _hoisted_1$45 = ["aria-disabled"];
|
|
13347
13199
|
var _hoisted_2$16 = [
|
|
13348
13200
|
"id",
|
|
13349
13201
|
"name",
|
|
@@ -13547,7 +13399,7 @@ var FluxFormInput_default = /* @__PURE__ */ defineComponent({
|
|
|
13547
13399
|
class: normalizeClass(unref(Form_module_default).formInputIconTrailing),
|
|
13548
13400
|
size: 18
|
|
13549
13401
|
}, null, 8, ["class"])) : createCommentVNode("", true)
|
|
13550
|
-
], 10, _hoisted_1$
|
|
13402
|
+
], 10, _hoisted_1$45);
|
|
13551
13403
|
};
|
|
13552
13404
|
}
|
|
13553
13405
|
});
|
|
@@ -13718,7 +13570,7 @@ var FluxPaneFooter_default = /* @__PURE__ */ defineComponent({
|
|
|
13718
13570
|
});
|
|
13719
13571
|
//#endregion
|
|
13720
13572
|
//#region src/component/FluxPaneHeader.vue?vue&type=script&setup=true&lang.ts
|
|
13721
|
-
var _hoisted_1$
|
|
13573
|
+
var _hoisted_1$44 = { key: 0 };
|
|
13722
13574
|
var _hoisted_2$15 = { key: 1 };
|
|
13723
13575
|
//#endregion
|
|
13724
13576
|
//#region src/component/FluxPaneHeader.vue
|
|
@@ -13742,7 +13594,7 @@ var FluxPaneHeader_default = /* @__PURE__ */ defineComponent({
|
|
|
13742
13594
|
__props.title || __props.subtitle ? (openBlock(), createElementBlock("div", {
|
|
13743
13595
|
key: 1,
|
|
13744
13596
|
class: normalizeClass(unref(Pane_module_default).paneHeaderCaption)
|
|
13745
|
-
}, [__props.title ? (openBlock(), createElementBlock("strong", _hoisted_1$
|
|
13597
|
+
}, [__props.title ? (openBlock(), createElementBlock("strong", _hoisted_1$44, toDisplayString(__props.title), 1)) : createCommentVNode("", true), __props.subtitle ? (openBlock(), createElementBlock("span", _hoisted_2$15, toDisplayString(__props.subtitle), 1)) : createCommentVNode("", true)], 2)) : createCommentVNode("", true),
|
|
13746
13598
|
renderSlot(_ctx.$slots, "after")
|
|
13747
13599
|
], 2);
|
|
13748
13600
|
};
|
|
@@ -13765,10 +13617,10 @@ var DialogLayout_default = /* @__PURE__ */ defineComponent({
|
|
|
13765
13617
|
icon: __props.icon,
|
|
13766
13618
|
title: __props.title
|
|
13767
13619
|
}, null, 8, ["icon", "title"]),
|
|
13768
|
-
__props.message ? (openBlock(), createBlock(FluxPaneBody_default, {
|
|
13769
|
-
|
|
13770
|
-
|
|
13771
|
-
}
|
|
13620
|
+
__props.message ? (openBlock(), createBlock(FluxPaneBody_default, { key: 0 }, {
|
|
13621
|
+
default: withCtx(() => [createTextVNode(toDisplayString(__props.message), 1)]),
|
|
13622
|
+
_: 1
|
|
13623
|
+
})) : createCommentVNode("", true),
|
|
13772
13624
|
$slots.default ? (openBlock(), createBlock(FluxPaneBody_default, { key: 1 }, {
|
|
13773
13625
|
default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
|
|
13774
13626
|
_: 3
|
|
@@ -13853,7 +13705,7 @@ var FilterBadge_default = /* @__PURE__ */ defineComponent({
|
|
|
13853
13705
|
});
|
|
13854
13706
|
//#endregion
|
|
13855
13707
|
//#region src/css/component/Menu.module.scss
|
|
13856
|
-
var { "
|
|
13708
|
+
var { "button": _0$10, "buttonIcon": _1$3, "buttonLabel": _2$2 } = Button_module_default$1;
|
|
13857
13709
|
var Menu_module_default = {
|
|
13858
13710
|
menu: `menu`,
|
|
13859
13711
|
menuNormal: `menu-normal menu`,
|
|
@@ -13861,9 +13713,9 @@ var Menu_module_default = {
|
|
|
13861
13713
|
menuGroup: `menu-group`,
|
|
13862
13714
|
menuGroupHorizontal: `menu-group-horizontal menu-group`,
|
|
13863
13715
|
menuGroupVertical: `menu-group-vertical menu-group`,
|
|
13864
|
-
menuItem: `menu-item ${
|
|
13716
|
+
menuItem: `menu-item ${_0$10}`,
|
|
13865
13717
|
badge: `badge`,
|
|
13866
|
-
menuItemIcon: `menu-item-icon ${
|
|
13718
|
+
menuItemIcon: `menu-item-icon ${_1$3}`,
|
|
13867
13719
|
menuItemLabel: `menu-item-label ${_2$2}`,
|
|
13868
13720
|
menuItemActive: `menu-item-active`,
|
|
13869
13721
|
menuItemDestructive: `menu-item-destructive`,
|
|
@@ -13873,7 +13725,7 @@ var Menu_module_default = {
|
|
|
13873
13725
|
menuCollapsibleOpened: `menu-collapsible-opened menu-collapsible`,
|
|
13874
13726
|
menuCollapsibleBody: `menu-collapsible-body`,
|
|
13875
13727
|
menuCollapsibleContent: `menu-collapsible-content`,
|
|
13876
|
-
menuItemSelectableIcon: `menu-item-selectable-icon ${
|
|
13728
|
+
menuItemSelectableIcon: `menu-item-selectable-icon ${_1$3}`,
|
|
13877
13729
|
menuItemSelected: `menu-item-selected`,
|
|
13878
13730
|
menuItemCommand: `menu-item-command`,
|
|
13879
13731
|
menuItemCommandIcon: `menu-item-command-icon`,
|
|
@@ -13905,7 +13757,7 @@ var FluxMenuGroup_default = /* @__PURE__ */ defineComponent({
|
|
|
13905
13757
|
});
|
|
13906
13758
|
//#endregion
|
|
13907
13759
|
//#region src/component/FluxMenuItem.vue?vue&type=script&setup=true&lang.ts
|
|
13908
|
-
var _hoisted_1$
|
|
13760
|
+
var _hoisted_1$43 = ["src", "alt"];
|
|
13909
13761
|
//#endregion
|
|
13910
13762
|
//#region src/component/FluxMenuItem.vue
|
|
13911
13763
|
var FluxMenuItem_default = /* @__PURE__ */ defineComponent({
|
|
@@ -13982,7 +13834,7 @@ var FluxMenuItem_default = /* @__PURE__ */ defineComponent({
|
|
|
13982
13834
|
class: normalizeClass(unref(Menu_module_default).menuItemImage),
|
|
13983
13835
|
src: __props.imageSrc,
|
|
13984
13836
|
alt: __props.imageAlt ?? ""
|
|
13985
|
-
}, null, 10, _hoisted_1$
|
|
13837
|
+
}, null, 10, _hoisted_1$43)]),
|
|
13986
13838
|
key: "1"
|
|
13987
13839
|
} : slots.before ? {
|
|
13988
13840
|
name: "iconLeading",
|
|
@@ -14388,6 +14240,18 @@ var SelectBase_default = /* @__PURE__ */ defineComponent({
|
|
|
14388
14240
|
};
|
|
14389
14241
|
}
|
|
14390
14242
|
});
|
|
14243
|
+
var Slider_module_default = {
|
|
14244
|
+
slider: `slider`,
|
|
14245
|
+
isDisabled: `is-disabled`,
|
|
14246
|
+
isDragging: `is-dragging`,
|
|
14247
|
+
sliderThumb: `slider-thumb`,
|
|
14248
|
+
sliderTrack: `slider-track`,
|
|
14249
|
+
sliderTrackValue: `slider-track-value`,
|
|
14250
|
+
tick: `tick`,
|
|
14251
|
+
tickLarge: `tick-large tick`,
|
|
14252
|
+
tickSmall: `tick-small tick`,
|
|
14253
|
+
ticks: `ticks`
|
|
14254
|
+
};
|
|
14391
14255
|
//#endregion
|
|
14392
14256
|
//#region src/component/FluxTicks.vue
|
|
14393
14257
|
var FluxTicks_default = /* @__PURE__ */ defineComponent({
|
|
@@ -14418,7 +14282,7 @@ var FluxTicks_default = /* @__PURE__ */ defineComponent({
|
|
|
14418
14282
|
});
|
|
14419
14283
|
//#endregion
|
|
14420
14284
|
//#region src/component/primitive/SliderBase.vue?vue&type=script&setup=true&lang.ts
|
|
14421
|
-
var _hoisted_1$
|
|
14285
|
+
var _hoisted_1$42 = ["aria-disabled"];
|
|
14422
14286
|
//#endregion
|
|
14423
14287
|
//#region src/component/primitive/SliderBase.vue
|
|
14424
14288
|
var SliderBase_default = /* @__PURE__ */ defineComponent({
|
|
@@ -14471,13 +14335,13 @@ var SliderBase_default = /* @__PURE__ */ defineComponent({
|
|
|
14471
14335
|
key: 0,
|
|
14472
14336
|
lower: __props.min,
|
|
14473
14337
|
upper: __props.max
|
|
14474
|
-
}, null, 8, ["lower", "upper"])) : createCommentVNode("", true), renderSlot(_ctx.$slots, "default")], 42, _hoisted_1$
|
|
14338
|
+
}, null, 8, ["lower", "upper"])) : createCommentVNode("", true), renderSlot(_ctx.$slots, "default")], 42, _hoisted_1$42);
|
|
14475
14339
|
};
|
|
14476
14340
|
}
|
|
14477
14341
|
});
|
|
14478
14342
|
//#endregion
|
|
14479
14343
|
//#region src/component/primitive/SliderThumb.vue?vue&type=script&setup=true&lang.ts
|
|
14480
|
-
var _hoisted_1$
|
|
14344
|
+
var _hoisted_1$41 = [
|
|
14481
14345
|
"aria-disabled",
|
|
14482
14346
|
"aria-label",
|
|
14483
14347
|
"aria-valuemax",
|
|
@@ -14536,7 +14400,7 @@ var SliderThumb_default = /* @__PURE__ */ defineComponent({
|
|
|
14536
14400
|
type: "button",
|
|
14537
14401
|
onKeydown: onKeyDown,
|
|
14538
14402
|
onPointerdown: _cache[0] || (_cache[0] = ($event) => $emit("grab", $event))
|
|
14539
|
-
}, null, 46, _hoisted_1$
|
|
14403
|
+
}, null, 46, _hoisted_1$41);
|
|
14540
14404
|
};
|
|
14541
14405
|
}
|
|
14542
14406
|
});
|
|
@@ -14641,7 +14505,7 @@ var Divider_module_default = {
|
|
|
14641
14505
|
};
|
|
14642
14506
|
//#endregion
|
|
14643
14507
|
//#region src/component/FluxSeparator.vue?vue&type=script&setup=true&lang.ts
|
|
14644
|
-
var _hoisted_1$
|
|
14508
|
+
var _hoisted_1$40 = ["aria-orientation"];
|
|
14645
14509
|
//#endregion
|
|
14646
14510
|
//#region src/component/FluxSeparator.vue
|
|
14647
14511
|
var FluxSeparator_default = /* @__PURE__ */ defineComponent({
|
|
@@ -14653,7 +14517,7 @@ var FluxSeparator_default = /* @__PURE__ */ defineComponent({
|
|
|
14653
14517
|
class: normalizeClass(__props.direction === "horizontal" ? unref(Divider_module_default).separatorHorizontal : unref(Divider_module_default).separatorVertical),
|
|
14654
14518
|
role: "separator",
|
|
14655
14519
|
"aria-orientation": __props.direction
|
|
14656
|
-
}, null, 10, _hoisted_1$
|
|
14520
|
+
}, null, 10, _hoisted_1$40);
|
|
14657
14521
|
};
|
|
14658
14522
|
}
|
|
14659
14523
|
});
|
|
@@ -14887,6 +14751,179 @@ var FluxFormSlider_default = /* @__PURE__ */ defineComponent({
|
|
|
14887
14751
|
};
|
|
14888
14752
|
}
|
|
14889
14753
|
});
|
|
14754
|
+
//#endregion
|
|
14755
|
+
//#region src/css/component/primitive/CoordinatePicker.module.scss
|
|
14756
|
+
var { "sliderThumb": _0$9 } = Slider_module_default;
|
|
14757
|
+
var CoordinatePicker_module_default = {
|
|
14758
|
+
coordinatePicker: `coordinate-picker`,
|
|
14759
|
+
coordinatePickerThumb: `coordinate-picker-thumb ${_0$9}`,
|
|
14760
|
+
isDisabled: `is-disabled`,
|
|
14761
|
+
isDragging: `is-dragging`
|
|
14762
|
+
};
|
|
14763
|
+
//#endregion
|
|
14764
|
+
//#region src/component/primitive/CoordinatePickerThumb.vue?vue&type=script&setup=true&lang.ts
|
|
14765
|
+
var _hoisted_1$39 = [
|
|
14766
|
+
"aria-disabled",
|
|
14767
|
+
"aria-valuetext",
|
|
14768
|
+
"tabindex"
|
|
14769
|
+
];
|
|
14770
|
+
//#endregion
|
|
14771
|
+
//#region src/component/primitive/CoordinatePickerThumb.vue
|
|
14772
|
+
var CoordinatePickerThumb_default = /* @__PURE__ */ defineComponent({
|
|
14773
|
+
__name: "CoordinatePickerThumb",
|
|
14774
|
+
props: {
|
|
14775
|
+
disabled: { type: Boolean },
|
|
14776
|
+
isDragging: { type: Boolean },
|
|
14777
|
+
position: {}
|
|
14778
|
+
},
|
|
14779
|
+
emits: [
|
|
14780
|
+
"decrement",
|
|
14781
|
+
"grab",
|
|
14782
|
+
"increment"
|
|
14783
|
+
],
|
|
14784
|
+
setup(__props, { emit: __emit }) {
|
|
14785
|
+
const $emit = __emit;
|
|
14786
|
+
const emit = __emit;
|
|
14787
|
+
const disabled = useDisabled_default(toRef(() => __props.disabled));
|
|
14788
|
+
function onKeyDown(evt) {
|
|
14789
|
+
if (unref(disabled)) return;
|
|
14790
|
+
switch (evt.key) {
|
|
14791
|
+
case "ArrowUp":
|
|
14792
|
+
emit("decrement", false, true);
|
|
14793
|
+
break;
|
|
14794
|
+
case "ArrowDown":
|
|
14795
|
+
emit("increment", false, true);
|
|
14796
|
+
break;
|
|
14797
|
+
case "ArrowLeft":
|
|
14798
|
+
emit("decrement", true, false);
|
|
14799
|
+
break;
|
|
14800
|
+
case "ArrowRight":
|
|
14801
|
+
emit("increment", true, false);
|
|
14802
|
+
break;
|
|
14803
|
+
default: return;
|
|
14804
|
+
}
|
|
14805
|
+
evt.preventDefault();
|
|
14806
|
+
}
|
|
14807
|
+
return (_ctx, _cache) => {
|
|
14808
|
+
return openBlock(), createElementBlock("button", {
|
|
14809
|
+
class: normalizeClass(unref(clsx)(unref(CoordinatePicker_module_default).coordinatePickerThumb, unref(disabled) && unref(CoordinatePicker_module_default).isDisabled, __props.isDragging && unref(CoordinatePicker_module_default).isDragging)),
|
|
14810
|
+
style: normalizeStyle({
|
|
14811
|
+
top: `${__props.position[1] * 100}%`,
|
|
14812
|
+
left: `${__props.position[0] * 100}%`
|
|
14813
|
+
}),
|
|
14814
|
+
role: "slider",
|
|
14815
|
+
"aria-disabled": unref(disabled) ? true : void 0,
|
|
14816
|
+
"aria-valuetext": `X: ${Math.round(__props.position[0] * 100)}%, Y: ${Math.round(__props.position[1] * 100)}%`,
|
|
14817
|
+
tabindex: unref(disabled) ? -1 : 0,
|
|
14818
|
+
type: "button",
|
|
14819
|
+
onKeydown: onKeyDown,
|
|
14820
|
+
onPointerdown: _cache[0] || (_cache[0] = ($event) => $emit("grab", $event))
|
|
14821
|
+
}, null, 46, _hoisted_1$39);
|
|
14822
|
+
};
|
|
14823
|
+
}
|
|
14824
|
+
});
|
|
14825
|
+
//#endregion
|
|
14826
|
+
//#region src/component/primitive/CoordinatePicker.vue?vue&type=script&setup=true&lang.ts
|
|
14827
|
+
var _hoisted_1$38 = ["aria-disabled", "aria-label"];
|
|
14828
|
+
//#endregion
|
|
14829
|
+
//#region src/component/primitive/CoordinatePicker.vue
|
|
14830
|
+
var CoordinatePicker_default = /* @__PURE__ */ defineComponent({
|
|
14831
|
+
__name: "CoordinatePicker",
|
|
14832
|
+
props: /* @__PURE__ */ mergeModels({
|
|
14833
|
+
ariaLabel: {},
|
|
14834
|
+
disabled: { type: Boolean },
|
|
14835
|
+
max: { default: 100 },
|
|
14836
|
+
min: { default: 0 },
|
|
14837
|
+
step: { default: 1 }
|
|
14838
|
+
}, {
|
|
14839
|
+
"modelValue": { default: [0, 0] },
|
|
14840
|
+
"modelModifiers": {}
|
|
14841
|
+
}),
|
|
14842
|
+
emits: /* @__PURE__ */ mergeModels(["dragging"], ["update:modelValue"]),
|
|
14843
|
+
setup(__props, { emit: __emit }) {
|
|
14844
|
+
const emit = __emit;
|
|
14845
|
+
const modelValue = useModel(__props, "modelValue");
|
|
14846
|
+
const disabled = useDisabled_default(toRef(() => __props.disabled));
|
|
14847
|
+
const rootRef = useTemplateRef("root");
|
|
14848
|
+
const isDragging = ref(false);
|
|
14849
|
+
const max = computed(() => Array.isArray(__props.max) ? __props.max : [__props.max, __props.max]);
|
|
14850
|
+
const min = computed(() => Array.isArray(__props.min) ? __props.min : [__props.min, __props.min]);
|
|
14851
|
+
const step = computed(() => Array.isArray(__props.step) ? __props.step : [__props.step, __props.step]);
|
|
14852
|
+
const thumbPosition = computed(() => [(unref(modelValue)[0] - unref(min)[0]) / (unref(max)[0] - unref(min)[0]), (unref(modelValue)[1] - unref(min)[1]) / (unref(max)[1] - unref(min)[1])]);
|
|
14853
|
+
function onDecrement(x, y) {
|
|
14854
|
+
if (unref(disabled)) return;
|
|
14855
|
+
let [valueX, valueY] = unref(modelValue);
|
|
14856
|
+
const [maxX, maxY] = unref(max);
|
|
14857
|
+
const [minX, minY] = unref(min);
|
|
14858
|
+
const [stepX, stepY] = unref(step);
|
|
14859
|
+
if (x) valueX = +t$1(Math.max(minX, Math.min(maxX, valueX - stepX)), stepX).toPrecision(4);
|
|
14860
|
+
if (y) valueY = +t$1(Math.max(minY, Math.min(maxY, valueY - stepY)), stepY).toPrecision(4);
|
|
14861
|
+
modelValue.value = [valueX, valueY];
|
|
14862
|
+
}
|
|
14863
|
+
function onIncrement(x, y) {
|
|
14864
|
+
if (unref(disabled)) return;
|
|
14865
|
+
let [valueX, valueY] = unref(modelValue);
|
|
14866
|
+
const [maxX, maxY] = unref(max);
|
|
14867
|
+
const [minX, minY] = unref(min);
|
|
14868
|
+
const [stepX, stepY] = unref(step);
|
|
14869
|
+
if (x) valueX = +t$1(Math.max(minX, Math.min(maxX, valueX + stepX)), stepX).toPrecision(4);
|
|
14870
|
+
if (y) valueY = +t$1(Math.max(minY, Math.min(maxY, valueY + stepY)), stepY).toPrecision(4);
|
|
14871
|
+
modelValue.value = [valueX, valueY];
|
|
14872
|
+
}
|
|
14873
|
+
function onPointerDown(evt) {
|
|
14874
|
+
if (unref(disabled)) return;
|
|
14875
|
+
isDragging.value = true;
|
|
14876
|
+
document.addEventListener("pointermove", onPointerMove);
|
|
14877
|
+
document.addEventListener("pointerup", onPointerUp, { passive: true });
|
|
14878
|
+
requestAnimationFrame(() => onPointerMove(evt));
|
|
14879
|
+
}
|
|
14880
|
+
function onPointerMove(evt) {
|
|
14881
|
+
const root = _$2(rootRef);
|
|
14882
|
+
if (!unref(isDragging) || !root) return;
|
|
14883
|
+
const [maxX, maxY] = unref(max);
|
|
14884
|
+
const [minX, minY] = unref(min);
|
|
14885
|
+
const [stepX, stepY] = unref(step);
|
|
14886
|
+
let { top, left, width, height } = root.getBoundingClientRect();
|
|
14887
|
+
top += 6;
|
|
14888
|
+
left += 6;
|
|
14889
|
+
width -= 12;
|
|
14890
|
+
height -= 12;
|
|
14891
|
+
const x = Math.max(0, Math.min(1, (evt.clientX - left) / width));
|
|
14892
|
+
const y = Math.max(0, Math.min(1, (evt.clientY - top) / height));
|
|
14893
|
+
modelValue.value = [+t$1(x * (maxX - minX) + minX, stepX).toPrecision(4), +t$1(y * (maxY - minY) + minY, stepY).toPrecision(4)];
|
|
14894
|
+
evt.preventDefault();
|
|
14895
|
+
}
|
|
14896
|
+
function onPointerUp() {
|
|
14897
|
+
isDragging.value = false;
|
|
14898
|
+
document.removeEventListener("pointermove", onPointerMove);
|
|
14899
|
+
document.removeEventListener("pointerup", onPointerUp);
|
|
14900
|
+
}
|
|
14901
|
+
watch(isDragging, (isDragging) => emit("dragging", isDragging));
|
|
14902
|
+
onUnmounted(() => {
|
|
14903
|
+
document.removeEventListener("pointermove", onPointerMove);
|
|
14904
|
+
document.removeEventListener("pointerup", onPointerUp);
|
|
14905
|
+
});
|
|
14906
|
+
return (_ctx, _cache) => {
|
|
14907
|
+
return openBlock(), createElementBlock("div", {
|
|
14908
|
+
ref: "root",
|
|
14909
|
+
class: normalizeClass(unref(CoordinatePicker_module_default).coordinatePicker),
|
|
14910
|
+
"aria-disabled": unref(disabled) ? true : void 0,
|
|
14911
|
+
"aria-label": __props.ariaLabel,
|
|
14912
|
+
onPointerdown: onPointerDown
|
|
14913
|
+
}, [createVNode(CoordinatePickerThumb_default, {
|
|
14914
|
+
disabled: unref(disabled),
|
|
14915
|
+
"is-dragging": isDragging.value,
|
|
14916
|
+
position: thumbPosition.value,
|
|
14917
|
+
onDecrement,
|
|
14918
|
+
onIncrement
|
|
14919
|
+
}, null, 8, [
|
|
14920
|
+
"disabled",
|
|
14921
|
+
"is-dragging",
|
|
14922
|
+
"position"
|
|
14923
|
+
])], 42, _hoisted_1$38);
|
|
14924
|
+
};
|
|
14925
|
+
}
|
|
14926
|
+
});
|
|
14890
14927
|
var Color_module_default = {
|
|
14891
14928
|
colorPicker: `color-picker`,
|
|
14892
14929
|
colorPickerPreview: `color-picker-preview`,
|
|
@@ -15461,16 +15498,16 @@ var FluxFormSelect_default = /* @__PURE__ */ defineComponent({
|
|
|
15461
15498
|
});
|
|
15462
15499
|
//#endregion
|
|
15463
15500
|
//#region src/css/component/Pagination.module.scss
|
|
15464
|
-
var { "
|
|
15501
|
+
var { "secondaryButton": _0$8, "secondaryButtonIcon": _1$2, "secondaryButtonLabel": _2$1 } = Button_module_default;
|
|
15465
15502
|
var Pagination_module_default = {
|
|
15466
15503
|
pagination: `pagination`,
|
|
15467
|
-
paginationButton: `pagination-button ${
|
|
15504
|
+
paginationButton: `pagination-button ${_0$8}`,
|
|
15468
15505
|
secondaryButton: `secondary-button`,
|
|
15469
15506
|
paginationButtonArrow: `pagination-button-arrow`,
|
|
15470
15507
|
paginationButtonCurrent: `pagination-button-current`,
|
|
15471
15508
|
paginationButtonSpacer: `pagination-button-spacer`,
|
|
15472
|
-
paginationButtonIcon: `pagination-button-icon ${
|
|
15473
|
-
paginationButtonLabel: `pagination-button-label ${
|
|
15509
|
+
paginationButtonIcon: `pagination-button-icon ${_1$2}`,
|
|
15510
|
+
paginationButtonLabel: `pagination-button-label ${_2$1}`,
|
|
15474
15511
|
paginationBar: `pagination-bar`,
|
|
15475
15512
|
paginationBarLimit: `pagination-bar-limit`,
|
|
15476
15513
|
paginationBarLimitDisplayingOf: `pagination-bar-limit-displaying-of`,
|