@wangxinowo/vue-datepicker-next 1.0.0

package/src/components/_util/vue-types/index.js

@@ -0,0 +1,263 @@
+import isPlainObject from 'lodash/isPlainObject';
+import { toType, getType, isFunction, validateType, isInteger, isArray, warn } from './utils';
+
+const VuePropTypes = {
+  get any() {
+    return toType('any', {
+      type: null,
+    });
+  },
+
+  get func() {
+    return toType('function', {
+      type: Function,
+    }).def(currentDefaults.func);
+  },
+
+  get bool() {
+    return toType('boolean', {
+      type: Boolean,
+    }).def(currentDefaults.bool);
+  },
+
+  get string() {
+    return toType('string', {
+      type: String,
+    }).def(currentDefaults.string);
+  },
+
+  get number() {
+    return toType('number', {
+      type: Number,
+    }).def(currentDefaults.number);
+  },
+
+  get array() {
+    return toType('array', {
+      type: Array,
+    }).def(currentDefaults.array);
+  },
+
+  get object() {
+    return toType('object', {
+      type: Object,
+    }).def(currentDefaults.object);
+  },
+
+  get integer() {
+    return toType('integer', {
+      type: Number,
+      validator(value) {
+        return isInteger(value);
+      },
+    }).def(currentDefaults.integer);
+  },
+
+  get symbol() {
+    return toType('symbol', {
+      type: null,
+      validator(value) {
+        return typeof value === 'symbol';
+      },
+    });
+  },
+
+  custom(validatorFn, warnMsg = 'custom validation failed') {
+    if (typeof validatorFn !== 'function') {
+      throw new TypeError('[VueTypes error]: You must provide a function as argument');
+    }
+
+    return toType(validatorFn.name || '<<anonymous function>>', {
+      validator(...args) {
+        const valid = validatorFn(...args);
+        if (!valid) warn(`${this._vueTypes_name} - ${warnMsg}`);
+        return valid;
+      },
+    });
+  },
+
+  oneOf(arr) {
+    if (!isArray(arr)) {
+      throw new TypeError('[VueTypes error]: You must provide an array as argument');
+    }
+    const msg = `oneOf - value should be one of "${arr.join('", "')}"`;
+    const allowedTypes = arr.reduce((ret, v) => {
+      if (v !== null && v !== undefined) {
+        ret.indexOf(v.constructor) === -1 && ret.push(v.constructor);
+      }
+      return ret;
+    }, []);
+
+    return toType('oneOf', {
+      type: allowedTypes.length > 0 ? allowedTypes : null,
+      validator(value) {
+        const valid = arr.indexOf(value) !== -1;
+        if (!valid) warn(msg);
+        return valid;
+      },
+    });
+  },
+
+  instanceOf(instanceConstructor) {
+    return toType('instanceOf', {
+      type: instanceConstructor,
+    });
+  },
+
+  oneOfType(arr) {
+    if (!isArray(arr)) {
+      throw new TypeError('[VueTypes error]: You must provide an array as argument');
+    }
+
+    let hasCustomValidators = false;
+
+    const nativeChecks = arr.reduce((ret, type) => {
+      if (isPlainObject(type)) {
+        if (type._vueTypes_name === 'oneOf') {
+          return ret.concat(type.type || []);
+        }
+        if (type.type && !isFunction(type.validator)) {
+          if (isArray(type.type)) return ret.concat(type.type);
+          ret.push(type.type);
+        } else if (isFunction(type.validator)) {
+          hasCustomValidators = true;
+        }
+        return ret;
+      }
+      ret.push(type);
+      return ret;
+    }, []);
+
+    if (!hasCustomValidators) {
+      // we got just native objects (ie: Array, Object)
+      // delegate to Vue native prop check
+      return toType('oneOfType', {
+        type: nativeChecks,
+      }).def(undefined);
+    }
+
+    const typesStr = arr
+      .map(type => {
+        if (type && isArray(type.type)) {
+          return type.type.map(getType);
+        }
+        return getType(type);
+      })
+      .reduce((ret, type) => ret.concat(isArray(type) ? type : [type]), [])
+      .join('", "');
+
+    return this.custom(function oneOfType(value) {
+      const valid = arr.some(type => {
+        if (type._vueTypes_name === 'oneOf') {
+          return type.type ? validateType(type.type, value, true) : true;
+        }
+        return validateType(type, value, true);
+      });
+      if (!valid) warn(`oneOfType - value type should be one of "${typesStr}"`);
+      return valid;
+    }).def(undefined);
+  },
+
+  arrayOf(type) {
+    return toType('arrayOf', {
+      type: Array,
+      validator(values) {
+        const valid = values.every(value => validateType(type, value));
+        if (!valid) warn(`arrayOf - value must be an array of "${getType(type)}"`);
+        return valid;
+      },
+    });
+  },
+
+  objectOf(type) {
+    return toType('objectOf', {
+      type: Object,
+      validator(obj) {
+        const valid = Object.keys(obj).every(key => validateType(type, obj[key]));
+        if (!valid) warn(`objectOf - value must be an object of "${getType(type)}"`);
+        return valid;
+      },
+    });
+  },
+
+  shape(obj) {
+    const keys = Object.keys(obj);
+    const requiredKeys = keys.filter(key => obj[key] && obj[key].required === true);
+
+    const type = toType('shape', {
+      type: Object,
+      validator(value) {
+        if (!isPlainObject(value)) {
+          return false;
+        }
+        const valueKeys = Object.keys(value);
+
+        // check for required keys (if any)
+        if (requiredKeys.length > 0 && requiredKeys.some(req => valueKeys.indexOf(req) === -1)) {
+          warn(
+            `shape - at least one of required properties "${requiredKeys.join(
+              '", "',
+            )}" is not present`,
+          );
+          return false;
+        }
+
+        return valueKeys.every(key => {
+          if (keys.indexOf(key) === -1) {
+            if (this._vueTypes_isLoose === true) return true;
+            warn(`shape - object is missing "${key}" property`);
+            return false;
+          }
+          const type = obj[key];
+          return validateType(type, value[key]);
+        });
+      },
+    });
+
+    Object.defineProperty(type, '_vueTypes_isLoose', {
+      enumerable: false,
+      writable: true,
+      value: false,
+    });
+
+    Object.defineProperty(type, 'loose', {
+      get() {
+        this._vueTypes_isLoose = true;
+        return this;
+      },
+      enumerable: false,
+    });
+
+    return type;
+  },
+};
+
+const typeDefaults = () => ({
+  func: undefined,
+  bool: undefined,
+  string: undefined,
+  number: undefined,
+  array: undefined,
+  object: undefined,
+  integer: undefined,
+});
+
+let currentDefaults = typeDefaults();
+
+Object.defineProperty(VuePropTypes, 'sensibleDefaults', {
+  enumerable: false,
+  set(value) {
+    if (value === false) {
+      currentDefaults = {};
+    } else if (value === true) {
+      currentDefaults = typeDefaults();
+    } else if (isPlainObject(value)) {
+      currentDefaults = value;
+    }
+  },
+  get() {
+    return currentDefaults;
+  },
+});
+
+export default VuePropTypes;

package/src/components/_util/vue-types/utils.js

@@ -0,0 +1,200 @@
+import isPlainObject from 'lodash/isPlainObject';
+
+const ObjProto = Object.prototype;
+const toString = ObjProto.toString;
+export const hasOwn = ObjProto.hasOwnProperty;
+
+const FN_MATCH_REGEXP = /^\s*function (\w+)/;
+
+// https://github.com/vuejs/vue/blob/dev/src/core/util/props.js#L159
+export const getType = fn => {
+  const type = fn !== null && fn !== undefined ? (fn.type ? fn.type : fn) : null;
+  const match = type && type.toString().match(FN_MATCH_REGEXP);
+  return match && match[1];
+};
+
+export const getNativeType = value => {
+  if (value === null || value === undefined) return null;
+  const match = value.constructor.toString().match(FN_MATCH_REGEXP);
+  return match && match[1];
+};
+
+/**
+ * No-op function
+ */
+export const noop = () => {};
+
+/**
+ * Checks for a own property in an object
+ *
+ * @param {object} obj - Object
+ * @param {string} prop - Property to check
+ */
+export const has = (obj, prop) => hasOwn.call(obj, prop);
+
+/**
+ * Determines whether the passed value is an integer. Uses `Number.isInteger` if available
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger
+ * @param {*} value - The value to be tested for being an integer.
+ * @returns {boolean}
+ */
+export const isInteger =
+  Number.isInteger ||
+  function(value) {
+    return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
+  };
+
+/**
+ * Determines whether the passed value is an Array.
+ *
+ * @param {*} value - The value to be tested for being an array.
+ * @returns {boolean}
+ */
+export const isArray =
+  Array.isArray ||
+  function(value) {
+    return toString.call(value) === '[object Array]';
+  };
+
+/**
+ * Checks if a value is a function
+ *
+ * @param {any} value - Value to check
+ * @returns {boolean}
+ */
+export const isFunction = value => toString.call(value) === '[object Function]';
+
+/**
+ * Adds a `def` method to the object returning a new object with passed in argument as `default` property
+ *
+ * @param {object} type - Object to enhance
+ */
+export const withDefault = function(type) {
+  Object.defineProperty(type, 'def', {
+    value(def) {
+      if (def === undefined && this.default === undefined) {
+        this.default = undefined;
+        return this;
+      }
+      if (!isFunction(def) && !validateType(this, def)) {
+        warn(`${this._vueTypes_name} - invalid default value: "${def}"`, def);
+        return this;
+      }
+      this.default =
+        isArray(def) || isPlainObject(def)
+          ? function() {
+              return def;
+            }
+          : def;
+
+      return this;
+    },
+    enumerable: false,
+    writable: false,
+  });
+};
+
+/**
+ * Adds a `isRequired` getter returning a new object with `required: true` key-value
+ *
+ * @param {object} type - Object to enhance
+ */
+export const withRequired = function(type) {
+  Object.defineProperty(type, 'isRequired', {
+    get() {
+      this.required = true;
+      return this;
+    },
+    enumerable: false,
+  });
+};
+
+/**
+ * Adds `isRequired` and `def` modifiers to an object
+ *
+ * @param {string} name - Type internal name
+ * @param {object} obj - Object to enhance
+ * @returns {object}
+ */
+export const toType = (name, obj) => {
+  Object.defineProperty(obj, '_vueTypes_name', {
+    enumerable: false,
+    writable: false,
+    value: name,
+  });
+  withRequired(obj);
+  withDefault(obj);
+
+  if (isFunction(obj.validator)) {
+    obj.validator = obj.validator.bind(obj);
+  }
+  return obj;
+};
+
+/**
+ * Validates a given value against a prop type object
+ *
+ * @param {Object|*} type - Type to use for validation. Either a type object or a constructor
+ * @param {*} value - Value to check
+ * @param {boolean} silent - Silence warnings
+ * @returns {boolean}
+ */
+export const validateType = (type, value, silent = false) => {
+  let typeToCheck = type;
+  let valid = true;
+  let expectedType;
+  if (!isPlainObject(type)) {
+    typeToCheck = { type };
+  }
+  const namePrefix = typeToCheck._vueTypes_name ? typeToCheck._vueTypes_name + ' - ' : '';
+
+  if (hasOwn.call(typeToCheck, 'type') && typeToCheck.type !== null) {
+    if (isArray(typeToCheck.type)) {
+      valid = typeToCheck.type.some(type => validateType(type, value, true));
+      expectedType = typeToCheck.type.map(type => getType(type)).join(' or ');
+    } else {
+      expectedType = getType(typeToCheck);
+
+      if (expectedType === 'Array') {
+        valid = isArray(value);
+      } else if (expectedType === 'Object') {
+        valid = isPlainObject(value);
+      } else if (
+        expectedType === 'String' ||
+        expectedType === 'Number' ||
+        expectedType === 'Boolean' ||
+        expectedType === 'Function'
+      ) {
+        valid = getNativeType(value) === expectedType;
+      } else {
+        valid = value instanceof typeToCheck.type;
+      }
+    }
+  }
+
+  if (!valid) {
+    silent === false && warn(`${namePrefix}value "${value}" should be of type "${expectedType}"`);
+    return false;
+  }
+
+  if (hasOwn.call(typeToCheck, 'validator') && isFunction(typeToCheck.validator)) {
+    valid = typeToCheck.validator(value);
+    if (!valid && silent === false) warn(`${namePrefix}custom validation failed`);
+    return valid;
+  }
+  return valid;
+};
+
+let warn = noop;
+
+if (process.env.NODE_ENV !== 'production') {
+  const hasConsole = typeof console !== 'undefined';
+  warn = msg => {
+    if (hasConsole) {
+      console.warn(`[VueTypes warn]: ${msg}`);
+    }
+  };
+}
+
+export { warn };

package/src/components/_util/warning.js

@@ -0,0 +1,7 @@
+import warning, { resetWarned } from '../vc-util/warning';
+
+export { resetWarned };
+
+export default (valid, component, message = '') => {
+  warning(valid, `[antdv: ${component}] ${message}`);
+};

package/src/components/_util/wave.jsx

@@ -0,0 +1,169 @@
+import TransitionEvents from './css-animation/Event';
+import raf from './raf';
+import { ConfigConsumerProps } from '../config-provider/configConsumerProps';
+let styleForPesudo;
+
+// Where el is the DOM element you'd like to test for visibility
+function isHidden(element) {
+  if (process.env.NODE_ENV === 'test') {
+    return false;
+  }
+  return !element || element.offsetParent === null;
+}
+function isNotGrey(color) {
+  // eslint-disable-next-line no-useless-escape
+  const match = (color || '').match(/rgba?\((\d*), (\d*), (\d*)(, [\.\d]*)?\)/);
+  if (match && match[1] && match[2] && match[3]) {
+    return !(match[1] === match[2] && match[2] === match[3]);
+  }
+  return true;
+}
+export default {
+  name: 'Wave',
+  props: ['insertExtraNode'],
+  mounted() {
+    this.$nextTick(() => {
+      const node = this.$el;
+      if (node.nodeType !== 1) {
+        return;
+      }
+      this.instance = this.bindAnimationEvent(node);
+    });
+  },
+  inject: {
+    configProvider: { default: () => ConfigConsumerProps },
+  },
+  beforeDestroy() {
+    if (this.instance) {
+      this.instance.cancel();
+    }
+    if (this.clickWaveTimeoutId) {
+      clearTimeout(this.clickWaveTimeoutId);
+    }
+    this.destroy = true;
+  },
+  methods: {
+    onClick(node, waveColor) {
+      if (!node || isHidden(node) || node.className.indexOf('-leave') >= 0) {
+        return;
+      }
+      const { insertExtraNode } = this.$props;
+      this.extraNode = document.createElement('div');
+      const extraNode = this.extraNode;
+      extraNode.className = 'ant-click-animating-node';
+      const attributeName = this.getAttributeName();
+      node.removeAttribute(attributeName);
+      node.setAttribute(attributeName, 'true');
+      // Not white or transparent or grey
+      styleForPesudo = styleForPesudo || document.createElement('style');
+      if (
+        waveColor &&
+        waveColor !== '#ffffff' &&
+        waveColor !== 'rgb(255, 255, 255)' &&
+        isNotGrey(waveColor) &&
+        !/rgba\(\d*, \d*, \d*, 0\)/.test(waveColor) && // any transparent rgba color
+        waveColor !== 'transparent'
+      ) {
+        // Add nonce if CSP exist
+        if (this.csp && this.csp.nonce) {
+          styleForPesudo.nonce = this.csp.nonce;
+        }
+        extraNode.style.borderColor = waveColor;
+        styleForPesudo.innerHTML = `
+        [ant-click-animating-without-extra-node='true']::after, .ant-click-animating-node {
+          --antd-wave-shadow-color: ${waveColor};
+        }`;
+        if (!document.body.contains(styleForPesudo)) {
+          document.body.appendChild(styleForPesudo);
+        }
+      }
+      if (insertExtraNode) {
+        node.appendChild(extraNode);
+      }
+      TransitionEvents.addStartEventListener(node, this.onTransitionStart);
+      TransitionEvents.addEndEventListener(node, this.onTransitionEnd);
+    },
+    onTransitionStart(e) {
+      if (this.destroy) return;
+
+      const node = this.$el;
+      if (!e || e.target !== node) {
+        return;
+      }
+
+      if (!this.animationStart) {
+        this.resetEffect(node);
+      }
+    },
+    onTransitionEnd(e) {
+      if (!e || e.animationName !== 'fadeEffect') {
+        return;
+      }
+      this.resetEffect(e.target);
+    },
+    getAttributeName() {
+      const { insertExtraNode } = this.$props;
+      return insertExtraNode ? 'ant-click-animating' : 'ant-click-animating-without-extra-node';
+    },
+    bindAnimationEvent(node) {
+      if (
+        !node ||
+        !node.getAttribute ||
+        node.getAttribute('disabled') ||
+        node.className.indexOf('disabled') >= 0
+      ) {
+        return;
+      }
+      const onClick = e => {
+        // Fix radio button click twice
+        if (e.target.tagName === 'INPUT' || isHidden(e.target)) {
+          return;
+        }
+        this.resetEffect(node);
+        // Get wave color from target
+        const waveColor =
+          getComputedStyle(node).getPropertyValue('border-top-color') || // Firefox Compatible
+          getComputedStyle(node).getPropertyValue('border-color') ||
+          getComputedStyle(node).getPropertyValue('background-color');
+        this.clickWaveTimeoutId = window.setTimeout(() => this.onClick(node, waveColor), 0);
+        raf.cancel(this.animationStartId);
+        this.animationStart = true;
+
+        // Render to trigger transition event cost 3 frames. Let's delay 10 frames to reset this.
+        this.animationStartId = raf(() => {
+          this.animationStart = false;
+        }, 10);
+      };
+      node.addEventListener('click', onClick, true);
+      return {
+        cancel: () => {
+          node.removeEventListener('click', onClick, true);
+        },
+      };
+    },
+
+    resetEffect(node) {
+      if (!node || node === this.extraNode || !(node instanceof Element)) {
+        return;
+      }
+      const { insertExtraNode } = this.$props;
+      const attributeName = this.getAttributeName();
+      node.setAttribute(attributeName, 'false'); // edge has bug on `removeAttribute` #14466
+      if (styleForPesudo) {
+        styleForPesudo.innerHTML = '';
+      }
+      if (insertExtraNode && this.extraNode && node.contains(this.extraNode)) {
+        node.removeChild(this.extraNode);
+      }
+      TransitionEvents.removeStartEventListener(node, this.onTransitionStart);
+      TransitionEvents.removeEndEventListener(node, this.onTransitionEnd);
+    },
+  },
+
+  render() {
+    if (this.configProvider.csp) {
+      this.csp = this.configProvider.csp;
+    }
+    return this.$slots.default && this.$slots.default[0];
+  },
+};

package/src/components/base/index.js

@@ -0,0 +1,9 @@
+import antDirective from '../_util/antDirective';
+const base = {};
+const install = function(Vue) {
+  base.Vue = Vue;
+  Vue.use(antDirective);
+};
+base.install = install;
+
+export default base;

package/src/components/base/style/index.js

@@ -0,0 +1,2 @@
+// empty file prevent babel-plugin-import error
+import '../../style/index.less';