@jetlinks-web/components 2.0.2 → 2.0.4-1

package/es/Scrollbar/Thumb.js

@@ -0,0 +1,189 @@
+function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) {
+    const op = ops[i];
+    const fn = ops[i + 1];
+    i += 2;
+    if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {
+        return undefined;
+    }
+    if (op === 'access' || op === 'optionalAccess') {
+        lastAccessLHS = value;
+        value = fn(value);
+    }
+    else if (op === 'call' || op === 'optionalCall') {
+        value = fn((...args) => value.call(lastAccessLHS, ...args));
+        lastAccessLHS = undefined;
+    }
+} return value; }
+/* Analyzed bindings: {
+  "computed": "setup-const",
+  "inject": "setup-const",
+  "onBeforeUnmount": "setup-const",
+  "ref": "setup-const",
+  "toRef": "setup-const",
+  "useEventListener": "setup-maybe-ref",
+  "isClient": "setup-maybe-ref",
+  "scrollbarContextKey": "setup-maybe-ref",
+  "BAR_MAP": "setup-maybe-ref",
+  "renderThumbStyle": "setup-maybe-ref",
+  "thumbProps": "setup-maybe-ref",
+  "props": "setup-reactive-const",
+  "scrollbar": "setup-maybe-ref",
+  "instance": "setup-ref",
+  "thumb": "setup-ref",
+  "thumbState": "setup-ref",
+  "visible": "setup-ref",
+  "cursorDown": "setup-let",
+  "cursorLeave": "setup-let",
+  "originalOnSelectStart": "setup-let",
+  "bar": "setup-ref",
+  "thumbStyle": "setup-ref",
+  "offsetRatio": "setup-ref",
+  "clickThumbHandler": "setup-const",
+  "clickTrackHandler": "setup-const",
+  "startDrag": "setup-const",
+  "mouseMoveDocumentHandler": "setup-const",
+  "mouseUpDocumentHandler": "setup-const",
+  "mouseMoveScrollbarHandler": "setup-const",
+  "mouseLeaveScrollbarHandler": "setup-const",
+  "restoreOnselectstart": "setup-const"
+} */
+import { defineComponent as _defineComponent } from 'vue';
+import { normalizeStyle as _normalizeStyle, createElementVNode as _createElementVNode, vShow as _vShow, normalizeClass as _normalizeClass, withDirectives as _withDirectives, Transition as _Transition, withCtx as _withCtx, openBlock as _openBlock, createBlock as _createBlock } from "vue";
+import { computed, inject, onBeforeUnmount, ref, toRef } from 'vue';
+import { useEventListener } from '@vueuse/core';
+import { isClient } from '@jetlinks-web/utils';
+import { scrollbarContextKey } from './constants';
+import { BAR_MAP, renderThumbStyle } from './util';
+import { thumbProps } from './thumbProps';
+const __sfc_main__ = _defineComponent({
+    props: thumbProps,
+    setup(__props) {
+        const props = __props;
+        const scrollbar = inject(scrollbarContextKey);
+        if (!scrollbar)
+            throw new Error('can not inject scrollbar context');
+        const instance = ref();
+        const thumb = ref();
+        const thumbState = ref({});
+        const visible = ref(false);
+        let cursorDown = false;
+        let cursorLeave = false;
+        let originalOnSelectStart = isClient ? document.onselectstart : null;
+        const bar = computed(() => BAR_MAP[props.vertical ? 'vertical' : 'horizontal']);
+        const thumbStyle = computed(() => renderThumbStyle({
+            size: props.size,
+            move: props.move,
+            bar: bar.value,
+        }));
+        const offsetRatio = computed(() => instance.value[bar.value.offset] ** 2 /
+            scrollbar.wrapElement[bar.value.scrollSize] /
+            props.ratio /
+            Thumb.value[bar.value.offset]);
+        const clickThumbHandler = (e) => {
+            // prevent click event of middle and right button
+            e.stopPropagation();
+            if (e.ctrlKey || [1, 2].includes(e.button))
+                return;
+            _optionalChain([window, 'access', _2 => _2.getSelection, 'call', _3 => _3(), 'optionalAccess', _4 => _4.removeAllRanges, 'call', _5 => _5()]);
+            startDrag(e);
+            const el = e.currentTarget;
+            if (!el)
+                return;
+            thumbState.value[bar.value.axis] =
+                el[bar.value.offset] -
+                    (e[bar.value.client] - el.getBoundingClientRect()[bar.value.direction]);
+        };
+        const clickTrackHandler = (e) => {
+            if (!Thumb.value || !instance.value || !scrollbar.wrapElement)
+                return;
+            const offset = Math.abs((e.target).getBoundingClientRect()[bar.value.direction] -
+                e[bar.value.client]);
+            const thumbHalf = Thumb.value[bar.value.offset] / 2;
+            const thumbPositionPercentage = ((offset - thumbHalf) * 100 * offsetRatio.value) /
+                instance.value[bar.value.offset];
+            scrollbar.wrapElement[bar.value.scroll] =
+                (thumbPositionPercentage * scrollbar.wrapElement[bar.value.scrollSize]) /
+                    100;
+        };
+        const startDrag = (e) => {
+            e.stopImmediatePropagation();
+            cursorDown = true;
+            document.addEventListener('mousemove', mouseMoveDocumentHandler);
+            document.addEventListener('mouseup', mouseUpDocumentHandler);
+            originalOnSelectStart = document.onselectstart;
+            document.onselectstart = () => false;
+        };
+        const mouseMoveDocumentHandler = (e) => {
+            if (!instance.value || !Thumb.value)
+                return;
+            if (cursorDown === false)
+                return;
+            const prevPage = thumbState.value[bar.value.axis];
+            if (!prevPage)
+                return;
+            const offset = (instance.value.getBoundingClientRect()[bar.value.direction] -
+                e[bar.value.client]) *
+                -1;
+            const thumbClickPosition = Thumb.value[bar.value.offset] - prevPage;
+            const thumbPositionPercentage = ((offset - thumbClickPosition) * 100 * offsetRatio.value) /
+                instance.value[bar.value.offset];
+            scrollbar.wrapElement[bar.value.scroll] =
+                (thumbPositionPercentage * scrollbar.wrapElement[bar.value.scrollSize]) /
+                    100;
+        };
+        const mouseUpDocumentHandler = () => {
+            cursorDown = false;
+            thumbState.value[bar.value.axis] = 0;
+            document.removeEventListener('mousemove', mouseMoveDocumentHandler);
+            document.removeEventListener('mouseup', mouseUpDocumentHandler);
+            restoreOnselectstart();
+            if (cursorLeave)
+                visible.value = false;
+        };
+        const mouseMoveScrollbarHandler = () => {
+            cursorLeave = false;
+            visible.value = !!props.size;
+        };
+        const mouseLeaveScrollbarHandler = () => {
+            cursorLeave = true;
+            visible.value = cursorDown;
+        };
+        onBeforeUnmount(() => {
+            restoreOnselectstart();
+            document.removeEventListener('mouseup', mouseUpDocumentHandler);
+        });
+        const restoreOnselectstart = () => {
+            if (document.onselectstart !== originalOnSelectStart)
+                document.onselectstart = originalOnSelectStart;
+        };
+        useEventListener(toRef(scrollbar, 'scrollbarElement'), 'mousemove', mouseMoveScrollbarHandler);
+        useEventListener(toRef(scrollbar, 'scrollbarElement'), 'mouseleave', mouseLeaveScrollbarHandler);
+        return (_ctx, _cache) => {
+            return (_openBlock(), _createBlock(_Transition, {
+                name: "j-scrollbar-fade",
+                persisted: ""
+            }, {
+                default: _withCtx(() => [
+                    _withDirectives(_createElementVNode("div", {
+                        ref_key: "instance",
+                        ref: instance,
+                        class: _normalizeClass(['j-scrollbar__bar', props.vertical ? 'is-vertical' : 'is-horizontal']),
+                        onMousedown: clickTrackHandler
+                    }, [
+                        _createElementVNode("div", {
+                            ref_key: "thumb",
+                            ref: thumb,
+                            class: "j-scrollbar__thumb",
+                            style: _normalizeStyle(thumbStyle.value),
+                            onMousedown: clickThumbHandler
+                        }, null, 36 /* STYLE, NEED_HYDRATION */)
+                    ], 34 /* CLASS, NEED_HYDRATION */), [
+                        [_vShow, _ctx.always || visible.value]
+                    ])
+                ]),
+                _: 1 /* STABLE */
+            }));
+        };
+    }
+});
+export default __sfc_main__;

package/es/Scrollbar/constants.js

@@ -0,0 +1 @@
+export var scrollbarContextKey = Symbol('scrollbarContextKey');

package/es/Scrollbar/index.js

@@ -0,0 +1,2 @@
+import Scrollbar from './Scrollbar.js';
+export default Scrollbar;

package/es/Scrollbar/scrollbarProps.js

@@ -0,0 +1,100 @@
+import { isNumber } from '@jetlinks-web/utils';
+export var scrollbarProps = {
+  /**
+   * @description height of scrollbar
+   */
+  height: {
+    type: [String, Number],
+    default: ''
+  },
+  /**
+   * @description max height of scrollbar
+   */
+  maxHeight: {
+    type: [String, Number],
+    default: ''
+  },
+  /**
+   * @description whether to use the native scrollbar
+   */
+  native: {
+    type: Boolean,
+    default: false
+  },
+  /**
+   * @description style of wrap
+   */
+  wrapStyle: {
+    type: [String, Object, Array],
+    default: ''
+  },
+  /**
+   * @description class of wrap
+   */
+  wrapClass: {
+    type: [String, Array],
+    default: ''
+  },
+  /**
+   * @description class of view
+   */
+  viewClass: {
+    type: [String, Array],
+    default: ''
+  },
+  /**
+   * @description style of view
+   */
+  viewStyle: {
+    type: [String, Array, Object],
+    default: ''
+  },
+  /**
+   * @description do not respond to container size changes, if the container size does not change, it is better to set it to optimize performance
+   */
+  noresize: Boolean,
+  /**
+   * @description element tag of the view
+   */
+  tag: {
+    type: String,
+    default: 'div'
+  },
+  /**
+   * @description always show
+   */
+  always: Boolean,
+  /**
+   * @description minimum size of scrollbar
+   */
+  minSize: {
+    type: Number,
+    default: 20
+  },
+  /**
+   * @description id of view
+   */
+  id: String,
+  /**
+   * @description role of view
+   */
+  role: String,
+  /**
+   * @description aria-label of view
+   */
+  ariaLabel: String,
+  /**
+   * @description aria-orientation of view
+   */
+  ariaOrientation: {
+    type: String,
+    values: ['horizontal', 'vertical']
+  }
+};
+export var scrollbarEmits = {
+  scroll: function scroll(_ref) {
+    var scrollTop = _ref.scrollTop,
+      scrollLeft = _ref.scrollLeft;
+    return [scrollTop, scrollLeft].every(isNumber);
+  }
+};

package/es/Scrollbar/thumbProps.js

@@ -0,0 +1,10 @@
+export var thumbProps = {
+  vertical: Boolean,
+  size: String,
+  move: Number,
+  ratio: {
+    type: Number,
+    required: true
+  },
+  always: Boolean
+};

package/es/Scrollbar/util.js

@@ -0,0 +1,30 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+export var GAP = 4; // top 2 + bottom 2 of bar instance
+export var BAR_MAP = {
+  vertical: {
+    offset: 'offsetHeight',
+    scroll: 'scrollTop',
+    scrollSize: 'scrollHeight',
+    size: 'height',
+    key: 'vertical',
+    axis: 'Y',
+    client: 'clientY',
+    direction: 'top'
+  },
+  horizontal: {
+    offset: 'offsetWidth',
+    scroll: 'scrollLeft',
+    scrollSize: 'scrollWidth',
+    size: 'width',
+    key: 'horizontal',
+    axis: 'X',
+    client: 'clientX',
+    direction: 'left'
+  }
+};
+export var renderThumbStyle = function renderThumbStyle(_ref) {
+  var move = _ref.move,
+    size = _ref.size,
+    bar = _ref.bar;
+  return _defineProperty(_defineProperty({}, bar.size, size), "transform", "translate".concat(bar.axis, "(").concat(move, "%)"));
+};

package/es/Search/Advanced/History.js

@@ -0,0 +1,183 @@
+/* Analyzed bindings: {
+  "target": "props",
+  "request": "props",
+  "deleteRequest": "props",
+  "deleteKey": "props",
+  "computed": "setup-const",
+  "ref": "setup-const",
+  "isFunction": "setup-maybe-ref",
+  "AIcon": "setup-maybe-ref",
+  "Empty": "setup-maybe-ref",
+  "Ellipsis": "setup-maybe-ref",
+  "Popconfirm": "setup-maybe-ref",
+  "Button": "setup-maybe-ref",
+  "FormItemRest": "setup-maybe-ref",
+  "Popover": "setup-maybe-ref",
+  "message": "setup-maybe-ref",
+  "emit": "setup-const",
+  "props": "setup-reactive-const",
+  "historyList": "setup-ref",
+  "historyVisible": "setup-ref",
+  "showEmpty": "setup-ref",
+  "showHistoryList": "setup-const",
+  "visibleChange": "setup-const",
+  "click": "setup-const",
+  "itemClick": "setup-const",
+  "deleteHistory": "setup-const"
+} */
+import { defineComponent as _defineComponent } from 'vue';
+import { createTextVNode as _createTextVNode, unref as _unref, withCtx as _withCtx, createVNode as _createVNode, renderList as _renderList, Fragment as _Fragment, openBlock as _openBlock, createElementBlock as _createElementBlock, toDisplayString as _toDisplayString, createElementVNode as _createElementVNode, withModifiers as _withModifiers } from "vue";
+const _hoisted_1 = { class: "search-history-warp" };
+const _hoisted_2 = {
+    key: 0,
+    class: "search-history-items"
+};
+const _hoisted_3 = ["onClick"];
+const _hoisted_4 = { class: "delete" };
+const _hoisted_5 = {
+    key: 1,
+    class: "search-history-empty"
+};
+import { computed, ref } from 'vue';
+import { isFunction } from 'lodash-es';
+import { AIcon, Empty, Ellipsis } from '../../../';
+import { Popconfirm, Button, FormItemRest, Popover, message } from 'ant-design-vue';
+const __sfc_main__ = _defineComponent({
+    props: {
+        target: {
+            type: String,
+            default: '',
+            required: true,
+        },
+        request: {
+            type: Function,
+            default: null,
+        },
+        deleteRequest: {
+            type: Function,
+            default: null,
+        },
+        deleteKey: {
+            type: String,
+            default: 'key',
+        },
+    },
+    emits: ["click", "itemClick"],
+    setup(__props, { emit: __emit }) {
+        const emit = __emit;
+        const props = __props;
+        const historyList = ref([]);
+        const historyVisible = ref(false);
+        const showEmpty = computed(() => {
+            return historyList.value.length === 0;
+        });
+        const showHistoryList = async () => {
+            if (props.request) {
+                const resp = await props.request(props.target);
+                if (resp.success && resp.result.length) {
+                    historyList.value = resp.result.filter((item) => item.content);
+                }
+                else {
+                    historyList.value = [];
+                }
+            }
+        };
+        const visibleChange = async (v) => {
+            historyVisible.value = v;
+        };
+        const click = () => {
+            emit('click');
+        };
+        const itemClick = (content) => {
+            historyVisible.value = false;
+            emit('itemClick', content);
+        };
+        const deleteHistory = async (item) => {
+            if (props.deleteRequest && isFunction(props.deleteRequest)) {
+                const resp = await props.deleteRequest(props.target, item[props.deleteKey]);
+                historyVisible.value = false;
+                if (resp.success || resp.status === 200 || resp.code === 200) {
+                    message.success('操作成功');
+                }
+                else {
+                    message.error('操作失败');
+                }
+            }
+        };
+        return (_ctx, _cache) => {
+            return (_openBlock(), _createElementBlock("div", _hoisted_1, [
+                _createVNode(_unref(FormItemRest), null, {
+                    default: _withCtx(() => [
+                        _createVNode(_unref(Button), {
+                            class: "search-history-button",
+                            type: "primary",
+                            "html-type": "submit"
+                        }, {
+                            default: _withCtx(() => [
+                                _createTextVNode(" 搜索 ")
+                            ]),
+                            _: 1 /* STABLE */
+                        })
+                    ]),
+                    _: 1 /* STABLE */
+                }),
+                _createVNode(_unref(Popover), {
+                    placement: "bottom",
+                    trigger: "click",
+                    "overlay-class-name": "search-history-list-pop",
+                    visible: historyVisible.value,
+                    onVisibleChange: visibleChange
+                }, {
+                    content: _withCtx(() => [
+                        (!showEmpty.value)
+                            ? (_openBlock(), _createElementBlock("div", _hoisted_2, [
+                                (_openBlock(true), _createElementBlock(_Fragment, null, _renderList(historyList.value, (item) => {
+                                    return (_openBlock(), _createElementBlock("div", {
+                                        key: item.id,
+                                        class: "search-history-item"
+                                    }, [
+                                        _createElementVNode("div", {
+                                            class: "history-item--title",
+                                            onClick: ($event) => (itemClick(item.content))
+                                        }, [
+                                            _createVNode(_unref(Ellipsis), { style: { "width": "100%" } }, {
+                                                default: _withCtx(() => [
+                                                    _createTextVNode(_toDisplayString(item.name), 1 /* TEXT */)
+                                                ]),
+                                                _: 2 /* DYNAMIC */
+                                            }, 1024 /* DYNAMIC_SLOTS */)
+                                        ], 8 /* PROPS */, _hoisted_3),
+                                        _createVNode(_unref(Popconfirm), {
+                                            title: "确认删除吗？",
+                                            placement: "top",
+                                            onConfirm: ($event) => (deleteHistory(item))
+                                        }, {
+                                            default: _withCtx(() => [
+                                                _createElementVNode("span", _hoisted_4, [
+                                                    _createVNode(_unref(AIcon), { type: "DeleteOutlined" })
+                                                ])
+                                            ]),
+                                            _: 2 /* DYNAMIC */
+                                        }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["onConfirm"])
+                                    ]));
+                                }), 128 /* KEYED_FRAGMENT */))
+                            ]))
+                            : (_openBlock(), _createElementBlock("div", _hoisted_5, [
+                                _createVNode(_unref(Empty))
+                            ]))
+                    ]),
+                    default: _withCtx(() => [
+                        _createElementVNode("div", {
+                            class: "search-history-button-icon",
+                            onClick: _withModifiers(showHistoryList, ["stop"])
+                        }, [
+                            _createVNode(_unref(AIcon), { type: "DownOutlined" })
+                        ])
+                    ]),
+                    _: 1 /* STABLE */
+                }, 8 /* PROPS */, ["visible"])
+            ]));
+        };
+    }
+});
+export default __sfc_main__;

package/es/Search/Advanced/SaveHistory.js

@@ -0,0 +1,153 @@
+/* Analyzed bindings: {
+  "terms": "props",
+  "target": "props",
+  "request": "props",
+  "ref": "setup-const",
+  "reactive": "setup-const",
+  "Form": "setup-maybe-ref",
+  "Button": "setup-maybe-ref",
+  "FormItem": "setup-maybe-ref",
+  "Popover": "setup-maybe-ref",
+  "Textarea": "setup-maybe-ref",
+  "message": "setup-maybe-ref",
+  "isFunction": "setup-maybe-ref",
+  "props": "setup-reactive-const",
+  "saveHistoryLoading": "setup-ref",
+  "visible": "setup-ref",
+  "formRef": "setup-ref",
+  "modelRef": "setup-reactive-const",
+  "visibleChange": "setup-const",
+  "saveHistory": "setup-const"
+} */
+import { defineComponent as _defineComponent } from 'vue';
+import { unref as _unref, createVNode as _createVNode, withCtx as _withCtx, createTextVNode as _createTextVNode, openBlock as _openBlock, createElementBlock as _createElementBlock, createCommentVNode as _createCommentVNode, createBlock as _createBlock, pushScopeId as _pushScopeId, popScopeId as _popScopeId } from "vue";
+const _withScopeId = n => (_pushScopeId("data-v-1712915948568"), n = n(), _popScopeId(), n);
+const _hoisted_1 = {
+    key: 0,
+    style: { "width": "240px" }
+};
+import { ref, reactive } from 'vue';
+import { Form, Button, FormItem, Popover, Textarea, message } from 'ant-design-vue';
+import { isFunction } from 'lodash-es';
+const __sfc_main__ = _defineComponent({
+    props: {
+        terms: {
+            type: Object,
+            default: () => ({}),
+        },
+        target: {
+            type: String,
+            default: '',
+            required: true,
+        },
+        request: {
+            type: Function,
+            default: null,
+        },
+    },
+    setup(__props) {
+        const props = __props;
+        const saveHistoryLoading = ref(false);
+        const visible = ref(false);
+        const formRef = ref();
+        const modelRef = reactive({
+            name: undefined,
+        });
+        const visibleChange = (e) => {
+            visible.value = e;
+            if (!e) {
+                setTimeout(() => {
+                    modelRef.name = undefined;
+                }, 100);
+            }
+        };
+        /**
+         * 保存当前查询条件
+         */
+        const saveHistory = async () => {
+            // 获取当前查询条件并转化为字符串
+            const formData = await formRef.value.validate();
+            if (formData && props.request && isFunction(props.request)) {
+                formData.content = JSON.stringify(props.terms);
+                saveHistoryLoading.value = true;
+                const resp = await props.request(formData, props.target);
+                saveHistoryLoading.value = false;
+                if (resp.success || resp.status === 200 || resp.code === 200) {
+                    message.success('操作成功');
+                    visibleChange(false);
+                }
+                else {
+                    message.error('操作失败');
+                }
+            }
+        };
+        return (_ctx, _cache) => {
+            return (_openBlock(), _createBlock(_unref(Popover), {
+                visible: visible.value,
+                "onUpdate:visible": _cache[1] || (_cache[1] = ($event) => ((visible).value = $event)),
+                title: "搜索名称",
+                trigger: "click",
+                placement: "bottom",
+                onVisibleChange: visibleChange
+            }, {
+                content: _withCtx(() => [
+                    (visible.value)
+                        ? (_openBlock(), _createElementBlock("div", _hoisted_1, [
+                            _createVNode(_unref(Form), {
+                                ref_key: "formRef",
+                                ref: formRef,
+                                model: modelRef
+                            }, {
+                                default: _withCtx(() => [
+                                    _createVNode(_unref(FormItem), {
+                                        name: "name",
+                                        rules: [
+                                            { required: true, message: '请输入名称' },
+                                            { max: 64, message: '最多64个字符' },
+                                        ]
+                                    }, {
+                                        default: _withCtx(() => [
+                                            _createVNode(_unref(Textarea), {
+                                                value: modelRef.name,
+                                                "onUpdate:value": _cache[0] || (_cache[0] = ($event) => ((modelRef.name) = $event)),
+                                                rows: 3,
+                                                maxlength: 200
+                                            }, null, 8 /* PROPS */, ["value"])
+                                        ]),
+                                        _: 1 /* STABLE */
+                                    })
+                                ]),
+                                _: 1 /* STABLE */
+                            }, 8 /* PROPS */, ["model"]),
+                            _createVNode(_unref(Button), {
+                                loading: saveHistoryLoading.value,
+                                type: "primary",
+                                class: "save-btn",
+                                style: { "width": "100%" },
+                                onClick: saveHistory
+                            }, {
+                                default: _withCtx(() => [
+                                    _createTextVNode(" 保存 ")
+                                ]),
+                                _: 1 /* STABLE */
+                            }, 8 /* PROPS */, ["loading"])
+                        ]))
+                        : _createCommentVNode("v-if", true)
+                ]),
+                default: _withCtx(() => [
+                    _createVNode(_unref(Button), {
+                        ghost: "",
+                        type: "primary"
+                    }, {
+                        default: _withCtx(() => [
+                            _createTextVNode(" 保存")
+                        ]),
+                        _: 1 /* STABLE */
+                    })
+                ]),
+                _: 1 /* STABLE */
+            }, 8 /* PROPS */, ["visible"]));
+        };
+    }
+});
+export default __sfc_main__;