@wangxinowo/vue-datepicker-next 1.0.0

package/src/components/_util/__tests__/easings.test.js

@@ -0,0 +1,13 @@
+import { easeInOutCubic } from '../easings';
+
+describe('Test easings', () => {
+  it('easeInOutCubic return value', () => {
+    const nums = [];
+    // eslint-disable-next-line no-plusplus
+    for (let index = 0; index < 5; index++) {
+      nums.push(easeInOutCubic(index, 1, 5, 4));
+    }
+
+    expect(nums).toEqual([1, 1.25, 3, 4.75, 5]);
+  });
+});

package/src/components/_util/__tests__/scrollTo.test.js

@@ -0,0 +1,56 @@
+import scrollTo from '../scrollTo';
+
+describe('Test ScrollTo function', () => {
+  let dateNowMock;
+
+  beforeAll(() => {
+    jest.useFakeTimers();
+  });
+
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+
+  beforeEach(() => {
+    dateNowMock = jest
+      .spyOn(Date, 'now')
+      .mockImplementationOnce(() => 0)
+      .mockImplementationOnce(() => 1000);
+  });
+
+  afterEach(() => {
+    dateNowMock.mockRestore();
+  });
+
+  it('test scrollTo', async () => {
+    const scrollToSpy = jest.spyOn(window, 'scrollTo').mockImplementation((x, y) => {
+      window.scrollY = y;
+      window.pageYOffset = y;
+    });
+
+    scrollTo(1000);
+
+    jest.runAllTimers();
+    expect(window.pageYOffset).toBe(1000);
+
+    scrollToSpy.mockRestore();
+  });
+
+  it('test callback - option', async () => {
+    const cbMock = jest.fn();
+    scrollTo(1000, {
+      callback: cbMock,
+    });
+    jest.runAllTimers();
+    expect(cbMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('test getContainer - option', async () => {
+    const div = document.createElement('div');
+    scrollTo(1000, {
+      getContainer: () => div,
+    });
+    jest.runAllTimers();
+    expect(div.scrollTop).toBe(1000);
+  });
+});

package/src/components/_util/antDirective.js

@@ -0,0 +1,13 @@
+import ref from 'vue-ref';
+import { antInput } from './antInputDirective';
+import { antDecorator } from './FormDecoratorDirective';
+import { antPortal } from './portalDirective';
+
+export default {
+  install: Vue => {
+    Vue.use(ref, { name: 'ant-ref' });
+    antInput(Vue);
+    antDecorator(Vue);
+    antPortal(Vue);
+  },
+};

package/src/components/_util/antInputDirective.js

@@ -0,0 +1,73 @@
+/**
+ * Not type checking this file because flow doesn't like attaching
+ * properties to Elements.
+ */
+
+export const inBrowser = typeof window !== 'undefined';
+export const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+export const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+function makeMap(str, expectsLowerCase) {
+  const map = Object.create(null);
+  const list = str.split(',');
+  for (let i = 0; i < list.length; i++) {
+    map[list[i]] = true;
+  }
+  return expectsLowerCase ? val => map[val.toLowerCase()] : val => map[val];
+}
+const isTextInputType = makeMap('text,number,password,search,email,tel,url');
+
+function onCompositionStart(e) {
+  e.target.composing = true;
+}
+
+function onCompositionEnd(e) {
+  // prevent triggering an input event for no reason
+  if (!e.target.composing) return;
+  e.target.composing = false;
+  trigger(e.target, 'input');
+}
+
+function trigger(el, type) {
+  const e = document.createEvent('HTMLEvents');
+  e.initEvent(type, true, true);
+  el.dispatchEvent(e);
+}
+
+/* istanbul ignore if */
+if (isIE9) {
+  // http://www.matts411.com/post/internet-explorer-9-oninput/
+  document.addEventListener('selectionchange', () => {
+    const el = document.activeElement;
+    if (el && el.vmodel) {
+      trigger(el, 'input');
+    }
+  });
+}
+
+export function antInput(Vue) {
+  return Vue.directive('ant-input', {
+    inserted(el, binding, vnode) {
+      if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
+        if (!binding.modifiers || !binding.modifiers.lazy) {
+          el.addEventListener('compositionstart', onCompositionStart);
+          el.addEventListener('compositionend', onCompositionEnd);
+          // Safari < 10.2 & UIWebView doesn't fire compositionend when
+          // switching focus before confirming composition choice
+          // this also fixes the issue where some browsers e.g. iOS Chrome
+          // fires "change" instead of "input" on autocomplete.
+          el.addEventListener('change', onCompositionEnd);
+          /* istanbul ignore if */
+          if (isIE9) {
+            el.vmodel = true;
+          }
+        }
+      }
+    },
+  });
+}
+
+export default {
+  install: Vue => {
+    antInput(Vue);
+  },
+};

package/src/components/_util/callMoment.js

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

package/src/components/_util/colors.js

@@ -0,0 +1,17 @@
+import { tuple } from './type';
+
+export const PresetColorTypes = tuple(
+  'pink',
+  'red',
+  'yellow',
+  'orange',
+  'cyan',
+  'green',
+  'blue',
+  'purple',
+  'geekblue',
+  'magenta',
+  'volcano',
+  'gold',
+  'lime',
+);

package/src/components/_util/createChainedFunction.js

@@ -0,0 +1,22 @@
+/**
+ * Safe chained function
+ *
+ * Will only create a new function if needed,
+ * otherwise will pass back existing functions or null.
+ *
+ * @returns {function|null}
+ */
+export default function createChainedFunction() {
+  const args = [].slice.call(arguments, 0);
+  if (args.length === 1) {
+    return args[0];
+  }
+
+  return function chainedFunction() {
+    for (let i = 0; i < args.length; i++) {
+      if (args[i] && args[i].apply) {
+        args[i].apply(this, arguments);
+      }
+    }
+  };
+}

package/src/components/_util/css-animation/Event.js

@@ -0,0 +1,130 @@
+const START_EVENT_NAME_MAP = {
+  transitionstart: {
+    transition: 'transitionstart',
+    WebkitTransition: 'webkitTransitionStart',
+    MozTransition: 'mozTransitionStart',
+    OTransition: 'oTransitionStart',
+    msTransition: 'MSTransitionStart',
+  },
+
+  animationstart: {
+    animation: 'animationstart',
+    WebkitAnimation: 'webkitAnimationStart',
+    MozAnimation: 'mozAnimationStart',
+    OAnimation: 'oAnimationStart',
+    msAnimation: 'MSAnimationStart',
+  },
+};
+
+const END_EVENT_NAME_MAP = {
+  transitionend: {
+    transition: 'transitionend',
+    WebkitTransition: 'webkitTransitionEnd',
+    MozTransition: 'mozTransitionEnd',
+    OTransition: 'oTransitionEnd',
+    msTransition: 'MSTransitionEnd',
+  },
+
+  animationend: {
+    animation: 'animationend',
+    WebkitAnimation: 'webkitAnimationEnd',
+    MozAnimation: 'mozAnimationEnd',
+    OAnimation: 'oAnimationEnd',
+    msAnimation: 'MSAnimationEnd',
+  },
+};
+
+const startEvents = [];
+const endEvents = [];
+
+function detectEvents() {
+  const testEl = document.createElement('div');
+  const style = testEl.style;
+
+  if (!('AnimationEvent' in window)) {
+    delete START_EVENT_NAME_MAP.animationstart.animation;
+    delete END_EVENT_NAME_MAP.animationend.animation;
+  }
+
+  if (!('TransitionEvent' in window)) {
+    delete START_EVENT_NAME_MAP.transitionstart.transition;
+    delete END_EVENT_NAME_MAP.transitionend.transition;
+  }
+
+  function process(EVENT_NAME_MAP, events) {
+    for (const baseEventName in EVENT_NAME_MAP) {
+      if (EVENT_NAME_MAP.hasOwnProperty(baseEventName)) {
+        const baseEvents = EVENT_NAME_MAP[baseEventName];
+        for (const styleName in baseEvents) {
+          if (styleName in style) {
+            events.push(baseEvents[styleName]);
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  process(START_EVENT_NAME_MAP, startEvents);
+  process(END_EVENT_NAME_MAP, endEvents);
+}
+
+if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+  detectEvents();
+}
+
+function addEventListener(node, eventName, eventListener) {
+  node.addEventListener(eventName, eventListener, false);
+}
+
+function removeEventListener(node, eventName, eventListener) {
+  node.removeEventListener(eventName, eventListener, false);
+}
+
+const TransitionEvents = {
+  // Start events
+  startEvents,
+
+  addStartEventListener(node, eventListener) {
+    if (startEvents.length === 0) {
+      window.setTimeout(eventListener, 0);
+      return;
+    }
+    startEvents.forEach(startEvent => {
+      addEventListener(node, startEvent, eventListener);
+    });
+  },
+
+  removeStartEventListener(node, eventListener) {
+    if (startEvents.length === 0) {
+      return;
+    }
+    startEvents.forEach(startEvent => {
+      removeEventListener(node, startEvent, eventListener);
+    });
+  },
+
+  // End events
+  endEvents,
+
+  addEndEventListener(node, eventListener) {
+    if (endEvents.length === 0) {
+      window.setTimeout(eventListener, 0);
+      return;
+    }
+    endEvents.forEach(endEvent => {
+      addEventListener(node, endEvent, eventListener);
+    });
+  },
+
+  removeEndEventListener(node, eventListener) {
+    if (endEvents.length === 0) {
+      return;
+    }
+    endEvents.forEach(endEvent => {
+      removeEventListener(node, endEvent, eventListener);
+    });
+  },
+};
+
+export default TransitionEvents;

package/src/components/_util/css-animation/index.js

@@ -0,0 +1,184 @@
+// https://github.com/yiminghe/css-animation 1.5.0
+
+import Event from './Event';
+import classes from 'component-classes';
+import { requestAnimationTimeout, cancelAnimationTimeout } from '../requestAnimationTimeout';
+
+const isCssAnimationSupported = Event.endEvents.length !== 0;
+const capitalPrefixes = [
+  'Webkit',
+  'Moz',
+  'O',
+  // ms is special .... !
+  'ms',
+];
+const prefixes = ['-webkit-', '-moz-', '-o-', 'ms-', ''];
+
+function getStyleProperty(node, name) {
+  // old ff need null, https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle
+  const style = window.getComputedStyle(node, null);
+  let ret = '';
+  for (let i = 0; i < prefixes.length; i++) {
+    ret = style.getPropertyValue(prefixes[i] + name);
+    if (ret) {
+      break;
+    }
+  }
+  return ret;
+}
+
+function fixBrowserByTimeout(node) {
+  if (isCssAnimationSupported) {
+    const transitionDelay = parseFloat(getStyleProperty(node, 'transition-delay')) || 0;
+    const transitionDuration = parseFloat(getStyleProperty(node, 'transition-duration')) || 0;
+    const animationDelay = parseFloat(getStyleProperty(node, 'animation-delay')) || 0;
+    const animationDuration = parseFloat(getStyleProperty(node, 'animation-duration')) || 0;
+    const time = Math.max(transitionDuration + transitionDelay, animationDuration + animationDelay);
+    // sometimes, browser bug
+    node.rcEndAnimTimeout = setTimeout(() => {
+      node.rcEndAnimTimeout = null;
+      if (node.rcEndListener) {
+        node.rcEndListener();
+      }
+    }, time * 1000 + 200);
+  }
+}
+
+function clearBrowserBugTimeout(node) {
+  if (node.rcEndAnimTimeout) {
+    clearTimeout(node.rcEndAnimTimeout);
+    node.rcEndAnimTimeout = null;
+  }
+}
+
+const cssAnimation = (node, transitionName, endCallback) => {
+  const nameIsObj = typeof transitionName === 'object';
+  const className = nameIsObj ? transitionName.name : transitionName;
+  const activeClassName = nameIsObj ? transitionName.active : `${transitionName}-active`;
+  let end = endCallback;
+  let start;
+  let active;
+  const nodeClasses = classes(node);
+
+  if (endCallback && Object.prototype.toString.call(endCallback) === '[object Object]') {
+    end = endCallback.end;
+    start = endCallback.start;
+    active = endCallback.active;
+  }
+
+  if (node.rcEndListener) {
+    node.rcEndListener();
+  }
+
+  node.rcEndListener = e => {
+    if (e && e.target !== node) {
+      return;
+    }
+
+    if (node.rcAnimTimeout) {
+      cancelAnimationTimeout(node.rcAnimTimeout);
+      node.rcAnimTimeout = null;
+    }
+
+    clearBrowserBugTimeout(node);
+
+    nodeClasses.remove(className);
+    nodeClasses.remove(activeClassName);
+
+    Event.removeEndEventListener(node, node.rcEndListener);
+    node.rcEndListener = null;
+
+    // Usually this optional end is used for informing an owner of
+    // a leave animation and telling it to remove the child.
+    if (end) {
+      end();
+    }
+  };
+
+  Event.addEndEventListener(node, node.rcEndListener);
+
+  if (start) {
+    start();
+  }
+  nodeClasses.add(className);
+
+  node.rcAnimTimeout = requestAnimationTimeout(() => {
+    node.rcAnimTimeout = null;
+
+    nodeClasses.add(className);
+    nodeClasses.add(activeClassName);
+
+    if (active) {
+      requestAnimationTimeout(active, 0);
+    }
+    fixBrowserByTimeout(node);
+    // 30ms for firefox
+  }, 30);
+
+  return {
+    stop() {
+      if (node.rcEndListener) {
+        node.rcEndListener();
+      }
+    },
+  };
+};
+
+cssAnimation.style = (node, style, callback) => {
+  if (node.rcEndListener) {
+    node.rcEndListener();
+  }
+
+  node.rcEndListener = e => {
+    if (e && e.target !== node) {
+      return;
+    }
+
+    if (node.rcAnimTimeout) {
+      cancelAnimationTimeout(node.rcAnimTimeout);
+      node.rcAnimTimeout = null;
+    }
+
+    clearBrowserBugTimeout(node);
+
+    Event.removeEndEventListener(node, node.rcEndListener);
+    node.rcEndListener = null;
+
+    // Usually this optional callback is used for informing an owner of
+    // a leave animation and telling it to remove the child.
+    if (callback) {
+      callback();
+    }
+  };
+
+  Event.addEndEventListener(node, node.rcEndListener);
+
+  node.rcAnimTimeout = requestAnimationTimeout(() => {
+    for (const s in style) {
+      if (style.hasOwnProperty(s)) {
+        node.style[s] = style[s];
+      }
+    }
+    node.rcAnimTimeout = null;
+    fixBrowserByTimeout(node);
+  }, 0);
+};
+
+cssAnimation.setTransition = (node, p, value) => {
+  let property = p;
+  let v = value;
+  if (value === undefined) {
+    v = property;
+    property = '';
+  }
+  property = property || '';
+  capitalPrefixes.forEach(prefix => {
+    node.style[`${prefix}Transition${property}`] = v;
+  });
+};
+
+cssAnimation.isCssAnimationSupported = isCssAnimationSupported;
+
+export { isCssAnimationSupported };
+
+export default cssAnimation;

package/src/components/_util/easings.js

@@ -0,0 +1,8 @@
+export function easeInOutCubic(t, b, c, d) {
+  const cc = c - b;
+  t /= d / 2;
+  if (t < 1) {
+    return (cc / 2) * t * t * t + b;
+  }
+  return (cc / 2) * ((t -= 2) * t * t + 2) + b;
+}

package/src/components/_util/env.js

@@ -0,0 +1,14 @@
+/* eslint-disable no-undef */
+// Browser environment sniffing
+export const inBrowser = typeof window !== 'undefined';
+export const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+export const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+export const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+export const isIE = UA && /msie|trident/.test(UA);
+export const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+export const isEdge = UA && UA.indexOf('edge/') > 0;
+export const isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+export const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+export const isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
+export const isPhantomJS = UA && /phantomjs/.test(UA);
+export const isFF = UA && UA.match(/firefox\/(\d+)/);

package/src/components/_util/getLocale.js

@@ -0,0 +1,30 @@
+export function getComponentLocale(props, context, componentName, getDefaultLocale) {
+  let locale = {};
+  if (context && context.antLocale && context.antLocale[componentName]) {
+    locale = context.antLocale[componentName];
+  } else {
+    const defaultLocale = getDefaultLocale();
+    // TODO: make default lang of antd be English
+    // https://github.com/ant-design/ant-design/issues/6334
+    locale = defaultLocale.default || defaultLocale;
+  }
+
+  const result = {
+    ...locale,
+    ...props.locale,
+  };
+  result.lang = {
+    ...locale.lang,
+    ...props.locale.lang,
+  };
+  return result;
+}
+
+export function getLocaleCode(context) {
+  const localeCode = context.antLocale && context.antLocale.locale;
+  // Had use LocaleProvide but didn't set locale
+  if (context.antLocale && context.antLocale.exist && !localeCode) {
+    return 'zh-cn';
+  }
+  return localeCode;
+}

package/src/components/_util/getRequestAnimationFrame.js

@@ -0,0 +1,46 @@
+const availablePrefixs = ['moz', 'ms', 'webkit'];
+
+function requestAnimationFramePolyfill() {
+  let lastTime = 0;
+  return function(callback) {
+    const currTime = new Date().getTime();
+    const timeToCall = Math.max(0, 16 - (currTime - lastTime));
+    const id = window.setTimeout(function() {
+      callback(currTime + timeToCall);
+    }, timeToCall);
+    lastTime = currTime + timeToCall;
+    return id;
+  };
+}
+
+export default function getRequestAnimationFrame() {
+  if (typeof window === 'undefined') {
+    return () => {};
+  }
+  if (window.requestAnimationFrame) {
+    // https://github.com/vuejs/vue/issues/4465
+    return window.requestAnimationFrame.bind(window);
+  }
+
+  const prefix = availablePrefixs.filter(key => `${key}RequestAnimationFrame` in window)[0];
+
+  return prefix ? window[`${prefix}RequestAnimationFrame`] : requestAnimationFramePolyfill();
+}
+
+export function cancelRequestAnimationFrame(id) {
+  if (typeof window === 'undefined') {
+    return null;
+  }
+  if (window.cancelAnimationFrame) {
+    return window.cancelAnimationFrame(id);
+  }
+  const prefix = availablePrefixs.filter(
+    key => `${key}CancelAnimationFrame` in window || `${key}CancelRequestAnimationFrame` in window,
+  )[0];
+
+  return prefix
+    ? (
+        window[`${prefix}CancelAnimationFrame`] || window[`${prefix}CancelRequestAnimationFrame`]
+      ).call(this, id)
+    : clearTimeout(id);
+}

package/src/components/_util/getScroll.js

@@ -0,0 +1,17 @@
+export default function getScroll(target, top) {
+  if (typeof window === 'undefined') {
+    return 0;
+  }
+
+  const prop = top ? 'pageYOffset' : 'pageXOffset';
+  const method = top ? 'scrollTop' : 'scrollLeft';
+  const isWindow = target === window;
+
+  let ret = isWindow ? target[prop] : target[method];
+  // ie6,7,8 standard mode
+  if (isWindow && typeof ret !== 'number') {
+    ret = window.document.documentElement[method];
+  }
+
+  return ret;
+}

package/src/components/_util/getScrollBarSize.js

@@ -0,0 +1,38 @@
+let cached;
+
+export default function getScrollBarSize(fresh) {
+  if (fresh || cached === undefined) {
+    const inner = document.createElement('div');
+    inner.style.width = '100%';
+    inner.style.height = '200px';
+
+    const outer = document.createElement('div');
+    const outerStyle = outer.style;
+
+    outerStyle.position = 'absolute';
+    outerStyle.top = 0;
+    outerStyle.left = 0;
+    outerStyle.pointerEvents = 'none';
+    outerStyle.visibility = 'hidden';
+    outerStyle.width = '200px';
+    outerStyle.height = '150px';
+    outerStyle.overflow = 'hidden';
+
+    outer.appendChild(inner);
+
+    document.body.appendChild(outer);
+
+    const widthContained = inner.offsetWidth;
+    outer.style.overflow = 'scroll';
+    let widthScroll = inner.offsetWidth;
+
+    if (widthContained === widthScroll) {
+      widthScroll = outer.clientWidth;
+    }
+
+    document.body.removeChild(outer);
+
+    cached = widthContained - widthScroll;
+  }
+  return cached;
+}