@wangxinowo/vue-datepicker-next 1.0.0

package/src/components/_util/requestAnimationTimeout.js

@@ -0,0 +1,23 @@
+import getRequestAnimationFrame, {
+  cancelRequestAnimationFrame as caf,
+} from './getRequestAnimationFrame';
+const raf = getRequestAnimationFrame();
+
+export const cancelAnimationTimeout = frame => caf(frame.id);
+
+export const requestAnimationTimeout = (callback, delay) => {
+  const start = Date.now();
+  function timeout() {
+    if (Date.now() - start >= delay) {
+      callback.call();
+    } else {
+      frame.id = raf(timeout);
+    }
+  }
+
+  const frame = {
+    id: raf(timeout),
+  };
+
+  return frame;
+};

package/src/components/_util/responsiveObserve.js

@@ -0,0 +1,94 @@
+// matchMedia polyfill for
+// https://github.com/WickyNilliams/enquire.js/issues/82
+let enquire;
+
+// TODO: Will be removed in antd 4.0 because we will no longer support ie9
+if (typeof window !== 'undefined') {
+  const matchMediaPolyfill = mediaQuery => {
+    return {
+      media: mediaQuery,
+      matches: false,
+      addListener() {},
+      removeListener() {},
+    };
+  };
+  // ref: https://github.com/ant-design/ant-design/issues/18774
+  if (!window.matchMedia) window.matchMedia = matchMediaPolyfill;
+  // eslint-disable-next-line global-require
+  enquire = require('enquire.js');
+}
+
+export const responsiveArray = ['xxl', 'xl', 'lg', 'md', 'sm', 'xs'];
+
+export const responsiveMap = {
+  xs: '(max-width: 575px)',
+  sm: '(min-width: 576px)',
+  md: '(min-width: 768px)',
+  lg: '(min-width: 992px)',
+  xl: '(min-width: 1200px)',
+  xxl: '(min-width: 1600px)',
+};
+
+let subscribers = [];
+let subUid = -1;
+let screens = {};
+
+const responsiveObserve = {
+  dispatch(pointMap) {
+    screens = pointMap;
+    if (subscribers.length < 1) {
+      return false;
+    }
+
+    subscribers.forEach(item => {
+      item.func(screens);
+    });
+
+    return true;
+  },
+  subscribe(func) {
+    if (subscribers.length === 0) {
+      this.register();
+    }
+    const token = (++subUid).toString();
+    subscribers.push({
+      token,
+      func,
+    });
+    func(screens);
+    return token;
+  },
+  unsubscribe(token) {
+    subscribers = subscribers.filter(item => item.token !== token);
+    if (subscribers.length === 0) {
+      this.unregister();
+    }
+  },
+  unregister() {
+    Object.keys(responsiveMap).map(screen => enquire.unregister(responsiveMap[screen]));
+  },
+  register() {
+    Object.keys(responsiveMap).map(screen =>
+      enquire.register(responsiveMap[screen], {
+        match: () => {
+          const pointMap = {
+            ...screens,
+            [screen]: true,
+          };
+          this.dispatch(pointMap);
+        },
+        unmatch: () => {
+          const pointMap = {
+            ...screens,
+            [screen]: false,
+          };
+          this.dispatch(pointMap);
+        },
+        // Keep a empty destroy to avoid triggering unmatch when unregister
+        destroy() {},
+      }),
+    );
+  },
+};
+
+export default responsiveObserve;

package/src/components/_util/scrollTo.js

@@ -0,0 +1,37 @@
+import raf from 'raf';
+import getScroll from './getScroll';
+import { easeInOutCubic } from './easings';
+
+// interface ScrollToOptions {
+//   /** Scroll container, default as window */
+//   getContainer?: () => HTMLElement | Window;
+//   /** Scroll end callback */
+//   callback?: () => any;
+//   /** Animation duration, default as 450 */
+//   duration?: number;
+// }
+
+export default function scrollTo(y, options = {}) {
+  const { getContainer = () => window, callback, duration = 450 } = options;
+
+  const container = getContainer();
+  const scrollTop = getScroll(container, true);
+  const startTime = Date.now();
+
+  const frameFunc = () => {
+    const timestamp = Date.now();
+    const time = timestamp - startTime;
+    const nextScrollTop = easeInOutCubic(time > duration ? duration : time, scrollTop, y, duration);
+    if (container === window) {
+      window.scrollTo(window.pageXOffset, nextScrollTop);
+    } else {
+      container.scrollTop = nextScrollTop;
+    }
+    if (time < duration) {
+      raf(frameFunc);
+    } else if (typeof callback === 'function') {
+      callback();
+    }
+  };
+  raf(frameFunc);
+}

package/src/components/_util/setStyle.js

@@ -0,0 +1,25 @@
+/**
+ * Easy to set element style, return previous style
+ * IE browser compatible(IE browser doesn't merge overflow style, need to set it separately)
+ * https://github.com/ant-design/ant-design/issues/19393
+ *
+ */
+function setStyle(style, options = {}) {
+  const { element = document.body } = options;
+  const oldStyle = {};
+
+  const styleKeys = Object.keys(style);
+
+  // IE browser compatible
+  styleKeys.forEach(key => {
+    oldStyle[key] = element.style[key];
+  });
+
+  styleKeys.forEach(key => {
+    element.style[key] = style[key];
+  });
+
+  return oldStyle;
+}
+
+export default setStyle;

package/src/components/_util/store/PropTypes.js

@@ -0,0 +1,7 @@
+import PropTypes from '../vue-types';
+
+export const storeShape = PropTypes.shape({
+  subscribe: PropTypes.func.isRequired,
+  setState: PropTypes.func.isRequired,
+  getState: PropTypes.func.isRequired,
+});

package/src/components/_util/store/Provider.jsx

@@ -0,0 +1,15 @@
+import { storeShape } from './PropTypes';
+export default {
+  name: 'StoreProvider',
+  props: {
+    store: storeShape.isRequired,
+  },
+  provide() {
+    return {
+      storeContext: this.$props,
+    };
+  },
+  render() {
+    return this.$slots.default[0];
+  },
+};

package/src/components/_util/store/connect.jsx

@@ -0,0 +1,106 @@
+import shallowEqual from 'shallowequal';
+import omit from 'omit.js';
+import { getOptionProps, getListeners } from '../props-util';
+import PropTypes from '../vue-types';
+import proxyComponent from '../proxyComponent';
+
+function getDisplayName(WrappedComponent) {
+  return WrappedComponent.name || 'Component';
+}
+
+const defaultMapStateToProps = () => ({});
+export default function connect(mapStateToProps) {
+  const shouldSubscribe = !!mapStateToProps;
+  const finalMapStateToProps = mapStateToProps || defaultMapStateToProps;
+  return function wrapWithConnect(WrappedComponent) {
+    const tempProps = omit(WrappedComponent.props || {}, ['store']);
+    const props = {
+      __propsSymbol__: PropTypes.any,
+    };
+    Object.keys(tempProps).forEach(k => {
+      props[k] = { ...tempProps[k], required: false };
+    });
+    const Connect = {
+      name: `Connect_${getDisplayName(WrappedComponent)}`,
+      props,
+      inject: {
+        storeContext: { default: () => ({}) },
+      },
+      data() {
+        this.store = this.storeContext.store;
+        this.preProps = omit(getOptionProps(this), ['__propsSymbol__']);
+        return {
+          subscribed: finalMapStateToProps(this.store.getState(), this.$props),
+        };
+      },
+      watch: {
+        __propsSymbol__() {
+          if (mapStateToProps && mapStateToProps.length === 2) {
+            this.subscribed = finalMapStateToProps(this.store.getState(), this.$props);
+          }
+        },
+      },
+      mounted() {
+        this.trySubscribe();
+      },
+
+      beforeDestroy() {
+        this.tryUnsubscribe();
+      },
+      methods: {
+        handleChange() {
+          if (!this.unsubscribe) {
+            return;
+          }
+          const props = omit(getOptionProps(this), ['__propsSymbol__']);
+          const nextSubscribed = finalMapStateToProps(this.store.getState(), props);
+          if (
+            !shallowEqual(this.preProps, props) ||
+            !shallowEqual(this.subscribed, nextSubscribed)
+          ) {
+            this.subscribed = nextSubscribed;
+          }
+        },
+
+        trySubscribe() {
+          if (shouldSubscribe) {
+            this.unsubscribe = this.store.subscribe(this.handleChange);
+            this.handleChange();
+          }
+        },
+
+        tryUnsubscribe() {
+          if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+          }
+        },
+        getWrappedInstance() {
+          return this.$refs.wrappedInstance;
+        },
+      },
+      render() {
+        const { $slots = {}, $scopedSlots, subscribed, store } = this;
+        const props = getOptionProps(this);
+        this.preProps = { ...omit(props, ['__propsSymbol__']) };
+        const wrapProps = {
+          props: {
+            ...props,
+            ...subscribed,
+            store,
+          },
+          on: getListeners(this),
+          scopedSlots: $scopedSlots,
+        };
+        return (
+          <WrappedComponent {...wrapProps} ref="wrappedInstance">
+            {Object.keys($slots).map(name => {
+              return <template slot={name}>{$slots[name]}</template>;
+            })}
+          </WrappedComponent>
+        );
+      },
+    };
+    return proxyComponent(Connect);
+  };
+}

package/src/components/_util/store/create.js

@@ -0,0 +1,30 @@
+export default function create(initialState) {
+  let state = initialState;
+  const listeners = [];
+
+  function setState(partial) {
+    state = { ...state, ...partial };
+    for (let i = 0; i < listeners.length; i++) {
+      listeners[i]();
+    }
+  }
+
+  function getState() {
+    return state;
+  }
+
+  function subscribe(listener) {
+    listeners.push(listener);
+
+    return function unsubscribe() {
+      const index = listeners.indexOf(listener);
+      listeners.splice(index, 1);
+    };
+  }
+
+  return {
+    setState,
+    getState,
+    subscribe,
+  };
+}

package/src/components/_util/store/index.js

@@ -0,0 +1,5 @@
+export { default as Provider } from './Provider';
+
+export { default as connect } from './connect';
+
+export { default as create } from './create';

package/src/components/_util/styleChecker.js

@@ -0,0 +1,13 @@
+const isStyleSupport = styleName => {
+  if (typeof window !== 'undefined' && window.document && window.document.documentElement) {
+    const styleNameList = Array.isArray(styleName) ? styleName : [styleName];
+    const { documentElement } = window.document;
+
+    return styleNameList.some(name => name in documentElement.style);
+  }
+  return false;
+};
+
+export const isFlexSupported = isStyleSupport(['flex', 'webkitFlex', 'Flex', 'msFlex']);
+
+export default isStyleSupport;

package/src/components/_util/switchScrollingEffect.js

@@ -0,0 +1,20 @@
+import getScrollBarSize from './getScrollBarSize';
+
+export default close => {
+  const bodyIsOverflowing =
+    document.body.scrollHeight > (window.innerHeight || document.documentElement.clientHeight) &&
+    window.innerWidth > document.body.offsetWidth;
+  if (!bodyIsOverflowing) {
+    return;
+  }
+  if (close) {
+    document.body.style.position = '';
+    document.body.style.width = '';
+    return;
+  }
+  const scrollBarSize = getScrollBarSize();
+  if (scrollBarSize) {
+    document.body.style.position = 'relative';
+    document.body.style.width = `calc(100% - ${scrollBarSize}px)`;
+  }
+};

package/src/components/_util/throttleByAnimationFrame.js

@@ -0,0 +1,45 @@
+import raf from 'raf';
+
+export default function throttleByAnimationFrame(fn) {
+  let requestId;
+
+  const later = args => () => {
+    requestId = null;
+    fn(...args);
+  };
+
+  const throttled = (...args) => {
+    if (requestId == null) {
+      requestId = raf(later(args));
+    }
+  };
+
+  throttled.cancel = () => raf.cancel(requestId);
+
+  return throttled;
+}
+
+export function throttleByAnimationFrameDecorator() {
+  return function(target, key, descriptor) {
+    const fn = descriptor.value;
+    let definingProperty = false;
+    return {
+      configurable: true,
+      get() {
+        if (definingProperty || this === target.prototype || this.hasOwnProperty(key)) {
+          return fn;
+        }
+
+        const boundFn = throttleByAnimationFrame(fn.bind(this));
+        definingProperty = true;
+        Object.defineProperty(this, key, {
+          value: boundFn,
+          configurable: true,
+          writable: true,
+        });
+        definingProperty = false;
+        return boundFn;
+      },
+    };
+  };
+}

package/src/components/_util/transButton.jsx

@@ -0,0 +1,81 @@
+/**
+ * Wrap of sub component which need use as Button capacity (like Icon component).
+ * This helps accessibility reader to tread as a interactive button to operation.
+ */
+import KeyCode from './KeyCode';
+import PropTypes from './vue-types';
+
+const inlineStyle = {
+  border: 0,
+  background: 'transparent',
+  padding: 0,
+  lineHeight: 'inherit',
+  display: 'inline-block',
+};
+
+const TransButton = {
+  props: {
+    noStyle: PropTypes.bool,
+  },
+
+  methods: {
+    onKeyDown(event) {
+      const { keyCode } = event;
+      if (keyCode === KeyCode.ENTER) {
+        event.preventDefault();
+      }
+    },
+
+    onKeyUp(event) {
+      const { keyCode } = event;
+      if (keyCode === KeyCode.ENTER) {
+        this.$emit('click', event);
+      }
+    },
+
+    setRef(btn) {
+      this.div = btn;
+    },
+
+    focus() {
+      if (this.div) {
+        this.div.focus();
+      }
+    },
+
+    blur() {
+      if (this.div) {
+        this.div.blur();
+      }
+    },
+  },
+
+  render() {
+    const { noStyle } = this.$props;
+
+    return (
+      <div
+        role="button"
+        tabIndex={0}
+        {...{
+          directives: [
+            {
+              name: 'ant-ref',
+              value: this.setRef,
+            },
+          ],
+          on: {
+            ...this.$listeners,
+            keydown: this.onKeyDown,
+            keyup: this.onKeyUp,
+          },
+        }}
+        style={{ ...(!noStyle ? inlineStyle : null) }}
+      >
+        {this.$slots.default}
+      </div>
+    );
+  },
+};
+
+export default TransButton;

package/src/components/_util/triggerEvent.js

@@ -0,0 +1,8 @@
+export default function triggerEvent(el, type) {
+  if ('createEvent' in document) {
+    // modern browsers, IE9+
+    const e = document.createEvent('HTMLEvents');
+    e.initEvent(type, false, true);
+    el.dispatchEvent(e);
+  }
+}

package/src/components/_util/type.js

@@ -0,0 +1,4 @@
+// https://stackoverflow.com/questions/46176165/ways-to-get-string-literal-type-of-array-values-without-enum-overhead
+export const tuple = (...args) => args;
+
+export const tupleNum = (...args) => args;

package/src/components/_util/vnode.js

@@ -0,0 +1,147 @@
+import { filterEmpty, parseStyleText } from './props-util';
+import classNames from 'classnames';
+
+export function cloneVNode(vnode, deep) {
+  const componentOptions = vnode.componentOptions;
+  const data = vnode.data;
+
+  let listeners = {};
+  if (componentOptions && componentOptions.listeners) {
+    listeners = { ...componentOptions.listeners };
+  }
+
+  let on = {};
+  if (data && data.on) {
+    on = { ...data.on };
+  }
+
+  const cloned = new vnode.constructor(
+    vnode.tag,
+    data ? { ...data, on } : data,
+    vnode.children,
+    vnode.text,
+    vnode.elm,
+    vnode.context,
+    componentOptions ? { ...componentOptions, listeners } : componentOptions,
+    vnode.asyncFactory,
+  );
+  cloned.ns = vnode.ns;
+  cloned.isStatic = vnode.isStatic;
+  cloned.key = vnode.key;
+  cloned.isComment = vnode.isComment;
+  cloned.fnContext = vnode.fnContext;
+  cloned.fnOptions = vnode.fnOptions;
+  cloned.fnScopeId = vnode.fnScopeId;
+  cloned.isCloned = true;
+  if (deep) {
+    if (vnode.children) {
+      cloned.children = cloneVNodes(vnode.children, true);
+    }
+    if (componentOptions && componentOptions.children) {
+      componentOptions.children = cloneVNodes(componentOptions.children, true);
+    }
+  }
+  return cloned;
+}
+
+export function cloneVNodes(vnodes, deep) {
+  const len = vnodes.length;
+  const res = new Array(len);
+  for (let i = 0; i < len; i++) {
+    res[i] = cloneVNode(vnodes[i], deep);
+  }
+  return res;
+}
+
+export function cloneElement(n, nodeProps = {}, deep) {
+  let ele = n;
+  if (Array.isArray(n)) {
+    ele = filterEmpty(n)[0];
+  }
+  if (!ele) {
+    return null;
+  }
+  const node = cloneVNode(ele, deep);
+  // // 函数式组件不支持clone  https://github.com/vueComponent/ant-design-vue/pull/1947
+  // warning(
+  //   !(node.fnOptions && node.fnOptions.functional),
+  //   `can not use cloneElement for functional component (${node.fnOptions && node.fnOptions.name})`,
+  // );
+  const { props = {}, key, on = {}, nativeOn = {}, children, directives = [] } = nodeProps;
+  const data = node.data || {};
+  let cls = {};
+  let style = {};
+  const {
+    attrs = {},
+    ref,
+    domProps = {},
+    style: tempStyle = {},
+    class: tempCls = {},
+    scopedSlots = {},
+  } = nodeProps;
+
+  if (typeof data.style === 'string') {
+    style = parseStyleText(data.style);
+  } else {
+    style = { ...data.style, ...style };
+  }
+  if (typeof tempStyle === 'string') {
+    style = { ...style, ...parseStyleText(style) };
+  } else {
+    style = { ...style, ...tempStyle };
+  }
+
+  if (typeof data.class === 'string' && data.class.trim() !== '') {
+    data.class.split(' ').forEach(c => {
+      cls[c.trim()] = true;
+    });
+  } else if (Array.isArray(data.class)) {
+    classNames(data.class)
+      .split(' ')
+      .forEach(c => {
+        cls[c.trim()] = true;
+      });
+  } else {
+    cls = { ...data.class, ...cls };
+  }
+  if (typeof tempCls === 'string' && tempCls.trim() !== '') {
+    tempCls.split(' ').forEach(c => {
+      cls[c.trim()] = true;
+    });
+  } else {
+    cls = { ...cls, ...tempCls };
+  }
+  node.data = Object.assign({}, data, {
+    style,
+    attrs: { ...data.attrs, ...attrs },
+    class: cls,
+    domProps: { ...data.domProps, ...domProps },
+    scopedSlots: { ...data.scopedSlots, ...scopedSlots },
+    directives: [...(data.directives || []), ...directives],
+  });
+
+  if (node.componentOptions) {
+    node.componentOptions.propsData = node.componentOptions.propsData || {};
+    node.componentOptions.listeners = node.componentOptions.listeners || {};
+    node.componentOptions.propsData = { ...node.componentOptions.propsData, ...props };
+    node.componentOptions.listeners = { ...node.componentOptions.listeners, ...on };
+    if (children) {
+      node.componentOptions.children = children;
+    }
+  } else {
+    if (children) {
+      node.children = children;
+    }
+    node.data.on = { ...(node.data.on || {}), ...on };
+  }
+  node.data.on = { ...(node.data.on || {}), ...nativeOn };
+
+  if (key !== undefined) {
+    node.key = key;
+    node.data.key = key;
+  }
+  if (typeof ref === 'string') {
+    node.data.ref = ref;
+  }
+  return node;
+}