vxe-pc-ui 3.16.0 → 3.16.1

package/es/ui/src/anime.js

@@ -0,0 +1,46 @@
+import XEUtils from 'xe-utils';
+import { addClass, removeClass } from '../../ui/src/dom';
+const rowMoveCls = 'row--drag-move';
+const colMoveClass = 'col--drag-move';
+/**
+ * 上下拖拽
+ */
+export function moveRowAnimateToTb(elemList, offsetTop) {
+    XEUtils.arrayEach(elemList, trEl => {
+        trEl.style.transform = `translateY(${offsetTop}px)`;
+    });
+    requestAnimationFrame(() => {
+        XEUtils.arrayEach(elemList, trEl => {
+            addClass(trEl, rowMoveCls);
+            trEl.style.transform = '';
+        });
+    });
+}
+export function clearRowAnimate(elem, clss) {
+    setTimeout(() => {
+        if (elem) {
+            XEUtils.arrayEach(elem.querySelectorAll(clss.map(cls => `${cls}.${rowMoveCls}`).join(',')), elem => removeClass(elem, rowMoveCls));
+        }
+    }, 500);
+}
+/**
+ * 左右拖拽
+ */
+export function moveColAnimateToLr(elemList, offsetLeft) {
+    XEUtils.arrayEach(elemList, trEl => {
+        trEl.style.transform = `translateX(${offsetLeft}px)`;
+    });
+    requestAnimationFrame(() => {
+        XEUtils.arrayEach(elemList, trEl => {
+            addClass(trEl, colMoveClass);
+            trEl.style.transform = '';
+        });
+    });
+}
+export function clearColAnimate(elem, clss) {
+    setTimeout(() => {
+        if (elem) {
+            XEUtils.arrayEach(elem.querySelectorAll(clss.map(cls => `${cls}.${rowMoveCls}`).join(',')), elem => removeClass(elem, colMoveClass));
+        }
+    }, 500);
+}

package/es/ui/src/comp.js

@@ -0,0 +1 @@
+export const defineVxeComponent = ((options) => options);

package/es/ui/src/dom.js

@@ -0,0 +1,255 @@
+import XEUtils from 'xe-utils';
+let tpImgEl;
+export function initTpImg() {
+    if (!tpImgEl) {
+        tpImgEl = new Image();
+        tpImgEl.src = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=';
+    }
+    return tpImgEl;
+}
+export function getTpImg() {
+    if (!tpImgEl) {
+        return initTpImg();
+    }
+    return tpImgEl;
+}
+const reClsMap = {};
+function getClsRE(cls) {
+    if (!reClsMap[cls]) {
+        reClsMap[cls] = new RegExp(`(?:^|\\s)${cls}(?!\\S)`, 'g');
+    }
+    return reClsMap[cls];
+}
+function getNodeOffset(elem, container, rest) {
+    if (elem) {
+        const parentElem = elem.parentNode;
+        rest.top += elem.offsetTop;
+        rest.left += elem.offsetLeft;
+        if (parentElem && parentElem !== document.documentElement && parentElem !== document.body) {
+            rest.top -= parentElem.scrollTop;
+            rest.left -= parentElem.scrollLeft;
+        }
+        if (container && (elem === container || elem.offsetParent === container) ? 0 : elem.offsetParent) {
+            return getNodeOffset(elem.offsetParent, container, rest);
+        }
+    }
+    return rest;
+}
+export function isPx(val) {
+    return val && /^\d+(\.\d+)?(px)?$/.test(val);
+}
+export function isScale(val) {
+    return val && /^\d+(\.\d+)?%$/.test(val);
+}
+export function hasClass(elem, cls) {
+    return !!(elem && elem.className && elem.className.match && elem.className.match(getClsRE(cls)));
+}
+export function removeClass(elem, cls) {
+    if (elem && hasClass(elem, cls)) {
+        elem.className = elem.className.replace(getClsRE(cls), '');
+    }
+}
+export function addClass(elem, cls) {
+    if (elem && !hasClass(elem, cls)) {
+        removeClass(elem, cls);
+        elem.className = `${elem.className} ${cls}`;
+    }
+}
+export function hasControlKey(evnt) {
+    return evnt.ctrlKey || evnt.metaKey;
+}
+export function toCssUnit(val, unit = 'px') {
+    if (XEUtils.isNumber(val) || /^\d+$/.test(`${val}`)) {
+        return `${val}${unit}`;
+    }
+    return `${val || ''}`;
+}
+export function getDomNode() {
+    const documentElement = document.documentElement;
+    const bodyElem = document.body;
+    return {
+        scrollTop: documentElement.scrollTop || bodyElem.scrollTop,
+        scrollLeft: documentElement.scrollLeft || bodyElem.scrollLeft,
+        visibleHeight: documentElement.clientHeight || bodyElem.clientHeight,
+        visibleWidth: documentElement.clientWidth || bodyElem.clientWidth
+    };
+}
+/**
+ * 检查触发源是否属于目标节点
+ */
+export function getEventTargetNode(evnt, container, queryCls, queryMethod) {
+    let targetElem;
+    let target = (evnt.target.shadowRoot && evnt.composed) ? (evnt.composedPath()[0] || evnt.target) : evnt.target;
+    while (target && target.nodeType && target !== document) {
+        if (queryCls && hasClass(target, queryCls) && (!queryMethod || queryMethod(target))) {
+            targetElem = target;
+        }
+        else if (target === container) {
+            return { flag: queryCls ? !!targetElem : true, container, targetElem: targetElem };
+        }
+        target = target.parentNode;
+    }
+    return { flag: false };
+}
+/**
+ * 获取元素相对于 document 的位置
+ */
+export function getOffsetPos(elem, container) {
+    return getNodeOffset(elem, container, { left: 0, top: 0 });
+}
+export function getAbsolutePos(elem) {
+    const bounding = elem.getBoundingClientRect();
+    const boundingTop = bounding.top;
+    const boundingLeft = bounding.left;
+    const { scrollTop, scrollLeft, visibleHeight, visibleWidth } = getDomNode();
+    return { boundingTop, top: scrollTop + boundingTop, boundingLeft, left: scrollLeft + boundingLeft, visibleHeight, visibleWidth };
+}
+export function getPaddingTopBottomSize(elem) {
+    if (elem) {
+        const computedStyle = getComputedStyle(elem);
+        const paddingTop = XEUtils.toNumber(computedStyle.paddingTop);
+        const paddingBottom = XEUtils.toNumber(computedStyle.paddingBottom);
+        return paddingTop + paddingBottom;
+    }
+    return 0;
+}
+export function getPaddingLeftRightSize(elem) {
+    if (elem) {
+        const computedStyle = getComputedStyle(elem);
+        const paddingLeft = XEUtils.toNumber(computedStyle.paddingLeft);
+        const paddingRight = XEUtils.toNumber(computedStyle.paddingRight);
+        return paddingLeft + paddingRight;
+    }
+    return 0;
+}
+const scrollIntoViewIfNeeded = 'scrollIntoViewIfNeeded';
+const scrollIntoView = 'scrollIntoView';
+export function scrollToView(elem) {
+    if (elem) {
+        if (elem[scrollIntoViewIfNeeded]) {
+            elem[scrollIntoViewIfNeeded]();
+        }
+        else if (elem[scrollIntoView]) {
+            elem[scrollIntoView]();
+        }
+    }
+}
+export function triggerEvent(targetElem, type) {
+    if (targetElem) {
+        targetElem.dispatchEvent(new Event(type));
+    }
+}
+export function isNodeElement(elem) {
+    return elem && elem.nodeType === 1;
+}
+export function updatePanelPlacement(targetElem, panelElem, options) {
+    const { placement, defaultPlacement, teleportTo, marginSize, isMinWidth } = Object.assign({ teleportTo: false, marginSize: 18, isMinWidth: true }, options);
+    let panelPlacement = 'bottom';
+    let top = '';
+    let bottom = '';
+    let left = '';
+    const right = '';
+    let minWidth = '';
+    const stys = {};
+    if (panelElem && targetElem) {
+        const documentElement = document.documentElement;
+        const bodyElem = document.body;
+        const targetHeight = targetElem.offsetHeight;
+        const panelHeight = panelElem.offsetHeight;
+        const panelWidth = panelElem.offsetWidth;
+        const panelRect = panelElem.getBoundingClientRect();
+        const targetRect = targetElem.getBoundingClientRect();
+        const visibleHeight = documentElement.clientHeight || bodyElem.clientHeight;
+        const visibleWidth = documentElement.clientWidth || bodyElem.clientWidth;
+        minWidth = targetElem.offsetWidth;
+        if (teleportTo) {
+            left = targetRect.left;
+            top = targetRect.top + targetHeight;
+            if (placement === 'top') {
+                panelPlacement = 'top';
+                top = targetRect.top - panelHeight;
+            }
+            else if (!placement) {
+                if (defaultPlacement === 'top') {
+                    panelPlacement = 'top';
+                    top = targetRect.top - panelHeight;
+                    // 如果上面不够放，则向下
+                    if (top < marginSize) {
+                        panelPlacement = 'bottom';
+                        top = targetRect.top + targetHeight;
+                    }
+                    // 如果下面不够放，则向上（优先）
+                    if (top + panelHeight + marginSize > visibleHeight) {
+                        panelPlacement = 'top';
+                        top = targetRect.top - panelHeight;
+                    }
+                }
+                else {
+                    // 如果下面不够放，则向上
+                    if (top + panelHeight + marginSize > visibleHeight) {
+                        panelPlacement = 'top';
+                        top = targetRect.top - panelHeight;
+                    }
+                    // 如果上面不够放，则向下（优先）
+                    if (top < marginSize) {
+                        panelPlacement = 'bottom';
+                        top = targetRect.top + targetHeight;
+                    }
+                }
+            }
+            // 如果溢出右边
+            if (left + panelWidth + marginSize > visibleWidth) {
+                left -= left + panelWidth + marginSize - visibleWidth;
+            }
+            // 如果溢出左边
+            if (left < marginSize) {
+                left = marginSize;
+            }
+        }
+        else {
+            if (placement === 'top') {
+                panelPlacement = 'top';
+                bottom = targetHeight;
+            }
+            else if (!placement) {
+                // 如果下面不够放，则向上
+                top = targetHeight;
+                if (targetRect.top + targetHeight + panelHeight + marginSize > visibleHeight) {
+                    // 如果上面不够放，则向下（优先）
+                    if (targetRect.top - targetHeight - panelHeight > marginSize) {
+                        panelPlacement = 'top';
+                        top = '';
+                        bottom = targetHeight;
+                    }
+                }
+            }
+            // 是否超出右侧
+            if (panelRect.left + panelRect.width + marginSize > visibleWidth) {
+                left = -(panelRect.left + panelRect.width + marginSize - visibleWidth);
+            }
+        }
+        if (XEUtils.isNumber(top)) {
+            stys.top = toCssUnit(top);
+        }
+        if (XEUtils.isNumber(bottom)) {
+            stys.bottom = toCssUnit(bottom);
+        }
+        if (XEUtils.isNumber(left)) {
+            stys.left = toCssUnit(left);
+        }
+        if (XEUtils.isNumber(right)) {
+            stys.right = toCssUnit(right);
+        }
+        if (isMinWidth && XEUtils.isNumber(minWidth)) {
+            stys.minWidth = toCssUnit(minWidth);
+        }
+    }
+    return {
+        top: top || 0,
+        bottom: bottom || 0,
+        left: left || 0,
+        right: right || 0,
+        style: stys,
+        placement: panelPlacement
+    };
+}

package/es/ui/src/log.js

@@ -0,0 +1,15 @@
+import { VxeUI } from '@vxe-ui/core';
+const { log } = VxeUI;
+const uiVersion = `ui v${"3.16.1"}`;
+export function createComponentLog(name) {
+    const tableVersion = VxeUI.tableVersion ? `table v${VxeUI.tableVersion}` : '';
+    const ganttVersion = VxeUI.ganttVersion ? `gantt v${VxeUI.ganttVersion}` : '';
+    const designVersion = VxeUI.designVersion ? `design v${VxeUI.designVersion}` : '';
+    const versionInfo = [uiVersion, tableVersion, ganttVersion, designVersion].join(' ');
+    return {
+        warnLog: log.create('warn', versionInfo + '] [' + name),
+        errLog: log.create('error', versionInfo + '] [' + name)
+    };
+}
+export const warnLog = log.create('warn', uiVersion);
+export const errLog = log.create('error', uiVersion);

package/es/ui/src/utils.js

@@ -0,0 +1,52 @@
+import XEUtils from 'xe-utils';
+import { getConfig } from '@vxe-ui/core';
+import DomZIndex from 'dom-zindex';
+export function isEnableConf(conf) {
+    return conf && conf.enabled !== false;
+}
+export function nextZIndex() {
+    return DomZIndex.getNext();
+}
+export function getLastZIndex() {
+    return DomZIndex.getCurrent();
+}
+export function nextSubZIndex() {
+    return DomZIndex.getSubNext();
+}
+export function getSubLastZIndex() {
+    return DomZIndex.getSubCurrent();
+}
+export function getGlobalDefaultConfig(value, globalValue) {
+    if (XEUtils.eqNull(value)) {
+        return globalValue;
+    }
+    return value;
+}
+export function getFuncText(content, args) {
+    if (XEUtils.eqNull(content)) {
+        return '';
+    }
+    const translate = getConfig().translate;
+    return `${translate ? translate('' + content, args) : content}`;
+}
+export function getText(content) {
+    if (XEUtils.eqNull(content)) {
+        return '';
+    }
+    return '' + content;
+}
+/**
+ * 判断值为：'' | null | undefined 时都属于空值
+ */
+export function eqEmptyValue(cellValue) {
+    return cellValue === null || cellValue === undefined || cellValue === '';
+}
+export function handleBooleanDefaultValue(value) {
+    return XEUtils.isBoolean(value) ? value : null;
+}
+export function enModelValue(nodeid) {
+    return XEUtils.eqNull(nodeid) ? '' : encodeURIComponent(`${nodeid}`);
+}
+export function deModelValue(nodeid) {
+    return nodeid ? decodeURIComponent(`${nodeid}`) : nodeid;
+}

package/es/ui/src/vn.js

@@ -0,0 +1,51 @@
+import XEUtils from 'xe-utils';
+export function getOnName(type) {
+    return XEUtils.kebabCase(type);
+}
+export function getModelEvent(renderOpts) {
+    switch (renderOpts.name) {
+        case 'VxeInput':
+        case 'VxeTextarea':
+        case 'VxeNumberInput':
+        case 'VxePasswordInput':
+        case 'VxeSelect':
+        case 'VxeTreeSelect':
+        case 'VxeTableSelect':
+        case 'VxeDatePicker':
+        case 'VxeDateRangePicker':
+        case 'VxeIconPicker':
+        case 'VxeColorPicker':
+        case 'VxeSlider':
+        case 'VxeUpload':
+            return 'modelValue';
+        case 'select':
+            return 'change';
+    }
+    return 'input';
+}
+export function getChangeEvent(renderOpts) {
+    switch (renderOpts.name) {
+        case 'input':
+        case 'textarea':
+        case 'VxeInput':
+        case 'VxeTextarea':
+        case '$input': // 已废弃
+        case '$textarea': // 已废弃
+            return 'input';
+    }
+    return 'change';
+}
+export function getSlotVNs(vns) {
+    if (XEUtils.isArray(vns)) {
+        return vns;
+    }
+    return vns ? [vns] : [];
+}
+export function getEventCaseName(_vm, name) {
+    const caseName = XEUtils.camelCase(name);
+    if (caseName === name) {
+        return name;
+    }
+    const _events = _vm ? _vm._events : null;
+    return _events && _events[caseName] ? caseName : name;
+}

package/es/upload/index.js

@@ -0,0 +1,15 @@
+import VxeUploadComponent from './src/upload';
+import { VxeUI } from '@vxe-ui/core';
+import { dynamicApp } from '../dynamics';
+import { saveLocalFile, readLocalFile } from './src/util';
+export const VxeUpload = Object.assign({}, VxeUploadComponent, {
+    install(app) {
+        app.component(VxeUploadComponent.name, VxeUploadComponent);
+    }
+});
+dynamicApp.use(VxeUpload);
+VxeUI.component(VxeUploadComponent);
+VxeUI.saveFile = saveLocalFile;
+VxeUI.readFile = readLocalFile;
+export const Upload = VxeUpload;
+export default VxeUpload;