@jetlinks-web/components 2.0.2 → 2.0.3

package/es/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/es/AMap/index.js

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

package/es/AMap/util.js

@@ -0,0 +1,56 @@
+export var 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/es/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/es/BadgeStatus/color.js

@@ -0,0 +1,21 @@
+var colorMap = {
+  'success': '36, 178, 118',
+  'warning': '255, 144, 0',
+  'error': '229, 0, 18',
+  'processing': '9, 46, 231',
+  'default': '102, 102, 102'
+};
+export var 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;
+};
+export default colorMap;

package/es/BadgeStatus/index.js

@@ -0,0 +1,3 @@
+import BadgeStatus from './Badge.js';
+export * from './color';
+export default BadgeStatus;

package/es/CardSelect/CardSelect.js

@@ -0,0 +1,123 @@
+/* Analyzed bindings: {
+  "layout": "props",
+  "options": "props",
+  "disabled": "props",
+  "multiple": "props",
+  "column": "props",
+  "value": "props",
+  "itemLayout": "props",
+  "has": "setup-maybe-ref",
+  "props": "setup-reactive-const",
+  "emit": "setup-const",
+  "selectKeys": "setup-maybe-ref",
+  "CardSelectStyle": "setup-maybe-ref",
+  "isMultiple": "setup-maybe-ref",
+  "handleSelect": "setup-const"
+} */
+import { unref as _unref, renderList as _renderList, Fragment as _Fragment, openBlock as _openBlock, createElementBlock as _createElementBlock, renderSlot as _renderSlot, toDisplayString as _toDisplayString, createElementVNode as _createElementVNode, normalizeClass as _normalizeClass, normalizeStyle as _normalizeStyle } from "vue";
+const _hoisted_1 = ["onClick"];
+const _hoisted_2 = { class: "j-card-select-item-content" };
+const _hoisted_3 = { class: "j-card-select-title" };
+const _hoisted_4 = { class: "j-card-select-describe" };
+import { has } from 'lodash-es';
+const __sfc_main__ = {
+    props: {
+        layout: {
+            type: String,
+            default: 'horizontal'
+        },
+        options: {
+            type: Array,
+            default: () => [],
+        },
+        disabled: {
+            type: Boolean,
+            default: false,
+        },
+        multiple: {
+            type: Boolean,
+            default: false,
+        },
+        column: {
+            type: Number,
+            default: 3,
+        },
+        value: {
+            type: [String, Array],
+            default: undefined,
+        },
+        itemLayout: {
+            type: String,
+            default: 'horizontal'
+        }
+    },
+    emits: ['select', 'change', 'update:value'],
+    setup(__props, { emit: __emit }) {
+        const props = __props;
+        const emit = __emit;
+        const selectKeys = ref([]);
+        const CardSelectStyle = computed(() => {
+            const _column = props.column > 0 && props.layout === 'horizontal' ? props.column : 1;
+            return {
+                'grid-template-columns': `repeat(${_column}, 1fr)`
+            };
+        });
+        const isMultiple = computed(() => {
+            return has(props, 'multiple') && props.multiple !== false;
+        });
+        const handleSelect = (key, node) => {
+            if (props.disabled || node.disabled) {
+                return;
+            }
+            const selectKeysSet = new Set(selectKeys.value);
+            const isActive = selectKeysSet.has(key);
+            if (isMultiple.value) {
+                if (isActive) {
+                    selectKeysSet.delete(key);
+                }
+                else {
+                    selectKeysSet.add(key);
+                }
+                selectKeys.value = [...selectKeysSet.values()];
+                const nodes = props.options.filter(item => selectKeys.value.includes(item.value));
+                emit('select', selectKeys.value, nodes);
+                emit('change', selectKeys.value, nodes);
+                emit('update:value', selectKeys.value);
+            }
+            else {
+                selectKeys.value = [key];
+                emit('select', key, node);
+                emit('change', key, node);
+                emit('update:value', key);
+            }
+        };
+        watch(() => props.value, () => {
+            selectKeys.value = isMultiple.value ? props.value : [props.value];
+        }, { immediate: true });
+        return (_ctx, _cache) => {
+            return (_openBlock(), _createElementBlock("div", {
+                class: "j-card-select",
+                style: _normalizeStyle(_unref(CardSelectStyle))
+            }, [
+                (_openBlock(true), _createElementBlock(_Fragment, null, _renderList(__props.options, (item) => {
+                    return (_openBlock(), _createElementBlock("div", {
+                        class: _normalizeClass({
+                            'j-card-select-item': true,
+                            'disabled': __props.disabled || item.disabled,
+                            'active': _unref(selectKeys).includes(item.value)
+                        }),
+                        onClick: () => handleSelect(item.value, item)
+                    }, [
+                        _renderSlot(_ctx.$slots, "itemRender", { node: item }, () => [
+                            _createElementVNode("div", _hoisted_2, [
+                                _createElementVNode("div", _hoisted_3, _toDisplayString(item.label), 1 /* TEXT */),
+                                _createElementVNode("div", _hoisted_4, _toDisplayString(item.describe), 1 /* TEXT */)
+                            ])
+                        ])
+                    ], 10 /* CLASS, PROPS */, _hoisted_1));
+                }), 256 /* UNKEYED_FRAGMENT */))
+            ], 4 /* STYLE */));
+        };
+    }
+};
+export default __sfc_main__;

package/es/CardSelect/index.js

@@ -0,0 +1,2 @@
+import CardSelect from "./CardSelect.js";
+export default CardSelect;

package/es/CheckButton/CheckButton.js

@@ -0,0 +1,121 @@
+/* Analyzed bindings: {
+  "value": "props",
+  "options": "props",
+  "multiple": "props",
+  "disabled": "props",
+  "class": "props",
+  "style": "props",
+  "computed": "setup-const",
+  "CSSProperties": "setup-const",
+  "PropType": "setup-const",
+  "ref": "setup-const",
+  "watch": "setup-const",
+  "isArray": "setup-maybe-ref",
+  "props": "setup-reactive-const",
+  "emit": "setup-const",
+  "myValue": "setup-ref",
+  "optionsMap": "setup-ref",
+  "_options": "setup-ref",
+  "selected": "setup-const"
+} */
+import { defineComponent as _defineComponent } from 'vue';
+import { renderList as _renderList, Fragment as _Fragment, openBlock as _openBlock, createElementBlock as _createElementBlock, toDisplayString as _toDisplayString, normalizeClass as _normalizeClass, normalizeStyle as _normalizeStyle, pushScopeId as _pushScopeId, popScopeId as _popScopeId } from "vue";
+const _withScopeId = n => (_pushScopeId("data-v-1712546546166"), n = n(), _popScopeId(), n);
+const _hoisted_1 = ["onClick"];
+import { computed, ref, watch } from 'vue';
+import { isArray } from '@jetlinks-web/utils';
+const __sfc_main__ = _defineComponent({
+    props: {
+        value: {
+            type: [String, Array],
+            default: undefined,
+        },
+        options: {
+            type: Array,
+            default: () => [],
+        },
+        multiple: {
+            type: Boolean,
+            default: false,
+        },
+        disabled: {
+            type: Boolean,
+            default: false,
+        },
+        class: {
+            type: String,
+            default: undefined,
+        },
+        style: {
+            type: Object,
+            default: () => ({}),
+        },
+    },
+    emits: ['update:value', 'change', 'select'],
+    setup(__props, { emit: __emit }) {
+        const props = __props;
+        const emit = __emit;
+        const myValue = ref();
+        const optionsMap = ref(new Map());
+        const _options = computed(() => {
+            props.options.forEach((item) => {
+                if (props.disabled) {
+                    item.display = props.disabled;
+                }
+                optionsMap.value.set(item.value, item);
+            });
+            return props.options;
+        });
+        watch(() => props.value, () => {
+            if (props.value) {
+                myValue.value = isArray(props.value) ? props.value : [props.value];
+            }
+            else {
+                myValue.value = [];
+            }
+        }, { immediate: true, deep: true });
+        const selected = (key, disabled) => {
+            if (disabled)
+                return;
+            const values = new Set(myValue.value);
+            if (values.has(key)) {
+                values.delete(key);
+            }
+            else {
+                if (!props.multiple) {
+                    values.clear();
+                }
+                values.add(key);
+            }
+            myValue.value = [...values.values()];
+            const optionsItems = myValue.value.map((_key) => {
+                return optionsMap.value.get(_key);
+            });
+            const _value = props.multiple ? myValue.value : myValue.value[0];
+            emit('update:value', _value);
+            emit('change', _value, props.multiple ? optionsItems : optionsItems[0]);
+            emit('select', _value, props.multiple ? optionsItems : optionsItems[0]);
+        };
+        return (_ctx, _cache) => {
+            return (_openBlock(), _createElementBlock("div", {
+                class: _normalizeClass(['j-check-button', props.class]),
+                style: _normalizeStyle(__props.style)
+            }, [
+                (_openBlock(true), _createElementBlock(_Fragment, null, _renderList(_options.value, (item) => {
+                    return (_openBlock(), _createElementBlock("div", {
+                        key: item.value,
+                        class: _normalizeClass([
+                            'j-check-button-item',
+                            myValue.value.includes(item.value) ? 'selected' : '',
+                            item.disabled ? 'disabled' : '',
+                        ]),
+                        onClick: () => {
+                            selected(item.value, item.disabled);
+                        }
+                    }, _toDisplayString(item.label), 11 /* TEXT, CLASS, PROPS */, _hoisted_1));
+                }), 128 /* KEYED_FRAGMENT */))
+            ], 6 /* CLASS, STYLE */));
+        };
+    }
+});
+export default __sfc_main__;

package/es/CheckButton/index.js

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

package/es/ConfigProvider/context.js

@@ -0,0 +1,12 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { configProviderProps } from 'ant-design-vue/es/config-provider/context';
+export var configProps = function configProps() {
+  return _objectSpread(_objectSpread({}, configProviderProps()), {}, {
+    IconConfig: {
+      type: Object
+    },
+    MapConfig: {
+      type: Object
+    }
+  });
+};

package/es/ConfigProvider/index.js

@@ -0,0 +1,31 @@
+import { createVNode as _createVNode } from "vue";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { defineComponent, provide, reactive, h } from 'vue';
+import { configProps } from './context';
+import { ComponentsEnum, MAPConfig } from '@jetlinks-web/constants';
+import { ConfigProvider } from 'ant-design-vue';
+import { omit } from 'lodash-es';
+import Empty from '../Empty';
+var JConfigProvider = defineComponent({
+  name: 'JConfigProvider',
+  inheritAttrs: false,
+  props: _objectSpread({}, configProps()),
+  setup: function setup(props, _ref) {
+    var slots = _ref.slots;
+    var _iconConfig = reactive(props.IconConfig || {});
+    var _mapConfig = reactive(props.MapConfig || {});
+    provide(ComponentsEnum.Icon, _iconConfig); // 全局Icon 配置
+    provide(MAPConfig, _mapConfig); // 全局地图配置
+    return function () {
+      return h(ConfigProvider, _objectSpread({}, omit(props, ['IconConfig', 'MapConfig'])), {
+        default: slots.default,
+        renderEmpty: function renderEmpty() {
+          var _slots$renderEmpty;
+          return ((_slots$renderEmpty = slots.renderEmpty) === null || _slots$renderEmpty === void 0 ? void 0 : _slots$renderEmpty.call(slots)) || _createVNode(Empty, null, null);
+        }
+      });
+    };
+  }
+});
+JConfigProvider.config = ConfigProvider.config;
+export default JConfigProvider;

package/es/Echarts/Echarts.js

@@ -0,0 +1,47 @@
+/* Analyzed bindings: {
+  "options": "props",
+  "style": "props",
+  "CSSProperties": "setup-const",
+  "nextTick": "setup-const",
+  "ref": "setup-const",
+  "watch": "setup-const",
+  "Ref": "setup-const",
+  "useECharts": "setup-maybe-ref",
+  "props": "setup-reactive-const",
+  "echartsDom": "setup-ref",
+  "setOptions": "setup-maybe-ref"
+} */
+import { defineComponent as _defineComponent } from 'vue';
+import { normalizeStyle as _normalizeStyle, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue";
+import { nextTick, ref, watch, } from 'vue';
+import { useECharts } from '@jetlinks-web/hooks';
+const __sfc_main__ = _defineComponent({
+    props: {
+        options: {
+            type: Object,
+            default: undefined,
+        },
+        style: Object,
+    },
+    setup(__props) {
+        const props = __props;
+        const echartsDom = ref();
+        const { setOptions } = useECharts(echartsDom.value);
+        watch(() => JSON.stringify(props.options), () => {
+            if (props.options) {
+                nextTick(() => {
+                    setOptions(props.options);
+                });
+            }
+        }, { immediate: true });
+        return (_ctx, _cache) => {
+            return (_openBlock(), _createElementBlock("div", {
+                ref_key: "echartsDom",
+                ref: echartsDom,
+                class: "echarts-warp",
+                style: _normalizeStyle(__props.style)
+            }, null, 4 /* STYLE */));
+        };
+    }
+});
+export default __sfc_main__;

package/es/Echarts/index.js

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