@jetlinks-web/components 2.0.2-2 → 2.0.2-5

package/es/Ellipsis/Ellipsis.js

@@ -0,0 +1,189 @@
+/* Analyzed bindings: {
+  "expandTrigger": "props",
+  "lineClamp": "props",
+  "tooltip": "props",
+  "Tooltip": "setup-maybe-ref",
+  "computed": "setup-const",
+  "mergeProps": "setup-const",
+  "ref": "setup-const",
+  "useAttrs": "setup-const",
+  "props": "setup-reactive-const",
+  "jEllipsis": "literal-const",
+  "jEllipsisCursorClass": "literal-const",
+  "jEllipsisLineClampClass": "literal-const",
+  "expandedRef": "setup-ref",
+  "tooltipRef": "setup-ref",
+  "triggerRef": "setup-ref",
+  "visible": "setup-ref",
+  "attrs": "setup-maybe-ref",
+  "handleClickRef": "setup-ref",
+  "triggerAttrs": "setup-const",
+  "showTooltip": "setup-const",
+  "ellipsisStyleRef": "setup-ref",
+  "syncEllipsisStyle": "setup-const",
+  "syncTriggerClass": "setup-const",
+  "syncCursorStyle": "setup-const",
+  "getTooltipDisabled": "setup-const"
+} */
+import { renderSlot as _renderSlot, normalizeClass as _normalizeClass, openBlock as _openBlock, createElementBlock as _createElementBlock, createCommentVNode as _createCommentVNode, mergeProps as _mergeProps, createElementVNode as _createElementVNode, unref as _unref, withCtx as _withCtx, createBlock as _createBlock } from "vue";
+import { Tooltip } from 'ant-design-vue';
+import { computed, mergeProps, ref, useAttrs } from 'vue';
+const jEllipsis = 'j-ellipsis';
+const jEllipsisCursorClass = 'j-ellipsis-cursor';
+const jEllipsisLineClampClass = 'j-ellipsis-line-clamp';
+const __sfc_main__ = Object.assign({
+    name: 'Ellipsis',
+}, {
+    props: {
+        expandTrigger: {
+            type: String,
+            default: undefined,
+        },
+        /** multiline ellipsis */
+        lineClamp: {
+            type: [Number, String],
+            default: 1,
+        },
+        tooltip: {
+            type: [Boolean, Object],
+            default: true,
+        },
+    },
+    setup(__props) {
+        const props = __props;
+        // define class name
+        const expandedRef = ref(false);
+        const tooltipRef = ref(null);
+        const triggerRef = ref(null);
+        const visible = ref(false);
+        const attrs = useAttrs();
+        const handleClickRef = computed(() => {
+            return props.expandTrigger === 'click'
+                ? () => {
+                    const { value: expanded } = expandedRef;
+                    expandedRef.value = !expanded;
+                }
+                : undefined;
+        });
+        function triggerAttrs() {
+            return {
+                ...mergeProps(attrs, {
+                    class: [
+                        jEllipsis,
+                        props.lineClamp !== undefined ? jEllipsisLineClampClass : undefined,
+                        props.expandTrigger === 'click' ? jEllipsisCursorClass : undefined,
+                    ],
+                    style: ellipsisStyleRef.value,
+                }),
+            };
+        }
+        const showTooltip = () => {
+            const { value: trigger } = triggerRef;
+            if (trigger) {
+                visible.value = trigger.scrollHeight > trigger.offsetHeight;
+            }
+        };
+        const ellipsisStyleRef = computed(() => {
+            const { lineClamp } = props;
+            const { value: expanded } = expandedRef;
+            if (lineClamp !== undefined) {
+                return {
+                    textOverflow: '',
+                    '-webkit-line-clamp': expanded ? '' : lineClamp,
+                };
+            }
+            else {
+                return {
+                    textOverflow: expanded ? '' : 'ellipsis',
+                    '-webkit-line-clamp': '',
+                };
+            }
+        });
+        const syncEllipsisStyle = (trigger) => {
+            if (!trigger)
+                return;
+            const latestStyle = ellipsisStyleRef.value;
+            const lineClampClass = jEllipsisLineClampClass;
+            if (props.lineClamp !== undefined) {
+                syncTriggerClass(trigger, lineClampClass, 'add');
+            }
+            else {
+                syncTriggerClass(trigger, lineClampClass, 'remove');
+            }
+            for (const key in latestStyle) {
+                if (trigger.style[key] !== latestStyle[key]) {
+                    trigger.style[key] = latestStyle[key];
+                }
+            }
+        };
+        const syncTriggerClass = (trigger, styleClass, action) => {
+            if (action === 'add') {
+                if (!trigger.classList.contains(styleClass)) {
+                    trigger.classList.add(styleClass);
+                }
+            }
+            else {
+                if (trigger.classList.contains(styleClass)) {
+                    trigger.classList.remove(styleClass);
+                }
+            }
+        };
+        const syncCursorStyle = (trigger, tooltipDisabled) => {
+            if (props.expandTrigger === 'click' && !tooltipDisabled) {
+                syncTriggerClass(trigger, jEllipsisCursorClass, 'add');
+            }
+            else {
+                syncTriggerClass(trigger, jEllipsisCursorClass, 'remove');
+            }
+        };
+        const getTooltipDisabled = () => {
+            let tooltipDisabled = false;
+            const { value: expanded } = expandedRef;
+            if (expanded)
+                return true;
+            const { value: trigger } = triggerRef;
+            if (trigger) {
+                syncEllipsisStyle(trigger);
+                tooltipDisabled = trigger.scrollHeight <= trigger.offsetHeight;
+                syncCursorStyle(trigger, tooltipDisabled);
+            }
+            return tooltipDisabled;
+        };
+        return (_ctx, _cache) => {
+            return (_openBlock(), _createBlock(_unref(Tooltip), _mergeProps({
+                ref_key: "tooltipRef",
+                ref: tooltipRef,
+                placement: "top"
+            }, __props.tooltip, { visible: visible.value }), {
+                default: _withCtx(() => [
+                    (__props.tooltip)
+                        ? (_openBlock(), _createElementBlock("div", {
+                            key: 0,
+                            class: _normalizeClass([jEllipsisLineClampClass, jEllipsis, 'j-ellipsis-deep'])
+                        }, [
+                            _renderSlot(_ctx.$slots, "default"),
+                            _renderSlot(_ctx.$slots, "tooltip")
+                        ], 2 /* CLASS */))
+                        : _createCommentVNode("v-if", true),
+                    _createElementVNode("span", _mergeProps({
+                        ref_key: "triggerRef",
+                        ref: triggerRef
+                    }, triggerAttrs(), {
+                        onClick: _cache[0] || (_cache[0] = (...args) => (handleClickRef.value && handleClickRef.value(...args))),
+                        onMouseleave: _cache[1] || (_cache[1] = $event => (visible.value = false)),
+                        onMouseenter: _cache[2] || (_cache[2] = $event => {
+                            ;
+                            [
+                                props.expandTrigger === 'click'
+                                    ? getTooltipDisabled()
+                                    : showTooltip(),
+                            ];
+                        })
+                    }), null, 16 /* FULL_PROPS */)
+                ]),
+                _: 3 /* FORWARDED */
+            }, 16 /* FULL_PROPS */, ["visible"]));
+        };
+    }
+});
+export default __sfc_main__;

package/es/Ellipsis/index.js

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

package/es/Empty/Empty.js

@@ -0,0 +1,56 @@
+/* Analyzed bindings: {
+  "description": "props",
+  "image": "props",
+  "imageStyle": "props",
+  "Empty": "setup-maybe-ref",
+  "useSlots": "setup-const",
+  "NoData": "setup-maybe-ref",
+  "omit": "setup-maybe-ref",
+  "slots": "setup-maybe-ref",
+  "renderArr": "setup-maybe-ref",
+  "props": "setup-reactive-const",
+  "baseProps": "setup-maybe-ref"
+} */
+import { defineComponent as _defineComponent } from 'vue';
+import { unref as _unref, renderSlot as _renderSlot, normalizeProps as _normalizeProps, guardReactiveProps as _guardReactiveProps, withCtx as _withCtx, renderList as _renderList, createSlots as _createSlots, openBlock as _openBlock, createBlock as _createBlock } from "vue";
+import { Empty } from 'ant-design-vue';
+import { useSlots } from 'vue';
+import NoData from './image';
+import { omit } from 'lodash-es';
+const __sfc_main__ = _defineComponent({
+    props: {
+        description: {
+            type: String,
+            default: '暂无数据',
+        },
+        image: {
+            type: String,
+            default: NoData,
+        },
+        imageStyle: {
+            type: Object,
+            default: () => {
+                return { height: '60px' };
+            },
+        },
+    },
+    setup(__props) {
+        const slots = useSlots();
+        const renderArr = Object.keys(slots);
+        const props = __props;
+        const baseProps = omit(props, ...renderArr);
+        return (_ctx, _cache) => {
+            return (_openBlock(), _createBlock(_unref(Empty), _normalizeProps(_guardReactiveProps(_unref(baseProps))), _createSlots({ _: 2 /* DYNAMIC */ }, [
+                _renderList(_unref(renderArr), (item) => {
+                    return {
+                        name: item,
+                        fn: _withCtx((scope) => [
+                            _renderSlot(_ctx.$slots, item, { scope: scope })
+                        ])
+                    };
+                })
+            ]), 1040 /* FULL_PROPS, DYNAMIC_SLOTS */));
+        };
+    }
+});
+export default __sfc_main__;

package/es/Empty/image.js

@@ -0,0 +1,2 @@
+var img = 'data:image/png;base64,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';
+export default img;

package/es/Empty/index.js

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

package/es/FullPage/FullPage.js

@@ -0,0 +1,31 @@
+/* Analyzed bindings: {
+  "ref": "setup-const",
+  "useElementBounding": "setup-maybe-ref",
+  "fullPage": "setup-ref",
+  "y": "setup-maybe-ref"
+} */
+import { defineComponent as _defineComponent } from 'vue';
+import { unref as _unref, renderSlot as _renderSlot, createElementVNode as _createElementVNode, normalizeStyle as _normalizeStyle, openBlock as _openBlock, createElementBlock as _createElementBlock, pushScopeId as _pushScopeId, popScopeId as _popScopeId } from "vue";
+const _withScopeId = n => (_pushScopeId("data-v-1712541386176"), n = n(), _popScopeId(), n);
+const _hoisted_1 = { class: "full-page-warp-content" };
+import { ref } from 'vue';
+import { useElementBounding } from '@vueuse/core';
+const __sfc_main__ = _defineComponent({
+    setup(__props) {
+        const fullPage = ref(null);
+        const { y } = useElementBounding(fullPage);
+        return (_ctx, _cache) => {
+            return (_openBlock(), _createElementBlock("div", {
+                class: "full-page-warp",
+                ref_key: "fullPage",
+                ref: fullPage,
+                style: _normalizeStyle({ minHeight: `calc(100vh - ${_unref(y) + 24}px)` })
+            }, [
+                _createElementVNode("div", _hoisted_1, [
+                    _renderSlot(_ctx.$slots, "default")
+                ])
+            ], 4 /* STYLE */));
+        };
+    }
+});
+export default __sfc_main__;

package/es/FullPage/index.js

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

package/es/Icon/icon.js

@@ -0,0 +1,43 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { createVNode as _createVNode } from "vue";
+import { defineComponent, createVNode, watchEffect } from 'vue';
+import * as aIcon from '@ant-design/icons-vue';
+import { createFromIconfontCN } from '@ant-design/icons-vue';
+import { useIcon } from '@jetlinks-web/hooks';
+var MyIcon = createFromIconfontCN({
+  scriptUrl: '//at.alicdn.com/t/c/font_3183515_i7oma42he.js' // 在 iconfont.cn 上生成
+});
+var AntdIcon = function AntdIcon(props) {
+  return createVNode(aIcon[props.type]);
+};
+var Icon = function Icon(props) {
+  return Object.keys(aIcon).includes(props.type) ? _createVNode(AntdIcon, props, null) : _createVNode(MyIcon, props, null);
+};
+export default defineComponent({
+  name: 'AIcon',
+  // 传入组件配置
+  props: ['type', 'scriptUrl', 'class'],
+  emits: ['click'],
+  setup: function setup(props, _ref) {
+    var emit = _ref.emit,
+      attrs = _ref.attrs;
+    var config = useIcon();
+    watchEffect(function () {
+      var url = props.scriptUrl || config.scriptUrl;
+      if (url) {
+        MyIcon = createFromIconfontCN({
+          scriptUrl: url
+        });
+      }
+    });
+    var click = function click() {
+      emit('click');
+    };
+    return function () {
+      return _createVNode(Icon, _objectSpread(_objectSpread({}, props), {}, {
+        "style": attrs.style,
+        "onClick": click
+      }), null);
+    };
+  }
+});

package/{src/Icon/index.ts → es/Icon/index.js}

@@ -1,3 +1,2 @@
-import AIcon from './icon';
-
-export default AIcon;
+import AIcon from './icon';
+export default AIcon;

package/es/MonacoEditor/Monaco.js

@@ -0,0 +1,238 @@
+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: {
+  "modelValue": "props",
+  "theme": "props",
+  "language": "props",
+  "codeTips": "props",
+  "init": "props",
+  "registrationTips": "props",
+  "registrationTypescript": "props",
+  "blurFormat": "props",
+  "readOnly": "props",
+  "options": "props",
+  "ref": "setup-const",
+  "onMounted": "setup-const",
+  "watch": "setup-const",
+  "onUnmounted": "setup-const",
+  "toRaw": "setup-const",
+  "nextTick": "setup-const",
+  "monaco": "setup-const",
+  "omit": "setup-maybe-ref",
+  "props": "setup-reactive-const",
+  "emit": "setup-const",
+  "dom": "setup-ref",
+  "instance": "setup-ref",
+  "monacoProviderRef": "setup-ref",
+  "monacoTypescriptProviderRef": "setup-ref",
+  "handleSuggestions": "setup-const",
+  "disposeRegister": "setup-const",
+  "registerCompletionItemProvider": "setup-const",
+  "disposeTypescript": "setup-const",
+  "registerTypescript": "setup-const",
+  "editorFormat": "setup-const",
+  "insert": "setup-const"
+} */
+import { openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue";
+import { ref, onMounted, watch, onUnmounted, toRaw, nextTick } from 'vue';
+import * as monaco from 'monaco-editor';
+import { omit } from 'lodash-es';
+const __sfc_main__ = {
+    props: {
+        modelValue: [String, Number],
+        theme: { type: String, default: 'vs-dark' },
+        language: { type: String, default: 'json' },
+        codeTips: { type: Array, default: () => [] },
+        init: { type: Function, default: undefined },
+        registrationTips: { type: Object, default: () => ({}) },
+        registrationTypescript: { type: Object, default: () => ({}) },
+        blurFormat: { type: Boolean, default: true },
+        readOnly: { type: Boolean, default: false },
+        options: { type: Object, default: () => ({}) },
+    },
+    emits: [
+        'update:modelValue',
+        'blur',
+        'focus',
+        'change',
+        'errorChange',
+    ],
+    setup(__props, { expose: __expose, emit: __emit }) {
+        const props = __props;
+        const emit = __emit;
+        const dom = ref();
+        const instance = ref();
+        const monacoProviderRef = ref();
+        const monacoTypescriptProviderRef = ref();
+        // codeTipItem.dispose() // 销毁自定义提示
+        const handleSuggestions = (suggestions, range) => {
+            return Array.isArray(suggestions)
+                ? suggestions.map((item) => ({ ...item, range }))
+                : [];
+        };
+        const disposeRegister = () => {
+            _optionalChain([monacoProviderRef, 'access', _ => _.value, 'optionalAccess', _2 => _2.dispose, 'call', _3 => _3()]);
+            monacoProviderRef.value = null;
+        };
+        /**
+         * 代码提示注册
+         */
+        const registerCompletionItemProvider = () => {
+            disposeRegister();
+            if (monaco.languages && _optionalChain([props, 'access', _4 => _4.registrationTips, 'optionalAccess', _5 => _5.suggestions])) {
+                const { name, suggestions } = props.registrationTips;
+                monacoProviderRef.value =
+                    monaco.languages.registerCompletionItemProvider(name || 'json', {
+                        provideCompletionItems: function (model, position) {
+                            const word = model.getWordUntilPosition(position); // 获取提示代码范围位置
+                            const range = {
+                                startLineNumber: position.lineNumber,
+                                endLineNumber: position.lineNumber,
+                                startColumn: word.startColumn,
+                                endColumn: word.endColumn,
+                            };
+                            return {
+                                suggestions: handleSuggestions(suggestions, range),
+                            };
+                        },
+                    });
+            }
+        };
+        const disposeTypescript = () => {
+            _optionalChain([monacoTypescriptProviderRef, 'access', _6 => _6.value, 'optionalAccess', _7 => _7.dispose, 'call', _8 => _8()]);
+            monacoTypescriptProviderRef.value = null;
+        };
+        const registerTypescript = () => {
+            disposeTypescript();
+            if (monaco.languages && _optionalChain([props, 'access', _9 => _9.registrationTypescript, 'optionalAccess', _10 => _10.typescript])) {
+                const { name, typescript } = props.registrationTypescript;
+                monacoTypescriptProviderRef.value =
+                    monaco.languages.typescript.javascriptDefaults.addExtraLib(typescript);
+            }
+        };
+        /**
+         * 代码格式化
+         */
+        const editorFormat = () => {
+            if (!instance.value)
+                return;
+            _optionalChain([toRaw, 'call', _11 => _11(instance.value), 'access', _12 => _12.getAction, 'call', _13 => _13('editor.action.formatDocument'), 'optionalAccess', _14 => _14.run, 'call', _15 => _15()]);
+            if (props.hasOwnProperty('readOnly')) {
+                setTimeout(() => {
+                    toRaw(instance.value).updateOptions({
+                        readOnly: props.readOnly !== false,
+                    });
+                }, 100);
+            }
+        };
+        monaco.editor.onDidChangeMarkers(([uri]) => {
+            const markers = monaco.editor.getModelMarkers({ resource: uri });
+            emit('errorChange', markers);
+        });
+        onMounted(async () => {
+            const _model = monaco.editor.createModel(props.modelValue, props.language);
+            instance.value = monaco.editor.create(dom.value, {
+                model: _model,
+                tabSize: 2,
+                automaticLayout: true,
+                scrollBeyondLastLine: false,
+                theme: props.theme,
+                formatOnPaste: true,
+                ...(omit(props.options, ['readOnly']) || {}),
+            });
+            instance.value.onDidChangeModelContent(() => {
+                //
+                const value = toRaw(instance.value).getValue();
+                nextTick(() => {
+                    emit('update:modelValue', value);
+                    emit('change', value);
+                });
+            });
+            instance.value.onDidBlurEditorText(() => {
+                emit('blur');
+                if (props.blurFormat) {
+                    editorFormat();
+                }
+            });
+            instance.value.onDidFocusEditorText(() => {
+                emit('focus');
+            });
+            if (props.modelValue) {
+                setTimeout(() => {
+                    editorFormat();
+                }, 200);
+            }
+            _optionalChain([props, 'access', _16 => _16.init, 'optionalCall', _17 => _17(instance.value, monaco)]);
+        });
+        /**
+         * 光标位置插入内容
+         * @param {String} val
+         * @param position
+         */
+        const insert = (val, position) => {
+            if (!instance.value)
+                return;
+            const _position = position || toRaw(instance.value).getPosition();
+            const value = toRaw(instance.value).getValue();
+            if (position && position.lineNumber) {
+                toRaw(instance.value).setPosition(position);
+            }
+            toRaw(instance.value).executeEdits(value, [
+                {
+                    range: new monaco.Range(_optionalChain([_position, 'optionalAccess', _18 => _18.lineNumber]), _optionalChain([_position, 'optionalAccess', _19 => _19.column]), _optionalChain([_position, 'optionalAccess', _20 => _20.lineNumber]), _optionalChain([_position, 'optionalAccess', _21 => _21.column])),
+                    text: val,
+                },
+            ]);
+        };
+        watch(() => props.modelValue, (val) => {
+            if (!instance.value ||
+                (instance.value &&
+                    props.modelValue === toRaw(instance.value).getValue()))
+                return;
+            // setValue之前获取光标位置
+            const position = toRaw(instance.value).getPosition();
+            // setValue之后光标位置改变
+            toRaw(instance.value).setValue(val);
+            // 设置光标位置为setValue之前的位置
+            toRaw(instance.value).setPosition(position);
+            editorFormat();
+        });
+        watch(() => JSON.stringify(props.registrationTips), () => {
+            registerCompletionItemProvider();
+        }, { immediate: true });
+        watch(() => JSON.stringify(props.registrationTypescript), () => {
+            registerTypescript();
+        }, { immediate: true });
+        onUnmounted(() => {
+            disposeRegister();
+            disposeTypescript();
+            _optionalChain([toRaw, 'call', _22 => _22(instance.value), 'access', _23 => _23.editor, 'optionalAccess', _24 => _24.dispose, 'optionalCall', _25 => _25()]);
+        });
+        __expose({
+            editorFormat,
+            insert,
+        });
+        return (_ctx, _cache) => {
+            return (_openBlock(), _createElementBlock("div", {
+                ref_key: "dom",
+                ref: dom,
+                class: "j-monaco-editor"
+            }, null, 512 /* NEED_PATCH */));
+        };
+    }
+};
+export default __sfc_main__;

package/es/MonacoEditor/index.js

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