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

package/es/ValueItem/ValueItem.js

@@ -0,0 +1,233 @@
+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",
+  "itemType": "props",
+  "mode": "props",
+  "placeholder": "props",
+  "options": "props",
+  "style": "props",
+  "class": "props",
+  "valueFormat": "props",
+  "action": "props",
+  "headers": "props",
+  "CSSProperties": "setup-const",
+  "PropType": "setup-const",
+  "ref": "setup-const",
+  "watch": "setup-const",
+  "componentsType": "setup-maybe-ref",
+  "MonacoEditor": "setup-maybe-ref",
+  "Select": "setup-maybe-ref",
+  "DatePicker": "setup-maybe-ref",
+  "TimePicker": "setup-maybe-ref",
+  "Input": "setup-maybe-ref",
+  "InputNumber": "setup-maybe-ref",
+  "InputPassword": "setup-maybe-ref",
+  "Upload": "setup-maybe-ref",
+  "Modal": "setup-maybe-ref",
+  "emit": "setup-const",
+  "props": "setup-reactive-const",
+  "typeMap": "setup-maybe-ref",
+  "myValue": "setup-ref",
+  "modalVisible": "setup-ref",
+  "objectValue": "setup-ref",
+  "handleItemModalSubmit": "setup-const",
+  "onChange": "setup-const",
+  "handleFileChange": "setup-const"
+} */
+import { defineComponent as _defineComponent } from 'vue';
+import { unref as _unref, mergeProps as _mergeProps, openBlock as _openBlock, createBlock as _createBlock, createCommentVNode as _createCommentVNode, resolveComponent as _resolveComponent, createVNode as _createVNode, withCtx as _withCtx, createElementVNode as _createElementVNode, createElementBlock as _createElementBlock } from "vue";
+const _hoisted_1 = { class: "value-item-warp" };
+const _hoisted_2 = { style: { "width": "100%", "height": "300px" } };
+import { ref, watch } from 'vue';
+import { componentsType } from './util';
+import { MonacoEditor } from '../../';
+import { Select, DatePicker, TimePicker, Input, InputNumber, InputPassword, Upload, Modal, } from 'ant-design-vue';
+const __sfc_main__ = _defineComponent({
+    props: {
+        // 组件双向绑定的值
+        modelValue: {
+            type: [Number, String],
+            default: '',
+        },
+        // 组件类型
+        itemType: {
+            type: String,
+            default: () => 'string',
+        },
+        // 多选框
+        mode: {
+            type: String,
+            default: '',
+        },
+        placeholder: String,
+        options: Array,
+        style: Object,
+        class: String,
+        valueFormat: String,
+        action: [String, Promise],
+        headers: Object,
+    },
+    emits: ["update:modelValue", "change"],
+    setup(__props, { emit: __emit }) {
+        const emit = __emit;
+        const props = __props;
+        const typeMap = new Map(Object.entries(componentsType));
+        const myValue = ref(undefined);
+        const modalVisible = ref(false);
+        const objectValue = ref('');
+        const handleItemModalSubmit = () => {
+            myValue.value = objectValue.value.replace(/[\r\n]\s*/g, '');
+            modalVisible.value = false;
+            emit('update:modelValue', objectValue.value);
+            emit('change', objectValue.value);
+        };
+        const onChange = (e) => {
+            emit('update:modelValue', myValue.value);
+            emit('change', e);
+        };
+        const handleFileChange = (info) => {
+            if (info.file.status === 'done') {
+                const url = _optionalChain([info, 'access', _2 => _2.file, 'access', _3 => _3.response, 'optionalAccess', _4 => _4.result]);
+                myValue.value = url;
+                emit('update:modelValue', url);
+                emit('change', url);
+            }
+        };
+        watch(() => props.modelValue, () => {
+            myValue.value = props.modelValue;
+            if (props.itemType === 'object') {
+                objectValue.value = props.modelValue;
+            }
+        }, { immediate: true });
+        return (_ctx, _cache) => {
+            const _component_AIcon = _resolveComponent("AIcon");
+            return (_openBlock(), _createElementBlock("div", _hoisted_1, [
+                (_unref(typeMap).get(__props.itemType) === 'select')
+                    ? (_openBlock(), _createBlock(_unref(Select), _mergeProps({
+                        key: 0,
+                        value: myValue.value,
+                        "onUpdate:value": _cache[0] || (_cache[0] = ($event) => ((myValue).value = $event)),
+                        allowClear: ""
+                    }, props, {
+                        onChange: _cache[1] || (_cache[1] = (_, options) => onChange(options))
+                    }), null, 16 /* FULL_PROPS */, ["value"]))
+                    : (_unref(typeMap).get(__props.itemType) === 'date')
+                        ? (_openBlock(), _createBlock(_unref(DatePicker), _mergeProps({
+                            key: 1,
+                            value: myValue.value,
+                            "onUpdate:value": _cache[2] || (_cache[2] = ($event) => ((myValue).value = $event)),
+                            valueFormat: __props.valueFormat || 'YYYY-MM-DD HH:mm:ss',
+                            allowClear: "",
+                            showTime: ""
+                        }, props, { onChange: onChange }), null, 16 /* FULL_PROPS */, ["value", "valueFormat"]))
+                        : (_unref(typeMap).get(__props.itemType) === 'time')
+                            ? (_openBlock(), _createBlock(_unref(TimePicker), _mergeProps({
+                                key: 2,
+                                value: myValue.value,
+                                "onUpdate:value": _cache[3] || (_cache[3] = ($event) => ((myValue).value = $event)),
+                                valueFormat: __props.valueFormat || 'HH:mm:ss',
+                                allowClear: ""
+                            }, props, { onChange: onChange }), null, 16 /* FULL_PROPS */, ["value", "valueFormat"]))
+                            : (_unref(typeMap).get(__props.itemType) === 'inputNumber')
+                                ? (_openBlock(), _createBlock(_unref(InputNumber), _mergeProps({
+                                    key: 3,
+                                    value: myValue.value,
+                                    "onUpdate:value": _cache[4] || (_cache[4] = ($event) => ((myValue).value = $event)),
+                                    allowClear: ""
+                                }, props, { onChange: onChange }), null, 16 /* FULL_PROPS */, ["value"]))
+                                : (_unref(typeMap).get(__props.itemType) === 'object')
+                                    ? (_openBlock(), _createBlock(_unref(Input), _mergeProps({
+                                        key: 4,
+                                        value: myValue.value,
+                                        "onUpdate:value": _cache[6] || (_cache[6] = ($event) => ((myValue).value = $event)),
+                                        allowClear: ""
+                                    }, props, { onChange: onChange }), {
+                                        addonAfter: _withCtx(() => [
+                                            _createVNode(_component_AIcon, {
+                                                type: "FormOutlined",
+                                                onClick: _cache[5] || (_cache[5] = ($event) => (modalVisible.value = true))
+                                            })
+                                        ]),
+                                        _: 1 /* STABLE */
+                                    }, 16 /* FULL_PROPS */, ["value"]))
+                                    : (_unref(typeMap).get(__props.itemType) === 'file')
+                                        ? (_openBlock(), _createBlock(_unref(Input), _mergeProps({
+                                            key: 5,
+                                            value: myValue.value,
+                                            "onUpdate:value": _cache[7] || (_cache[7] = ($event) => ((myValue).value = $event)),
+                                            allowClear: "",
+                                            placeholder: "请输入链接"
+                                        }, props, { onChange: onChange }), {
+                                            addonAfter: _withCtx(() => [
+                                                _createVNode(_unref(Upload), {
+                                                    action: __props.action,
+                                                    headers: __props.headers,
+                                                    showUploadList: false,
+                                                    name: "file",
+                                                    onChange: handleFileChange
+                                                }, {
+                                                    default: _withCtx(() => [
+                                                        _createVNode(_component_AIcon, { type: "UploadOutlined" })
+                                                    ]),
+                                                    _: 1 /* STABLE */
+                                                }, 8 /* PROPS */, ["action", "headers"])
+                                            ]),
+                                            _: 1 /* STABLE */
+                                        }, 16 /* FULL_PROPS */, ["value"]))
+                                        : (_unref(typeMap).get(__props.itemType) === 'password')
+                                            ? (_openBlock(), _createBlock(_unref(InputPassword), _mergeProps({
+                                                key: 6,
+                                                value: myValue.value,
+                                                "onUpdate:value": _cache[8] || (_cache[8] = ($event) => ((myValue).value = $event)),
+                                                allowClear: "",
+                                                type: "password"
+                                            }, props, { onChange: onChange }), null, 16 /* FULL_PROPS */, ["value"]))
+                                            : (_openBlock(), _createBlock(_unref(Input), _mergeProps({
+                                                key: 7,
+                                                value: myValue.value,
+                                                "onUpdate:value": _cache[9] || (_cache[9] = ($event) => ((myValue).value = $event)),
+                                                allowClear: "",
+                                                type: "text"
+                                            }, props, { onChange: onChange }), null, 16 /* FULL_PROPS */, ["value"])),
+                _createCommentVNode(" 代码编辑器弹窗 "),
+                _createVNode(_unref(Modal), {
+                    visible: modalVisible.value,
+                    "onUpdate:visible": _cache[11] || (_cache[11] = ($event) => ((modalVisible).value = $event)),
+                    zIndex: 1100,
+                    "cancel-text": "取消",
+                    "ok-text": "确认",
+                    title: "编辑",
+                    width: "700px",
+                    onCancel: _cache[12] || (_cache[12] = ($event) => (modalVisible.value = false)),
+                    onOk: handleItemModalSubmit
+                }, {
+                    default: _withCtx(() => [
+                        _createElementVNode("div", _hoisted_2, [
+                            _createVNode(_unref(MonacoEditor), {
+                                modelValue: objectValue.value,
+                                "onUpdate:modelValue": _cache[10] || (_cache[10] = ($event) => ((objectValue).value = $event))
+                            }, null, 8 /* PROPS */, ["modelValue"])
+                        ])
+                    ]),
+                    _: 1 /* STABLE */
+                }, 8 /* PROPS */, ["visible"])
+            ]));
+        };
+    }
+});
+export default __sfc_main__;

package/es/ValueItem/index.js

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

package/es/ValueItem/util.js

@@ -0,0 +1,16 @@
+export var componentsType = {
+  int: 'inputNumber',
+  long: 'inputNumber',
+  float: 'inputNumber',
+  double: 'inputNumber',
+  string: 'input',
+  array: 'input',
+  password: 'password',
+  enum: 'select',
+  boolean: 'select',
+  date: 'date',
+  time: 'time',
+  object: 'object',
+  geoPoint: 'geoPoint',
+  file: 'file'
+};

package/es/index.js

@@ -0,0 +1,24 @@
+import InitAMap from './AMap';
+import BadgeStatus from './BadgeStatus';
+import CardSelect from './CardSelect';
+import CheckButton from './CheckButton';
+import ConfigProvider from './ConfigProvider';
+import Echarts from './Echarts';
+import Ellipsis from './Ellipsis';
+import Empty from './Empty';
+import FullPage from './FullPage';
+import AIcon from './Icon';
+import MonacoEditor from './MonacoEditor';
+import PermissionButton from './PermissionButton';
+import ProLayout, { PageContainer } from './ProLayout';
+import ProTable from './ProTable';
+import Scrollbar from './Scrollbar';
+import Search, { AdvancedSearch } from './Search';
+import ValueItem from './ValueItem';
+export * from './style';
+export { BadgeStatus, CardSelect, CheckButton, Echarts, Ellipsis, Empty, FullPage, AIcon, MonacoEditor, PermissionButton, ValueItem, ProTable, Scrollbar, Search, AdvancedSearch, ConfigProvider };
+export default {
+  install: function install(app) {
+    app.component('JAMap', InitAMap).component('JBadgeStatus', BadgeStatus).component('JCardSelect', CardSelect).component('JCheckButton', CheckButton).component('JConfigProvider', ConfigProvider).component('JEcharts', Echarts).component('JEllipsis', Ellipsis).component('JEmpty', Empty).component('JFullPage', FullPage).component('AIcon', AIcon).component('JMonacoEditor', MonacoEditor).component('JPermissionButton', PermissionButton).component('JProLayout', ProLayout).component('JPageContainer', PageContainer).component('JProTable', ProTable).component('JScrollbar', Scrollbar).component('JSearch', Search).component('JAdvancedSearch', AdvancedSearch).component('JValueItem', ValueItem);
+  }
+};

package/es/style/index.js

@@ -0,0 +1,3 @@
+import '../ProLayout/style';
+import '../ProTable/style';
+import '../ProLayout/style';

package/{src → es}/style/variable.less

@@ -1,4 +1,2 @@
-@import 'ant-design-vue/es/style/themes/index.less';
-
 @text-color-title: #000;
 @text-color-subtitle: #263237;

package/lib/AMap/Map.js

@@ -0,0 +1,124 @@
+/* Analyzed bindings: {
+  "style": "props",
+  "class": "props",
+  "AMapUI": "props",
+  "center": "props",
+  "plugins": "props",
+  "zooms": "props",
+  "JSKey": "props",
+  "WebKey": "props",
+  "ref": "setup-const",
+  "computed": "setup-const",
+  "initAMapApiLoader": "setup-maybe-ref",
+  "ElAmap": "setup-maybe-ref",
+  "getAMapUiPromise": "setup-maybe-ref",
+  "MapProps": "setup-maybe-ref",
+  "MAPConfig": "setup-maybe-ref",
+  "Empty": "setup-maybe-ref",
+  "emit": "setup-const",
+  "props": "setup-reactive-const",
+  "config": "setup-maybe-ref",
+  "_mapStyle": "setup-ref",
+  "hasAMapKey": "setup-ref",
+  "uiLoading": "setup-ref",
+  "map": "setup-ref",
+  "isOpenUi": "setup-ref",
+  "getAMapUI": "setup-const",
+  "initMap": "setup-const"
+} */
+import { defineComponent as _defineComponent } from 'vue';
+import { renderSlot as _renderSlot, unref as _unref, mergeProps as _mergeProps, withCtx as _withCtx, openBlock as _openBlock, createBlock as _createBlock, normalizeClass as _normalizeClass, normalizeStyle as _normalizeStyle, createElementBlock as _createElementBlock } from "vue";
+import { ref, computed } from 'vue';
+import { initAMapApiLoader, ElAmap } from '@vuemap/vue-amap';
+import { getAMapUiPromise } from '@jetlinks-web/utils';
+import { MapProps } from './util';
+import { MAPConfig } from "@jetlinks-web/constants";
+import Empty from '../Empty';
+import '@vuemap/vue-amap/dist/style.css';
+const __sfc_main__ = _defineComponent({
+    props: {
+        ...MapProps(),
+        style: Object,
+        class: String,
+        AMapUI: [String, Boolean],
+        center: Array,
+        plugins: Array,
+        zooms: {
+            type: Array,
+            default: [3, 20]
+        },
+        JSKey: String,
+        WebKey: String,
+    },
+    emits: [
+        'initMap',
+    ],
+    setup(__props, { emit: __emit }) {
+        const emit = __emit;
+        const props = __props;
+        const config = inject(MAPConfig);
+        const _mapStyle = computed(() => {
+            if (props.mapStyle) {
+                return `amap://styles/${props.mapStyle}`;
+            }
+            if (config.mapStyle) {
+                return config.mapStyle;
+            }
+            return undefined;
+        });
+        const hasAMapKey = computed(() => {
+            return !!(props.JSKey || config.JSKey);
+        });
+        initAMapApiLoader({
+            key: props.JSKey || config.JSKey || '',
+            securityJsCode: props.WebKey || config.WebKey,
+            plugins: props.plugins
+        });
+        const uiLoading = ref(false);
+        const map = ref(null);
+        const isOpenUi = computed(() => {
+            return 'AMapUI' in props || props.AMapUI;
+        });
+        const getAMapUI = () => {
+            const version = typeof props.AMapUI === 'string' ? props.AMapUI : '1.1';
+            getAMapUiPromise(version).then(() => {
+                uiLoading.value = true;
+            });
+        };
+        const initMap = (e) => {
+            map.value = e;
+            emit('initMap', e);
+            if (isOpenUi.value) {
+                getAMapUI();
+            }
+        };
+        return (_ctx, _cache) => {
+            return (_openBlock(), _createElementBlock("div", {
+                style: _normalizeStyle(props.style || { width: '100%', height: '100%' }),
+                class: _normalizeClass(props.class)
+            }, [
+                (hasAMapKey.value)
+                    ? (_openBlock(), _createBlock(_unref(ElAmap), _mergeProps({
+                        key: 0,
+                        "map-style": _mapStyle.value
+                    }, {
+                        ...props,
+                        ..._ctx.$attrs
+                    }, { onInit: initMap }), {
+                        default: _withCtx(() => [
+                            (uiLoading.value)
+                                ? _renderSlot(_ctx.$slots, "default", { key: 0 })
+                                : _renderSlot(_ctx.$slots, "default", { key: 1 })
+                        ]),
+                        _: 3 /* FORWARDED */
+                    }, 16 /* FULL_PROPS */, ["map-style"]))
+                    : (_openBlock(), _createBlock(_unref(Empty), {
+                        key: 1,
+                        description: "请配置高德地图key",
+                        style: { "padding": "20%" }
+                    }))
+            ], 6 /* CLASS, STYLE */));
+        };
+    }
+});
+export default __sfc_main__;

package/lib/AMap/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Map = _interopRequireDefault(require("./Map.js"));
+var _default = exports.default = _Map.default;

package/lib/AMap/util.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MapProps = void 0;
+var MapProps = exports.MapProps = function MapProps() {
+  return {
+    //  响应式
+    center: Array,
+    labelzIndex: Number,
+    lang: String,
+    mapStyle: String,
+    //  静态属性
+    vid: String,
+    amapManager: Object,
+    defaultCursor: String,
+    animateEnable: {
+      type: Boolean,
+      default: true
+    },
+    isHotspot: Boolean,
+    rotateEnable: {
+      type: Boolean,
+      default: true
+    },
+    resizeEnable: {
+      type: Boolean,
+      default: true
+    },
+    showIndoorMap: Boolean,
+    expandZoomRange: Boolean,
+    dragEnable: {
+      type: Boolean,
+      default: true
+    },
+    zoomEnable: {
+      type: Boolean,
+      default: true
+    },
+    doubleClickZoom: {
+      type: Boolean,
+      default: true
+    },
+    keyboardEnable: {
+      type: Boolean,
+      default: true
+    },
+    jogEnable: {
+      type: Boolean,
+      default: true
+    },
+    scrollWheel: {
+      type: Boolean,
+      default: true
+    },
+    touchZoom: {
+      type: Boolean,
+      default: true
+    }
+  };
+};

package/lib/BadgeStatus/Badge.js

@@ -0,0 +1,54 @@
+/* Analyzed bindings: {
+  "text": "props",
+  "status": "props",
+  "statusNames": "props",
+  "computed": "setup-const",
+  "getHexColor": "setup-maybe-ref",
+  "props": "setup-reactive-const",
+  "_color": "setup-ref"
+} */
+import { defineComponent as _defineComponent } from 'vue';
+import { resolveComponent as _resolveComponent, openBlock as _openBlock, createBlock as _createBlock } from "vue";
+import { computed } from 'vue';
+import { getHexColor } from './color';
+const __sfc_main__ = _defineComponent({
+    props: {
+        text: {
+            type: String,
+        },
+        status: {
+            type: [String, Number],
+            default: 'default',
+        },
+        /**
+         * 自定义status值颜色
+         * @example {
+         *   1: 'success',
+         *   0: 'error'
+         * }
+         */
+        statusNames: {
+            type: Object,
+            default: () => ({
+                'success': 'success',
+                'warning': 'warning',
+                'error': 'error',
+                'default': 'default',
+            })
+        },
+    },
+    setup(__props) {
+        const props = __props;
+        const _color = computed(() => {
+            return getHexColor(props.status, props.statusNames, 1);
+        });
+        return (_ctx, _cache) => {
+            const _component_a_badge = _resolveComponent("a-badge");
+            return (_openBlock(), _createBlock(_component_a_badge, {
+                color: _color.value,
+                text: __props.text
+            }, null, 8 /* PROPS */, ["color", "text"]));
+        };
+    }
+});
+export default __sfc_main__;

package/lib/BadgeStatus/color.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getHexColor = exports.default = void 0;
+var colorMap = {
+  'success': '36, 178, 118',
+  'warning': '255, 144, 0',
+  'error': '229, 0, 18',
+  'processing': '9, 46, 231',
+  'default': '102, 102, 102'
+};
+var getHexColor = exports.getHexColor = function getHexColor(code, statusNames) {
+  var pe = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0.1;
+  if (!code) {
+    return "rgba(102, 102, 102, ".concat(pe, ")");
+  }
+  if (colorMap[code]) {
+    return "rgba(".concat(colorMap[code], ", ").concat(pe, ")");
+  }
+  if (Object.keys(statusNames).length) {
+    return statusNames[code];
+  }
+  return;
+};
+var _default = exports.default = colorMap;

package/lib/BadgeStatus/index.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+exports.default = void 0;
+var _Badge = _interopRequireDefault(require("./Badge.js"));
+var _color = require("./color");
+Object.keys(_color).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _color[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _color[key];
+    }
+  });
+});
+var _default = exports.default = _Badge.default;