@wangxinowo/vue-datepicker-next 1.0.0

package/src/components/_util/getTransitionProps.js

@@ -0,0 +1,34 @@
+import animate from './css-animation';
+const noop = () => {};
+const getTransitionProps = (transitionName, opt = {}) => {
+  const { beforeEnter, enter, afterEnter, leave, afterLeave, appear = true, tag, nativeOn } = opt;
+  const transitionProps = {
+    props: {
+      appear,
+      css: false,
+    },
+    on: {
+      beforeEnter: beforeEnter || noop,
+      enter:
+        enter ||
+        ((el, done) => {
+          animate(el, `${transitionName}-enter`, done);
+        }),
+      afterEnter: afterEnter || noop,
+      leave:
+        leave ||
+        ((el, done) => {
+          animate(el, `${transitionName}-leave`, done);
+        }),
+      afterLeave: afterLeave || noop,
+    },
+    nativeOn,
+  };
+  // transition-group
+  if (tag) {
+    transitionProps.tag = tag;
+  }
+  return transitionProps;
+};
+
+export default getTransitionProps;

package/src/components/_util/interopDefault.js

@@ -0,0 +1,4 @@
+// https://github.com/moment/moment/issues/3650
+export default function interopDefault(m) {
+  return m.default || m;
+}

package/src/components/_util/isCssAnimationSupported.js

@@ -0,0 +1,24 @@
+let animation;
+
+function isCssAnimationSupported() {
+  if (animation !== undefined) {
+    return animation;
+  }
+  const domPrefixes = 'Webkit Moz O ms Khtml'.split(' ');
+  const elm = document.createElement('div');
+  if (elm.style.animationName !== undefined) {
+    animation = true;
+  }
+  if (animation !== undefined) {
+    for (let i = 0; i < domPrefixes.length; i++) {
+      if (elm.style[`${domPrefixes[i]}AnimationName`] !== undefined) {
+        animation = true;
+        break;
+      }
+    }
+  }
+  animation = animation || false;
+  return animation;
+}
+
+export default isCssAnimationSupported;

package/src/components/_util/isFlexSupported.js

@@ -0,0 +1,12 @@
+export default function isFlexSupported() {
+  if (typeof window !== 'undefined' && window.document && window.document.documentElement) {
+    const { documentElement } = window.document;
+    return (
+      'flex' in documentElement.style ||
+      'webkitFlex' in documentElement.style ||
+      'Flex' in documentElement.style ||
+      'msFlex' in documentElement.style
+    );
+  }
+  return false;
+}

package/src/components/_util/isNumeric.js

@@ -0,0 +1,4 @@
+const isNumeric = value => {
+  return !isNaN(parseFloat(value)) && isFinite(value);
+};
+export default isNumeric;

package/src/components/_util/isValid.js

@@ -0,0 +1,4 @@
+const isValid = value => {
+  return value !== undefined && value !== null && value !== '';
+};
+export default isValid;

package/src/components/_util/moment-util.js

@@ -0,0 +1,75 @@
+import interopDefault from './interopDefault';
+import * as moment from 'moment';
+import warning from './warning';
+import isNil from 'lodash/isNil';
+
+export const TimeType = {
+  validator(value) {
+    return typeof value === 'string' || isNil(value) || moment.isMoment(value);
+  },
+};
+
+export const TimesType = {
+  validator(value) {
+    if (Array.isArray(value)) {
+      return (
+        value.length === 0 ||
+        value.findIndex(val => typeof val !== 'string') === -1 ||
+        value.findIndex(val => !isNil(val) && !moment.isMoment(val)) === -1
+      );
+    }
+    return false;
+  },
+};
+
+export const TimeOrTimesType = {
+  validator(value) {
+    if (Array.isArray(value)) {
+      return (
+        value.length === 0 ||
+        value.findIndex(val => typeof val !== 'string') === -1 ||
+        value.findIndex(val => !isNil(val) && !moment.isMoment(val)) === -1
+      );
+    } else {
+      return typeof value === 'string' || isNil(value) || moment.isMoment(value);
+    }
+  },
+};
+
+export function checkValidate(componentName, value, propName, valueFormat) {
+  const values = Array.isArray(value) ? value : [value];
+  values.forEach(val => {
+    if (!val) return;
+    valueFormat &&
+      warning(
+        interopDefault(moment)(val, valueFormat).isValid(),
+        componentName,
+        `When set \`valueFormat\`, \`${propName}\` should provides invalidate string time. `,
+      );
+    !valueFormat &&
+      warning(
+        interopDefault(moment).isMoment(val) && val.isValid(),
+        componentName,
+        `\`${propName}\` provides invalidate moment time. If you want to set empty value, use \`null\` instead.`,
+      );
+  });
+}
+export const stringToMoment = (value, valueFormat) => {
+  if (Array.isArray(value)) {
+    return value.map(val =>
+      typeof val === 'string' && val ? interopDefault(moment)(val, valueFormat) : val || null,
+    );
+  } else {
+    return typeof value === 'string' && value
+      ? interopDefault(moment)(value, valueFormat)
+      : value || null;
+  }
+};
+
+export const momentToString = (value, valueFormat) => {
+  if (Array.isArray(value)) {
+    return value.map(val => (interopDefault(moment).isMoment(val) ? val.format(valueFormat) : val));
+  } else {
+    return interopDefault(moment).isMoment(value) ? value.format(valueFormat) : value;
+  }
+};

package/src/components/_util/openAnimation.js

@@ -0,0 +1,67 @@
+import cssAnimation from './css-animation';
+import raf from 'raf';
+import Vue from 'vue';
+
+function animate(node, show, done) {
+  let height;
+  let requestAnimationFrameId;
+  let appearRequestAnimationFrameId;
+  return cssAnimation(node, 'ant-motion-collapse-legacy', {
+    start() {
+      if (appearRequestAnimationFrameId) {
+        raf.cancel(appearRequestAnimationFrameId);
+      }
+      if (!show) {
+        node.style.height = `${node.offsetHeight}px`;
+        node.style.opacity = '1';
+      } else {
+        height = node.offsetHeight;
+        // not get offsetHeight when appear
+        // set it into raf get correct offsetHeight
+        if (height === 0) {
+          appearRequestAnimationFrameId = raf(() => {
+            height = node.offsetHeight;
+            node.style.height = '0px';
+            node.style.opacity = '0';
+          });
+        } else {
+          node.style.height = '0px';
+          node.style.opacity = '0';
+        }
+      }
+    },
+    active() {
+      if (requestAnimationFrameId) {
+        raf.cancel(requestAnimationFrameId);
+      }
+      requestAnimationFrameId = raf(() => {
+        node.style.height = `${show ? height : 0}px`;
+        node.style.opacity = show ? '1' : '0';
+      });
+    },
+    end() {
+      if (appearRequestAnimationFrameId) {
+        raf.cancel(appearRequestAnimationFrameId);
+      }
+      if (requestAnimationFrameId) {
+        raf.cancel(requestAnimationFrameId);
+      }
+      node.style.height = '';
+      node.style.opacity = '';
+      done && done();
+    },
+  });
+}
+
+const animation = {
+  enter(node, done) {
+    Vue.nextTick(() => {
+      animate(node, true, done);
+    });
+  },
+  leave(node, done) {
+    return animate(node, false, done);
+  },
+};
+
+export default animation;

package/src/components/_util/portalDirective.js

@@ -0,0 +1,24 @@
+export function antPortal(Vue) {
+  return Vue.directive('ant-portal', {
+    inserted(el, binding) {
+      const { value } = binding;
+      const parentNode = typeof value === 'function' ? value(el) : value;
+      if (parentNode !== el.parentNode) {
+        parentNode.appendChild(el);
+      }
+    },
+    componentUpdated(el, binding) {
+      const { value } = binding;
+      const parentNode = typeof value === 'function' ? value(el) : value;
+      if (parentNode !== el.parentNode) {
+        parentNode.appendChild(el);
+      }
+    },
+  });
+}
+
+export default {
+  install: Vue => {
+    antPortal(Vue);
+  },
+};

package/src/components/_util/props-util.js

@@ -0,0 +1,335 @@
+import isPlainObject from 'lodash/isPlainObject';
+import classNames from 'classnames';
+function getType(fn) {
+  const match = fn && fn.toString().match(/^\s*function (\w+)/);
+  return match ? match[1] : '';
+}
+
+const camelizeRE = /-(\w)/g;
+const camelize = str => {
+  return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+};
+const parseStyleText = (cssText = '', camel) => {
+  const res = {};
+  const listDelimiter = /;(?![^(]*\))/g;
+  const propertyDelimiter = /:(.+)/;
+  cssText.split(listDelimiter).forEach(function(item) {
+    if (item) {
+      const tmp = item.split(propertyDelimiter);
+      if (tmp.length > 1) {
+        const k = camel ? camelize(tmp[0].trim()) : tmp[0].trim();
+        res[k] = tmp[1].trim();
+      }
+    }
+  });
+  return res;
+};
+
+const hasProp = (instance, prop) => {
+  const $options = instance.$options || {};
+  const propsData = $options.propsData || {};
+  return prop in propsData;
+};
+const slotHasProp = (slot, prop) => {
+  const $options = slot.componentOptions || {};
+  const propsData = $options.propsData || {};
+  return prop in propsData;
+};
+const filterProps = (props, propsData = {}) => {
+  const res = {};
+  Object.keys(props).forEach(k => {
+    if (k in propsData || props[k] !== undefined) {
+      res[k] = props[k];
+    }
+  });
+  return res;
+};
+
+const getScopedSlots = ele => {
+  return (ele.data && ele.data.scopedSlots) || {};
+};
+
+const getSlots = ele => {
+  let componentOptions = ele.componentOptions || {};
+  if (ele.$vnode) {
+    componentOptions = ele.$vnode.componentOptions || {};
+  }
+  const children = ele.children || componentOptions.children || [];
+  const slots = {};
+  children.forEach(child => {
+    if (!isEmptyElement(child)) {
+      const name = (child.data && child.data.slot) || 'default';
+      slots[name] = slots[name] || [];
+      slots[name].push(child);
+    }
+  });
+  return { ...slots, ...getScopedSlots(ele) };
+};
+const getSlot = (self, name = 'default', options = {}) => {
+  return (
+    (self.$scopedSlots && self.$scopedSlots[name] && self.$scopedSlots[name](options)) ||
+    self.$slots[name] ||
+    []
+  );
+};
+
+const getAllChildren = ele => {
+  let componentOptions = ele.componentOptions || {};
+  if (ele.$vnode) {
+    componentOptions = ele.$vnode.componentOptions || {};
+  }
+  return ele.children || componentOptions.children || [];
+};
+const getSlotOptions = ele => {
+  if (ele.fnOptions) {
+    // 函数式组件
+    return ele.fnOptions;
+  }
+  let componentOptions = ele.componentOptions;
+  if (ele.$vnode) {
+    componentOptions = ele.$vnode.componentOptions;
+  }
+  return componentOptions ? componentOptions.Ctor.options || {} : {};
+};
+const getOptionProps = instance => {
+  if (instance.componentOptions) {
+    const componentOptions = instance.componentOptions;
+    const { propsData = {}, Ctor = {} } = componentOptions;
+    const props = (Ctor.options || {}).props || {};
+    const res = {};
+    for (const [k, v] of Object.entries(props)) {
+      const def = v.default;
+      if (def !== undefined) {
+        res[k] =
+          typeof def === 'function' && getType(v.type) !== 'Function' ? def.call(instance) : def;
+      }
+    }
+    return { ...res, ...propsData };
+  }
+  const { $options = {}, $props = {} } = instance;
+  return filterProps($props, $options.propsData);
+};
+
+const getComponentFromProp = (instance, prop, options = instance, execute = true) => {
+  if (instance.$createElement) {
+    const h = instance.$createElement;
+    const temp = instance[prop];
+    if (temp !== undefined) {
+      return typeof temp === 'function' && execute ? temp(h, options) : temp;
+    }
+    return (
+      (instance.$scopedSlots[prop] && execute && instance.$scopedSlots[prop](options)) ||
+      instance.$scopedSlots[prop] ||
+      instance.$slots[prop] ||
+      undefined
+    );
+  } else {
+    const h = instance.context.$createElement;
+    const temp = getPropsData(instance)[prop];
+    if (temp !== undefined) {
+      return typeof temp === 'function' && execute ? temp(h, options) : temp;
+    }
+    const slotScope = getScopedSlots(instance)[prop];
+    if (slotScope !== undefined) {
+      return typeof slotScope === 'function' && execute ? slotScope(h, options) : slotScope;
+    }
+    const slotsProp = [];
+    const componentOptions = instance.componentOptions || {};
+    (componentOptions.children || []).forEach(child => {
+      if (child.data && child.data.slot === prop) {
+        if (child.data.attrs) {
+          delete child.data.attrs.slot;
+        }
+        if (child.tag === 'template') {
+          slotsProp.push(child.children);
+        } else {
+          slotsProp.push(child);
+        }
+      }
+    });
+    return slotsProp.length ? slotsProp : undefined;
+  }
+};
+
+const getAllProps = ele => {
+  let data = ele.data || {};
+  let componentOptions = ele.componentOptions || {};
+  if (ele.$vnode) {
+    data = ele.$vnode.data || {};
+    componentOptions = ele.$vnode.componentOptions || {};
+  }
+  return { ...data.props, ...data.attrs, ...componentOptions.propsData };
+};
+
+const getPropsData = ele => {
+  let componentOptions = ele.componentOptions;
+  if (ele.$vnode) {
+    componentOptions = ele.$vnode.componentOptions;
+  }
+  return componentOptions ? componentOptions.propsData || {} : {};
+};
+const getValueByProp = (ele, prop) => {
+  return getPropsData(ele)[prop];
+};
+
+const getAttrs = ele => {
+  let data = ele.data;
+  if (ele.$vnode) {
+    data = ele.$vnode.data;
+  }
+  return data ? data.attrs || {} : {};
+};
+
+const getKey = ele => {
+  let key = ele.key;
+  if (ele.$vnode) {
+    key = ele.$vnode.key;
+  }
+  return key;
+};
+
+export function getEvents(child) {
+  let events = {};
+  if (child.componentOptions && child.componentOptions.listeners) {
+    events = child.componentOptions.listeners;
+  } else if (child.data && child.data.on) {
+    events = child.data.on;
+  }
+  return { ...events };
+}
+
+// 获取 xxx.native 或者 原生标签 事件
+export function getDataEvents(child) {
+  let events = {};
+  if (child.data && child.data.on) {
+    events = child.data.on;
+  }
+  return { ...events };
+}
+
+// use getListeners instead this.$listeners
+// https://github.com/vueComponent/ant-design-vue/issues/1705
+export function getListeners(context) {
+  return (context.$vnode ? context.$vnode.componentOptions.listeners : context.$listeners) || {};
+}
+export function getClass(ele) {
+  let data = {};
+  if (ele.data) {
+    data = ele.data;
+  } else if (ele.$vnode && ele.$vnode.data) {
+    data = ele.$vnode.data;
+  }
+  const tempCls = data.class || {};
+  const staticClass = data.staticClass;
+  let cls = {};
+  staticClass &&
+    staticClass.split(' ').forEach(c => {
+      cls[c.trim()] = true;
+    });
+  if (typeof tempCls === 'string') {
+    tempCls.split(' ').forEach(c => {
+      cls[c.trim()] = true;
+    });
+  } else if (Array.isArray(tempCls)) {
+    classNames(tempCls)
+      .split(' ')
+      .forEach(c => {
+        cls[c.trim()] = true;
+      });
+  } else {
+    cls = { ...cls, ...tempCls };
+  }
+  return cls;
+}
+export function getStyle(ele, camel) {
+  let data = {};
+  if (ele.data) {
+    data = ele.data;
+  } else if (ele.$vnode && ele.$vnode.data) {
+    data = ele.$vnode.data;
+  }
+  let style = data.style || data.staticStyle;
+  if (typeof style === 'string') {
+    style = parseStyleText(style, camel);
+  } else if (camel && style) {
+    // 驼峰化
+    const res = {};
+    Object.keys(style).forEach(k => (res[camelize(k)] = style[k]));
+    return res;
+  }
+  return style;
+}
+
+export function getComponentName(opts) {
+  return opts && (opts.Ctor.options.name || opts.tag);
+}
+
+export function isEmptyElement(c) {
+  return !(c.tag || (c.text && c.text.trim() !== ''));
+}
+
+export function isStringElement(c) {
+  return !c.tag;
+}
+
+export function filterEmpty(children = []) {
+  return children.filter(c => !isEmptyElement(c));
+}
+const initDefaultProps = (propTypes, defaultProps) => {
+  Object.keys(defaultProps).forEach(k => {
+    if (propTypes[k]) {
+      propTypes[k].def && (propTypes[k] = propTypes[k].def(defaultProps[k]));
+    } else {
+      throw new Error(`not have ${k} prop`);
+    }
+  });
+  return propTypes;
+};
+
+export function mergeProps() {
+  const args = [].slice.call(arguments, 0);
+  const props = {};
+  args.forEach((p = {}) => {
+    for (const [k, v] of Object.entries(p)) {
+      props[k] = props[k] || {};
+      if (isPlainObject(v)) {
+        Object.assign(props[k], v);
+      } else {
+        props[k] = v;
+      }
+    }
+  });
+  return props;
+}
+
+function isValidElement(element) {
+  return (
+    element &&
+    typeof element === 'object' &&
+    'componentOptions' in element &&
+    'context' in element &&
+    element.tag !== undefined
+  ); // remove text node
+}
+
+export {
+  hasProp,
+  filterProps,
+  getOptionProps,
+  getComponentFromProp,
+  getSlotOptions,
+  slotHasProp,
+  getPropsData,
+  getKey,
+  getAttrs,
+  getValueByProp,
+  parseStyleText,
+  initDefaultProps,
+  isValidElement,
+  camelize,
+  getSlots,
+  getSlot,
+  getAllProps,
+  getAllChildren,
+};
+export default hasProp;

package/src/components/_util/proxyComponent.jsx

@@ -0,0 +1,58 @@
+import PropTypes from './vue-types';
+import { getOptionProps, getListeners } from './props-util';
+
+function getDisplayName(WrappedComponent) {
+  return WrappedComponent.name || 'Component';
+}
+export default function wrapWithConnect(WrappedComponent) {
+  const tempProps = WrappedComponent.props || {};
+  const methods = WrappedComponent.methods || {};
+  const props = {};
+  Object.keys(tempProps).forEach(k => {
+    props[k] = { ...tempProps[k], required: false };
+  });
+  WrappedComponent.props.__propsSymbol__ = PropTypes.any;
+  WrappedComponent.props.children = PropTypes.array.def([]);
+  const ProxyWrappedComponent = {
+    props,
+    model: WrappedComponent.model,
+    name: `Proxy_${getDisplayName(WrappedComponent)}`,
+    methods: {
+      getProxyWrappedInstance() {
+        return this.$refs.wrappedInstance;
+      },
+    },
+    render() {
+      const { $slots = {}, $scopedSlots } = this;
+      const props = getOptionProps(this);
+      const wrapProps = {
+        props: {
+          ...props,
+          __propsSymbol__: Symbol(),
+          componentWillReceiveProps: { ...props },
+          children: $slots.default || props.children || [],
+        },
+        on: getListeners(this),
+      };
+      if (Object.keys($scopedSlots).length) {
+        wrapProps.scopedSlots = $scopedSlots;
+      }
+      const slotsKey = Object.keys($slots);
+      return (
+        <WrappedComponent {...wrapProps} ref="wrappedInstance">
+          {slotsKey.length
+            ? slotsKey.map(name => {
+                return <template slot={name}>{$slots[name]}</template>;
+              })
+            : null}
+        </WrappedComponent>
+      );
+    },
+  };
+  Object.keys(methods).map(m => {
+    ProxyWrappedComponent.methods[m] = function() {
+      return this.getProxyWrappedInstance()[m](...arguments);
+    };
+  });
+  return ProxyWrappedComponent;
+}

package/src/components/_util/raf.js

@@ -0,0 +1,32 @@
+import raf from 'raf';
+
+let id = 0;
+const ids = {};
+
+// Support call raf with delay specified frame
+export default function wrapperRaf(callback, delayFrames = 1) {
+  const myId = id++;
+  let restFrames = delayFrames;
+
+  function internalCallback() {
+    restFrames -= 1;
+
+    if (restFrames <= 0) {
+      callback();
+      delete ids[myId];
+    } else {
+      ids[myId] = raf(internalCallback);
+    }
+  }
+
+  ids[myId] = raf(internalCallback);
+
+  return myId;
+}
+
+wrapperRaf.cancel = function(pid) {
+  if (pid === undefined) return;
+  raf.cancel(ids[pid]);
+  delete ids[pid];
+};
+wrapperRaf.ids = ids; // export this for test usage