@vxe-ui/core 0.0.1

package/packages/src/event.ts

@@ -0,0 +1,89 @@
+import XEUtils from 'xe-utils'
+
+import { VxeComponentBase } from '../../types'
+
+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: { [key: string]: string } = {
+  ' ': '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: {
+  comp: VxeComponentBase;
+  type: string;
+  cb: (evnt: Event) => void;
+}[] = []
+
+export const hasEventKey = (evnt: KeyboardEvent, targetKey: string) => {
+  const { key } = evnt
+  targetKey = targetKey.toLowerCase()
+  return key ? (targetKey === key.toLowerCase() || !!(convertEventKeys[key] && convertEventKeys[key].toLowerCase() === targetKey)) : false
+}
+
+function triggerEvent (evnt: Event) {
+  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: VxeComponentBase, type: string, cb: (evnt: any) => void) {
+    eventStore.push({ comp, type, cb })
+  },
+  off (comp: VxeComponentBase, type: string) {
+    XEUtils.remove(eventStore, item => item.comp === comp && item.type === type)
+  },
+  trigger: triggerEvent,
+  eqKeypad (evnt: KeyboardEvent, keyVal: string) {
+    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/packages/src/formats.ts

@@ -0,0 +1,62 @@
+import XEUtils from 'xe-utils'
+import { warnLog } from './log'
+
+import { VxeGlobalFormats } from '../../types'
+
+class VXEFormatsStore {
+  private store: any = {}
+
+  mixin (options: any): VXEFormatsStore {
+    XEUtils.each(options, (item, key) => {
+      this.add(key, item)
+    })
+    return this
+  }
+
+  has (name: string): boolean {
+    return !!this.get(name)
+  }
+
+  get (name: string): any {
+    return this.store[name]
+  }
+
+  add (name: string, render: any): VXEFormatsStore {
+    const conf = this.store[name]
+    // 兼容
+    if (XEUtils.isFunction(render)) {
+      if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
+        warnLog('vxe.error.delProp', ['formats -> callback', 'cellFormatMethod'])
+      }
+      render = {
+        cellFormatMethod: render
+      }
+    }
+
+    // 检测是否覆盖
+    if (process.env.VUE_APP_VXE_TABLE_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: string): void {
+    delete this.store[name]
+  }
+
+  forEach (callback: any): void {
+    XEUtils.objectEach(this.store, callback)
+  }
+}
+
+export const formats = new VXEFormatsStore() as VxeGlobalFormats
+
+if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
+  Object.assign(formats, { _name: 'Formats' })
+}

package/packages/src/globalStore.ts

@@ -0,0 +1,13 @@
+import { VxeGlobalConfig } from '../../types'
+
+const globalConfigStore: Required<VxeGlobalConfig> = {
+  size: '',
+  theme: '',
+  version: 1,
+  zIndex: 999,
+  resizeInterval: 500,
+
+  i18n: (key: string) => key
+}
+
+export default globalConfigStore

package/packages/src/hooks.ts

@@ -0,0 +1,5 @@
+import VXEStore from './store'
+
+import { VxeGlobalHooks } from '../../types'
+
+export const hooks = new VXEStore() as VxeGlobalHooks

package/packages/src/i18n.ts

@@ -0,0 +1,8 @@
+import globalConfigStore from './globalStore'
+
+export function getI18n (key: string, args?: any) {
+  if (globalConfigStore.i18n) {
+    return globalConfigStore.i18n(key, args)
+  }
+  return key
+}

package/packages/src/iconStore.ts

@@ -0,0 +1,5 @@
+import { VxeGlobalIcon } from '../../types'
+
+const iconConfigStore: VxeGlobalIcon = {}
+
+export default iconConfigStore

package/packages/src/interceptor.ts

@@ -0,0 +1,46 @@
+import XEUtils from 'xe-utils'
+import { warnLog } from './log'
+
+import { VxeGlobalInterceptor, VxeGlobalInterceptorHandles } from '../../types'
+
+const storeMap: { [type: string]: VxeGlobalInterceptorHandles.InterceptorCallback[] } = {}
+
+export const interceptor: VxeGlobalInterceptor = {
+  mixin (options) {
+    XEUtils.each(options, (callback: VxeGlobalInterceptorHandles.InterceptorCallback, 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.VUE_APP_VXE_TABLE_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/packages/src/log.ts

@@ -0,0 +1,16 @@
+import { getI18n } from './i18n'
+
+export function getLog (message: string, params?: any) {
+  return `[vxe-table v${process.env.VUE_APP_VXE_TABLE_VERSION}] ${getI18n(message, params)}`
+}
+
+function outLog (type: 'log' | 'warn' | 'error') {
+  return function (message: string, params?: any) {
+    const msg = getLog(message, params)
+    console[type](msg)
+    return msg
+  }
+}
+
+export const warnLog = outLog('warn')
+export const errLog = outLog('error')

package/packages/src/menus.ts

@@ -0,0 +1,62 @@
+import XEUtils from 'xe-utils'
+import { warnLog } from './log'
+
+import { VxeGlobalMenus } from '../../types'
+
+class VXEMenusStore {
+  private store: any = {}
+
+  mixin (options: any): VXEMenusStore {
+    XEUtils.each(options, (item, key) => {
+      this.add(key, item)
+    })
+    return this
+  }
+
+  has (name: string): boolean {
+    return !!this.get(name)
+  }
+
+  get (name: string): any {
+    return this.store[name]
+  }
+
+  add (name: string, render: any): VXEMenusStore {
+    const conf = this.store[name]
+    // 兼容
+    if (XEUtils.isFunction(render)) {
+      if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
+        warnLog('vxe.error.delProp', ['menus -> callback', 'menuMethod'])
+      }
+      render = {
+        menuMethod: render
+      }
+    }
+
+    // 检测是否覆盖
+    if (process.env.VUE_APP_VXE_TABLE_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: string): void {
+    delete this.store[name]
+  }
+
+  forEach (callback: any): void {
+    XEUtils.objectEach(this.store, callback)
+  }
+}
+
+export const menus = new VXEMenusStore() as VxeGlobalMenus
+
+if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
+  Object.assign(menus, { _name: 'Menus' })
+}

package/packages/src/renderer.ts

@@ -0,0 +1,50 @@
+import XEUtils from 'xe-utils'
+import { warnLog } from './log'
+
+import { VxeGlobalRenderer, RendererOptions } from '../../types'
+
+/**
+ * 内置的组件渲染
+ */
+const renderMap: Record<string, RendererOptions> = {}
+
+/**
+ * 全局渲染器
+ */
+export const renderer: VxeGlobalRenderer = {
+  mixin (opts) {
+    XEUtils.each(opts, (options, name) => renderer.add(name, options))
+    return renderer
+  },
+  get (name: string) {
+    return renderMap[name] || null
+  },
+  add (name, options) {
+    if (name && options) {
+      const renders: any = renderMap[name]
+      if (renders) {
+        // 检测是否覆盖
+        if (process.env.VUE_APP_VXE_TABLE_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/packages/src/resize.ts

@@ -0,0 +1,85 @@
+import XEUtils from 'xe-utils'
+import globalConfigStore from './globalStore'
+
+/**
+ * 监听 resize 事件
+ * 如果项目中已使用了 resize-observer-polyfill，那么只需要将方法定义全局，该组件就会自动使用
+ */
+let resizeTimeout: any
+/* eslint-disable no-use-before-define */
+const eventStore: XEResizeObserver[] = []
+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 {
+  tarList: {
+    target: Element;
+    width: number;
+    heighe: number;
+  }[] = []
+
+  callback: (...args: any[]) => void
+
+  constructor (callback: (...args: any[]) => void) {
+    this.callback = callback
+  }
+
+  observe (target: Element): void {
+    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: Element): void {
+    XEUtils.remove(eventStore, item => item.tarList.some(observer => observer.target === target))
+  }
+
+  disconnect (): void {
+    XEUtils.remove(eventStore, item => item === this)
+  }
+}
+
+export function createResizeEvent (callback: (...args: any[]) => void): any {
+  if (window.ResizeObserver) {
+    return new window.ResizeObserver(callback)
+  }
+  return new XEResizeObserver(callback)
+}

package/packages/src/store.ts

@@ -0,0 +1,49 @@
+import { warnLog } from './log'
+import XEUtils from 'xe-utils'
+
+/**
+ * 创建数据仓库
+ */
+export class Store {
+  private store: any = {}
+
+  mixin (options: any): Store {
+    XEUtils.each(options, (item, key) => {
+      this.add(key, item)
+    })
+    return this
+  }
+
+  has (name: string): boolean {
+    return !!this.get(name)
+  }
+
+  get (name: string): any {
+    return this.store[name]
+  }
+
+  add (name: string, options: any): Store {
+    const conf = this.store[name]
+    // 检测是否覆盖
+    if (process.env.VUE_APP_VXE_TABLE_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: string): void {
+    delete this.store[name]
+  }
+
+  forEach (callback: any): void {
+    XEUtils.objectEach(this.store, callback)
+  }
+}
+
+export default Store

package/packages/src/theme.ts

@@ -0,0 +1,13 @@
+import globalConfigStore from './globalStore'
+
+import { VxeGlobalConfig } from '../../types'
+
+export default function setTheme (options?: VxeGlobalConfig) {
+  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/packages/src/validators.ts

@@ -0,0 +1,9 @@
+import VXEStore from './store'
+
+import { VxeGlobalValidators } from '../../types'
+
+export const validators = new VXEStore() as VxeGlobalValidators
+
+if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
+  Object.assign(validators, { _name: 'Validators' })
+}

package/types/core/clipboard.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 全局剪贴板
+ */
+export interface VxeGlobalClipboard {
+  copy(content: string | number): boolean
+}

package/types/core/commands.d.ts

@@ -0,0 +1,25 @@
+/* eslint-disable no-use-before-define */
+
+export namespace VxeGlobalCommandsHandles {
+  export interface CommandsOptions {
+    commandMethod?: (params: CommandMethodParams, ...args: any[]) => void
+  }
+  export interface CommandMethodParams {
+    code: string
+    button?: any
+  }
+}
+
+/**
+ * 全局格式化
+ */
+export interface VxeGlobalCommands {
+  mixin(opts: {
+    [name: string]: VxeGlobalCommandsHandles.CommandsOptions | ((params: VxeGlobalCommandsHandles.CommandMethodParams, ...args: any[]) => void)
+  }): VxeGlobalCommands
+  has(name: string): boolean
+  get(name: string): VxeGlobalCommandsHandles.CommandsOptions
+  add(name: string, options: VxeGlobalCommandsHandles.CommandsOptions | ((params: VxeGlobalCommandsHandles.CommandMethodParams, ...args: any[]) => void)): VxeGlobalCommands
+  delete(name: string): void
+  forEach(callback: (options: VxeGlobalCommandsHandles.CommandsOptions, name: string) => void): void
+}

package/types/core/formats.d.ts

@@ -0,0 +1,23 @@
+/* eslint-disable no-use-before-define */
+
+export namespace VxeGlobalFormatsHandles {
+  export interface FormatsOptions {
+    cellFormatMethod?: (params: FormatMethodParams, ...args: any[]) => string | number
+  }
+  export interface FormatMethodParams {
+  }
+}
+
+/**
+ * 全局格式化
+ */
+export interface VxeGlobalFormats {
+  mixin(opts: {
+    [name: string]: VxeGlobalFormatsHandles.FormatsOptions | ((params: VxeGlobalFormatsHandles.FormatMethodParams, ...args: any[]) => string | number)
+  }): VxeGlobalFormats
+  has(name: string): boolean
+  get(name: string): VxeGlobalFormatsHandles.FormatsOptions
+  add(name: string, options: VxeGlobalFormatsHandles.FormatsOptions | ((params: VxeGlobalFormatsHandles.FormatMethodParams, ...args: any[]) => string | number)): VxeGlobalFormats
+  delete(name: string): void
+  forEach(callback: (options: VxeGlobalFormatsHandles.FormatsOptions, name: string) => void): void
+}

package/types/core/global-config.d.ts

@@ -0,0 +1,14 @@
+import { VxeComponentSize } from '../tool'
+
+/**
+ * 全局参数对象
+ */
+export interface VxeGlobalConfig {
+  zIndex?: number
+  size?: VxeComponentSize
+  version?: string | number
+  theme?: null | '' | 'default' | 'dark'
+  resizeInterval?: number
+
+  i18n?(key: string, args?: any): string
+}

package/types/core/global-icon.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 全局图标参数
+ */
+export interface VxeGlobalIcon {}

package/types/core/hooks.d.ts

@@ -0,0 +1,14 @@
+export namespace VxeGlobalHooksHandles {
+  export interface HookOptions {}
+}
+
+export interface VxeGlobalHooks {
+  mixin(options: {
+    [type: string]: VxeGlobalHooksHandles.HookOptions
+  }): VxeGlobalHooks
+  has(type: string): boolean
+  get(type: string): VxeGlobalHooksHandles.HookOptions
+  add(type: string, options: VxeGlobalHooksHandles.HookOptions): VxeGlobalHooks
+  delete(type: string): void
+  forEach(callback: (options: VxeGlobalHooksHandles.HookOptions, type: string) => void): void
+}