@vxe-ui/core 0.0.1

package/es/src/event.js

@@ -0,0 +1,75 @@
+import XEUtils from 'xe-utils';
+export const EVENT_KEYS = {
+    F2: 'F2',
+    ESCAPE: 'Escape',
+    ENTER: 'Enter',
+    TAB: 'Tab',
+    DELETE: 'Delete',
+    BACKSPACE: 'Backspace',
+    SPACEBAR: ' ',
+    CONTEXT_MENU: 'ContextMenu',
+    ARROW_UP: 'ArrowUp',
+    ARROW_DOWN: 'ArrowDown',
+    ARROW_LEFT: 'ArrowLeft',
+    ARROW_RIGHT: 'ArrowRight',
+    PAGE_UP: 'PageUp',
+    PAGE_DOWN: 'PageDown'
+};
+const browse = XEUtils.browse();
+const convertEventKeys = {
+    ' ': 'Spacebar',
+    Apps: EVENT_KEYS.CONTEXT_MENU,
+    Del: EVENT_KEYS.DELETE,
+    Up: EVENT_KEYS.ARROW_UP,
+    Down: EVENT_KEYS.ARROW_DOWN,
+    Left: EVENT_KEYS.ARROW_LEFT,
+    Right: EVENT_KEYS.ARROW_RIGHT
+};
+// 监听全局事件
+const wheelName = browse.firefox ? 'DOMMouseScroll' : 'mousewheel';
+const eventStore = [];
+export const hasEventKey = (evnt, targetKey) => {
+    const { key } = evnt;
+    targetKey = targetKey.toLowerCase();
+    return key ? (targetKey === key.toLowerCase() || !!(convertEventKeys[key] && convertEventKeys[key].toLowerCase() === targetKey)) : false;
+};
+function triggerEvent(evnt) {
+    const isWheel = evnt.type === wheelName;
+    eventStore.forEach(({ type, cb }) => {
+        // 如果被取消冒泡，不再执行
+        if (!evnt.cancelBubble) {
+            if (type === evnt.type || (isWheel && type === 'mousewheel')) {
+                cb(evnt);
+            }
+        }
+    });
+}
+export const GlobalEvent = {
+    on(comp, type, cb) {
+        eventStore.push({ comp, type, cb });
+    },
+    off(comp, type) {
+        XEUtils.remove(eventStore, item => item.comp === comp && item.type === type);
+    },
+    trigger: triggerEvent,
+    eqKeypad(evnt, keyVal) {
+        const { key } = evnt;
+        if (keyVal.toLowerCase() === key.toLowerCase()) {
+            return true;
+        }
+        return false;
+    }
+};
+if (browse.isDoc) {
+    if (!browse.msie) {
+        window.addEventListener('copy', triggerEvent, false);
+        window.addEventListener('cut', triggerEvent, false);
+        window.addEventListener('paste', triggerEvent, false);
+    }
+    document.addEventListener('keydown', triggerEvent, false);
+    document.addEventListener('contextmenu', triggerEvent, false);
+    window.addEventListener('mousedown', triggerEvent, false);
+    window.addEventListener('blur', triggerEvent, false);
+    window.addEventListener('resize', triggerEvent, false);
+    window.addEventListener(wheelName, XEUtils.throttle(triggerEvent, 100, { leading: true, trailing: false }), { passive: true, capture: false });
+}

package/es/src/formats.js

@@ -0,0 +1,57 @@
+import XEUtils from 'xe-utils';
+import { warnLog } from './log';
+class VXEFormatsStore {
+    constructor() {
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    mixin(options) {
+        XEUtils.each(options, (item, key) => {
+            this.add(key, item);
+        });
+        return this;
+    }
+    has(name) {
+        return !!this.get(name);
+    }
+    get(name) {
+        return this.store[name];
+    }
+    add(name, render) {
+        const conf = this.store[name];
+        // 兼容
+        if (XEUtils.isFunction(render)) {
+            if (process.env.NODE_ENV === 'development') {
+                warnLog('vxe.error.delProp', ['formats -> callback', 'cellFormatMethod']);
+            }
+            render = {
+                cellFormatMethod: render
+            };
+        }
+        // 检测是否覆盖
+        if (process.env.NODE_ENV === 'development') {
+            const confKeys = XEUtils.keys(conf);
+            XEUtils.each(render, (item, key) => {
+                if (confKeys.includes(key)) {
+                    warnLog('vxe.error.coverProp', [name, key]);
+                }
+            });
+        }
+        this.store[name] = conf ? XEUtils.merge(conf, render) : render;
+        return this;
+    }
+    delete(name) {
+        delete this.store[name];
+    }
+    forEach(callback) {
+        XEUtils.objectEach(this.store, callback);
+    }
+}
+export const formats = new VXEFormatsStore();
+if (process.env.NODE_ENV === 'development') {
+    Object.assign(formats, { _name: 'Formats' });
+}

package/es/src/globalStore.js

@@ -0,0 +1,9 @@
+const globalConfigStore = {
+    size: '',
+    theme: '',
+    version: 1,
+    zIndex: 999,
+    resizeInterval: 500,
+    i18n: (key) => key
+};
+export default globalConfigStore;

package/es/src/hooks.js

@@ -0,0 +1,2 @@
+import VXEStore from './store';
+export const hooks = new VXEStore();

package/es/src/i18n.js

@@ -0,0 +1,7 @@
+import globalConfigStore from './globalStore';
+export function getI18n(key, args) {
+    if (globalConfigStore.i18n) {
+        return globalConfigStore.i18n(key, args);
+    }
+    return key;
+}

package/es/src/iconStore.js

@@ -0,0 +1,2 @@
+const iconConfigStore = {};
+export default iconConfigStore;

package/es/src/interceptor.js

@@ -0,0 +1,41 @@
+import XEUtils from 'xe-utils';
+import { warnLog } from './log';
+const storeMap = {};
+export const interceptor = {
+    mixin(options) {
+        XEUtils.each(options, (callback, type) => {
+            interceptor.add(type, callback);
+        });
+        return interceptor;
+    },
+    get(type) {
+        return storeMap[type] || [];
+    },
+    add(type, callback) {
+        if (callback) {
+            let eList = storeMap[type];
+            if (!eList) {
+                eList = storeMap[type] = [];
+            }
+            // 检测重复
+            if (process.env.NODE_ENV === 'development') {
+                if (eList.indexOf(callback) > -1) {
+                    warnLog('vxe.error.coverProp', ['Interceptor', type]);
+                }
+            }
+            eList.push(callback);
+        }
+        return interceptor;
+    },
+    delete(type, callback) {
+        const eList = storeMap[type];
+        if (eList) {
+            if (callback) {
+                XEUtils.remove(eList, fn => fn === callback);
+            }
+            else {
+                delete storeMap[type];
+            }
+        }
+    }
+};

package/es/src/log.js

@@ -0,0 +1,13 @@
+import { getI18n } from './i18n';
+export function getLog(message, params) {
+    return `[vxe-table v${"0.0.1"}] ${getI18n(message, params)}`;
+}
+function outLog(type) {
+    return function (message, params) {
+        const msg = getLog(message, params);
+        console[type](msg);
+        return msg;
+    };
+}
+export const warnLog = outLog('warn');
+export const errLog = outLog('error');

package/es/src/menus.js

@@ -0,0 +1,57 @@
+import XEUtils from 'xe-utils';
+import { warnLog } from './log';
+class VXEMenusStore {
+    constructor() {
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    mixin(options) {
+        XEUtils.each(options, (item, key) => {
+            this.add(key, item);
+        });
+        return this;
+    }
+    has(name) {
+        return !!this.get(name);
+    }
+    get(name) {
+        return this.store[name];
+    }
+    add(name, render) {
+        const conf = this.store[name];
+        // 兼容
+        if (XEUtils.isFunction(render)) {
+            if (process.env.NODE_ENV === 'development') {
+                warnLog('vxe.error.delProp', ['menus -> callback', 'menuMethod']);
+            }
+            render = {
+                menuMethod: render
+            };
+        }
+        // 检测是否覆盖
+        if (process.env.NODE_ENV === 'development') {
+            const confKeys = XEUtils.keys(conf);
+            XEUtils.each(render, (item, key) => {
+                if (confKeys.includes(key)) {
+                    warnLog('vxe.error.coverProp', [name, key]);
+                }
+            });
+        }
+        this.store[name] = conf ? XEUtils.merge(conf, render) : render;
+        return this;
+    }
+    delete(name) {
+        delete this.store[name];
+    }
+    forEach(callback) {
+        XEUtils.objectEach(this.store, callback);
+    }
+}
+export const menus = new VXEMenusStore();
+if (process.env.NODE_ENV === 'development') {
+    Object.assign(menus, { _name: 'Menus' });
+}

package/es/src/renderer.js

@@ -0,0 +1,46 @@
+import XEUtils from 'xe-utils';
+import { warnLog } from './log';
+/**
+ * 内置的组件渲染
+ */
+const renderMap = {};
+/**
+ * 全局渲染器
+ */
+export const renderer = {
+    mixin(opts) {
+        XEUtils.each(opts, (options, name) => renderer.add(name, options));
+        return renderer;
+    },
+    get(name) {
+        return renderMap[name] || null;
+    },
+    add(name, options) {
+        if (name && options) {
+            const renders = renderMap[name];
+            if (renders) {
+                // 检测是否覆盖
+                if (process.env.NODE_ENV === 'development') {
+                    XEUtils.each(options, (val, key) => {
+                        if (!XEUtils.eqNull(renders[key]) && renders[key] !== val) {
+                            warnLog('vxe.error.coverProp', [`Renderer.${name}`, key]);
+                        }
+                    });
+                }
+                Object.assign(renders, options);
+            }
+            else {
+                renderMap[name] = options;
+            }
+        }
+        return renderer;
+    },
+    forEach(callback) {
+        XEUtils.objectEach(renderMap, callback);
+        return renderer;
+    },
+    delete(name) {
+        delete renderMap[name];
+        return renderer;
+    }
+};

package/es/src/resize.js

@@ -0,0 +1,81 @@
+import XEUtils from 'xe-utils';
+import globalConfigStore from './globalStore';
+/**
+ * 监听 resize 事件
+ * 如果项目中已使用了 resize-observer-polyfill，那么只需要将方法定义全局，该组件就会自动使用
+ */
+let resizeTimeout;
+/* eslint-disable no-use-before-define */
+const eventStore = [];
+const defaultInterval = 500;
+function eventHandle() {
+    if (eventStore.length) {
+        eventStore.forEach((item) => {
+            item.tarList.forEach((observer) => {
+                const { target, width, heighe } = observer;
+                const clientWidth = target.clientWidth;
+                const clientHeight = target.clientHeight;
+                const rWidth = clientWidth && width !== clientWidth;
+                const rHeight = clientHeight && heighe !== clientHeight;
+                if (rWidth || rHeight) {
+                    observer.width = clientWidth;
+                    observer.heighe = clientHeight;
+                    setTimeout(item.callback);
+                }
+            });
+        });
+        /* eslint-disable @typescript-eslint/no-use-before-define */
+        eventListener();
+    }
+}
+function eventListener() {
+    clearTimeout(resizeTimeout);
+    resizeTimeout = setTimeout(eventHandle, globalConfigStore.resizeInterval || defaultInterval);
+}
+export class XEResizeObserver {
+    constructor(callback) {
+        Object.defineProperty(this, "tarList", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "callback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.callback = callback;
+    }
+    observe(target) {
+        if (target) {
+            const { tarList } = this;
+            if (!tarList.some(observer => observer.target === target)) {
+                tarList.push({
+                    target,
+                    width: target.clientWidth,
+                    heighe: target.clientHeight
+                });
+            }
+            if (!eventStore.length) {
+                eventListener();
+            }
+            if (!eventStore.some((item) => item === this)) {
+                eventStore.push(this);
+            }
+        }
+    }
+    unobserve(target) {
+        XEUtils.remove(eventStore, item => item.tarList.some(observer => observer.target === target));
+    }
+    disconnect() {
+        XEUtils.remove(eventStore, item => item === this);
+    }
+}
+export function createResizeEvent(callback) {
+    if (window.ResizeObserver) {
+        return new window.ResizeObserver(callback);
+    }
+    return new XEResizeObserver(callback);
+}

package/es/src/store.js

@@ -0,0 +1,48 @@
+import { warnLog } from './log';
+import XEUtils from 'xe-utils';
+/**
+ * 创建数据仓库
+ */
+export class Store {
+    constructor() {
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    mixin(options) {
+        XEUtils.each(options, (item, key) => {
+            this.add(key, item);
+        });
+        return this;
+    }
+    has(name) {
+        return !!this.get(name);
+    }
+    get(name) {
+        return this.store[name];
+    }
+    add(name, options) {
+        const conf = this.store[name];
+        // 检测是否覆盖
+        if (process.env.NODE_ENV === 'development') {
+            const confKeys = XEUtils.keys(conf);
+            XEUtils.each(options, (item, key) => {
+                if (confKeys.includes(key)) {
+                    warnLog('vxe.error.coverProp', [name, key]);
+                }
+            });
+        }
+        this.store[name] = conf ? XEUtils.merge(conf, options) : options;
+        return this;
+    }
+    delete(name) {
+        delete this.store[name];
+    }
+    forEach(callback) {
+        XEUtils.objectEach(this.store, callback);
+    }
+}
+export default Store;

package/es/src/theme.js

@@ -0,0 +1,10 @@
+import globalConfigStore from './globalStore';
+export default function setTheme(options) {
+    const theme = (options ? options.theme : null) || globalConfigStore.theme || 'default';
+    if (typeof document !== 'undefined') {
+        const documentElement = document.documentElement;
+        if (documentElement) {
+            documentElement.setAttribute('data-vxe-theme', theme);
+        }
+    }
+}

package/es/src/validators.js

@@ -0,0 +1,5 @@
+import VXEStore from './store';
+export const validators = new VXEStore();
+if (process.env.NODE_ENV === 'development') {
+    Object.assign(validators, { _name: 'Validators' });
+}

package/lib/index.common.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+exports.default = void 0;
+var _core = _interopRequireWildcard(require("./src/core"));
+Object.keys(_core).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _core[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _core[key];
+    }
+  });
+});
+var _xeUtils = _interopRequireDefault(require("xe-utils"));
+var _zhCN = _interopRequireDefault(require("./language/zh-CN"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+// 默认中文
+(0, _core.setConfig)({
+  i18n: (key, args) => _xeUtils.default.toFormatString(_xeUtils.default.get(_zhCN.default, key), args)
+});
+var _default = exports.default = _core.default;