handsontable 0.0.0-next-9ec04ce-20221121

package/utils/samplesGenerator.mjs

@@ -0,0 +1,205 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.map.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.array.index-of.js";
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+import { isObject } from "./../helpers/object.mjs";
+import { rangeEach } from "./../helpers/number.mjs";
+import { stringify } from "./../helpers/mixed.mjs";
+/**
+ * @class SamplesGenerator
+ */
+var SamplesGenerator = /*#__PURE__*/function () {
+  function SamplesGenerator(dataFactory) {
+    _classCallCheck(this, SamplesGenerator);
+    /**
+     * Samples prepared for calculations.
+     *
+     * @type {Map}
+     * @default {null}
+     */
+    this.samples = null;
+    /**
+     * Function which give the data to collect samples.
+     *
+     * @type {Function}
+     */
+    this.dataFactory = dataFactory;
+    /**
+     * Custom number of samples to take of each value length.
+     *
+     * @type {number}
+     * @default {null}
+     */
+    this.customSampleCount = null;
+    /**
+     * `true` if duplicate samples collection should be allowed, `false` otherwise.
+     *
+     * @type {boolean}
+     * @default {false}
+     */
+    this.allowDuplicates = false;
+  }
+
+  /**
+   * Get the sample count for this instance.
+   *
+   * @returns {number}
+   */
+  _createClass(SamplesGenerator, [{
+    key: "getSampleCount",
+    value: function getSampleCount() {
+      if (this.customSampleCount) {
+        return this.customSampleCount;
+      }
+      return SamplesGenerator.SAMPLE_COUNT;
+    }
+
+    /**
+     * Set the sample count.
+     *
+     * @param {number} sampleCount Number of samples to be collected.
+     */
+  }, {
+    key: "setSampleCount",
+    value: function setSampleCount(sampleCount) {
+      this.customSampleCount = sampleCount;
+    }
+
+    /**
+     * Set if the generator should accept duplicate values.
+     *
+     * @param {boolean} allowDuplicates `true` to allow duplicate values.
+     */
+  }, {
+    key: "setAllowDuplicates",
+    value: function setAllowDuplicates(allowDuplicates) {
+      this.allowDuplicates = allowDuplicates;
+    }
+
+    /**
+     * Generate samples for row. You can control which area should be sampled by passing `rowRange` object and `colRange` object.
+     *
+     * @param {object|number} rowRange The rows range to generate the samples.
+     * @param {object} colRange The column range to generate the samples.
+     * @returns {object}
+     */
+  }, {
+    key: "generateRowSamples",
+    value: function generateRowSamples(rowRange, colRange) {
+      return this.generateSamples('row', colRange, rowRange);
+    }
+
+    /**
+     * Generate samples for column. You can control which area should be sampled by passing `colRange` object and `rowRange` object.
+     *
+     * @param {object} colRange Column index.
+     * @param {object} rowRange Column index.
+     * @returns {object}
+     */
+  }, {
+    key: "generateColumnSamples",
+    value: function generateColumnSamples(colRange, rowRange) {
+      return this.generateSamples('col', rowRange, colRange);
+    }
+
+    /**
+     * Generate collection of samples.
+     *
+     * @param {string} type Type to generate. Can be `col` or `row`.
+     * @param {object} range The range to generate the samples.
+     * @param {object|number} specifierRange The range to generate the samples.
+     * @returns {Map}
+     */
+  }, {
+    key: "generateSamples",
+    value: function generateSamples(type, range, specifierRange) {
+      var _this = this;
+      var samples = new Map();
+      var _ref = typeof specifierRange === 'number' ? {
+          from: specifierRange,
+          to: specifierRange
+        } : specifierRange,
+        from = _ref.from,
+        to = _ref.to;
+      rangeEach(from, to, function (index) {
+        var sample = _this.generateSample(type, range, index);
+        samples.set(index, sample);
+      });
+      return samples;
+    }
+
+    /**
+     * Generate sample for specified type (`row` or `col`).
+     *
+     * @param {string} type Samples type `row` or `col`.
+     * @param {object} range The range to generate the samples.
+     * @param {number} specifierValue The range to generate the samples.
+     * @returns {Map}
+     */
+  }, {
+    key: "generateSample",
+    value: function generateSample(type, range, specifierValue) {
+      var _this2 = this;
+      if (type !== 'row' && type !== 'col') {
+        throw new Error('Unsupported sample type');
+      }
+      var samples = new Map();
+      var computedKey = type === 'row' ? 'col' : 'row';
+      var sampledValues = [];
+      rangeEach(range.from, range.to, function (index) {
+        var _ref2 = type === 'row' ? _this2.dataFactory(specifierValue, index) : _this2.dataFactory(index, specifierValue),
+          value = _ref2.value,
+          bundleSeed = _ref2.bundleSeed;
+        var hasCustomBundleSeed = typeof bundleSeed === 'string' && bundleSeed.length > 0;
+        var seed;
+        if (hasCustomBundleSeed) {
+          seed = bundleSeed;
+        } else if (isObject(value)) {
+          seed = "".concat(Object.keys(value).length);
+        } else if (Array.isArray(value)) {
+          seed = "".concat(value.length);
+        } else {
+          seed = "".concat(stringify(value).length);
+        }
+        if (!samples.has(seed)) {
+          samples.set(seed, {
+            needed: _this2.getSampleCount(),
+            strings: []
+          });
+        }
+        var sample = samples.get(seed);
+        if (sample.needed) {
+          var duplicate = sampledValues.indexOf(value) > -1;
+          if (!duplicate || _this2.allowDuplicates || hasCustomBundleSeed) {
+            sample.strings.push(_defineProperty({
+              value: value
+            }, computedKey, index));
+            sampledValues.push(value);
+            sample.needed -= 1;
+          }
+        }
+      });
+      return samples;
+    }
+  }], [{
+    key: "SAMPLE_COUNT",
+    get:
+    /**
+     * Number of samples to take of each value length.
+     *
+     * @type {number}
+     */
+    function get() {
+      return 3;
+    }
+  }]);
+  return SamplesGenerator;
+}();
+export default SamplesGenerator;

package/utils/staticRegister.js

@@ -0,0 +1,92 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.symbol.iterator.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.function.name.js");
+require("core-js/modules/es.regexp.exec.js");
+exports.__esModule = true;
+exports.collection = void 0;
+exports.default = staticRegister;
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.map.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+var collection = new Map();
+
+/**
+ * @param {string} namespace The namespace for the storage.
+ * @returns {object}
+ */
+exports.collection = collection;
+function staticRegister() {
+  var namespace = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'common';
+  if (!collection.has(namespace)) {
+    collection.set(namespace, new Map());
+  }
+  var subCollection = collection.get(namespace);
+
+  /**
+   * Register an item to the collection. If the item under the same was exist earlier then this item will be replaced with new one.
+   *
+   * @param {string} name Identification of the item.
+   * @param {*} item Item to save in the collection.
+   */
+  function register(name, item) {
+    subCollection.set(name, item);
+  }
+
+  /**
+   * Retrieve the item from the collection.
+   *
+   * @param {string} name Identification of the item.
+   * @returns {*} Returns item which was saved in the collection.
+   */
+  function getItem(name) {
+    return subCollection.get(name);
+  }
+
+  /**
+   * Check if item under specified name is exists.
+   *
+   * @param {string} name Identification of the item.
+   * @returns {boolean} Returns `true` or `false` depends on if element exists in the collection.
+   */
+  function hasItem(name) {
+    return subCollection.has(name);
+  }
+
+  /**
+   * Retrieve list of names registered from the collection.
+   *
+   * @returns {Array} Returns an array of strings with all names under which objects are stored.
+   */
+  function getNames() {
+    return _toConsumableArray(subCollection.keys());
+  }
+
+  /**
+   * Retrieve all registered values from the collection.
+   *
+   * @returns {Array} Returns an array with all values stored in the collection.
+   */
+  function getValues() {
+    return _toConsumableArray(subCollection.values());
+  }
+  return {
+    register: register,
+    getItem: getItem,
+    hasItem: hasItem,
+    getNames: getNames,
+    getValues: getValues
+  };
+}

package/utils/staticRegister.mjs

@@ -0,0 +1,86 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.map.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.symbol.iterator.js";
+import "core-js/modules/es.array.from.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.function.name.js";
+import "core-js/modules/es.regexp.exec.js";
+export var collection = new Map();
+
+/**
+ * @param {string} namespace The namespace for the storage.
+ * @returns {object}
+ */
+export default function staticRegister() {
+  var namespace = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'common';
+  if (!collection.has(namespace)) {
+    collection.set(namespace, new Map());
+  }
+  var subCollection = collection.get(namespace);
+
+  /**
+   * Register an item to the collection. If the item under the same was exist earlier then this item will be replaced with new one.
+   *
+   * @param {string} name Identification of the item.
+   * @param {*} item Item to save in the collection.
+   */
+  function register(name, item) {
+    subCollection.set(name, item);
+  }
+
+  /**
+   * Retrieve the item from the collection.
+   *
+   * @param {string} name Identification of the item.
+   * @returns {*} Returns item which was saved in the collection.
+   */
+  function getItem(name) {
+    return subCollection.get(name);
+  }
+
+  /**
+   * Check if item under specified name is exists.
+   *
+   * @param {string} name Identification of the item.
+   * @returns {boolean} Returns `true` or `false` depends on if element exists in the collection.
+   */
+  function hasItem(name) {
+    return subCollection.has(name);
+  }
+
+  /**
+   * Retrieve list of names registered from the collection.
+   *
+   * @returns {Array} Returns an array of strings with all names under which objects are stored.
+   */
+  function getNames() {
+    return _toConsumableArray(subCollection.keys());
+  }
+
+  /**
+   * Retrieve all registered values from the collection.
+   *
+   * @returns {Array} Returns an array with all values stored in the collection.
+   */
+  function getValues() {
+    return _toConsumableArray(subCollection.values());
+  }
+  return {
+    register: register,
+    getItem: getItem,
+    hasItem: hasItem,
+    getNames: getNames,
+    getValues: getValues
+  };
+}

package/validators/autocompleteValidator/autocompleteValidator.d.ts

@@ -0,0 +1,5 @@
+import { CellProperties } from '../../settings';
+import { CellValue } from '../../common';
+
+export const VALIDATOR_TYPE: 'autocomplete';
+export function autocompleteValidator(this: CellProperties, value: CellValue, callback: (valid: boolean) => void): void;

package/validators/autocompleteValidator/autocompleteValidator.js

@@ -0,0 +1,56 @@
+"use strict";
+
+exports.__esModule = true;
+exports.VALIDATOR_TYPE = void 0;
+exports.autocompleteValidator = autocompleteValidator;
+var VALIDATOR_TYPE = 'autocomplete';
+
+/**
+ * The Autocomplete cell validator.
+ *
+ * @private
+ * @param {*} value Value of edited cell.
+ * @param {Function} callback Callback called with validation result.
+ */
+exports.VALIDATOR_TYPE = VALIDATOR_TYPE;
+function autocompleteValidator(value, callback) {
+  var valueToValidate = value;
+  if (valueToValidate === null || valueToValidate === void 0) {
+    valueToValidate = '';
+  }
+  if (this.allowEmpty && valueToValidate === '') {
+    callback(true);
+    return;
+  }
+  if (this.strict && this.source) {
+    if (typeof this.source === 'function') {
+      this.source(valueToValidate, process(valueToValidate, callback));
+    } else {
+      process(valueToValidate, callback)(this.source);
+    }
+  } else {
+    callback(true);
+  }
+}
+autocompleteValidator.VALIDATOR_TYPE = VALIDATOR_TYPE;
+
+/**
+ * Function responsible for validation of autocomplete value.
+ *
+ * @param {*} value Value of edited cell.
+ * @param {Function} callback Callback called with validation result.
+ * @returns {Function}
+ */
+function process(value, callback) {
+  var originalVal = value;
+  return function (source) {
+    var found = false;
+    for (var s = 0, slen = source.length; s < slen; s++) {
+      if (originalVal === source[s]) {
+        found = true; // perfect match
+        break;
+      }
+    }
+    callback(found);
+  };
+}

package/validators/autocompleteValidator/autocompleteValidator.mjs

@@ -0,0 +1,50 @@
+export var VALIDATOR_TYPE = 'autocomplete';
+
+/**
+ * The Autocomplete cell validator.
+ *
+ * @private
+ * @param {*} value Value of edited cell.
+ * @param {Function} callback Callback called with validation result.
+ */
+export function autocompleteValidator(value, callback) {
+  var valueToValidate = value;
+  if (valueToValidate === null || valueToValidate === void 0) {
+    valueToValidate = '';
+  }
+  if (this.allowEmpty && valueToValidate === '') {
+    callback(true);
+    return;
+  }
+  if (this.strict && this.source) {
+    if (typeof this.source === 'function') {
+      this.source(valueToValidate, process(valueToValidate, callback));
+    } else {
+      process(valueToValidate, callback)(this.source);
+    }
+  } else {
+    callback(true);
+  }
+}
+autocompleteValidator.VALIDATOR_TYPE = VALIDATOR_TYPE;
+
+/**
+ * Function responsible for validation of autocomplete value.
+ *
+ * @param {*} value Value of edited cell.
+ * @param {Function} callback Callback called with validation result.
+ * @returns {Function}
+ */
+function process(value, callback) {
+  var originalVal = value;
+  return function (source) {
+    var found = false;
+    for (var s = 0, slen = source.length; s < slen; s++) {
+      if (originalVal === source[s]) {
+        found = true; // perfect match
+        break;
+      }
+    }
+    callback(found);
+  };
+}

package/validators/autocompleteValidator/index.d.ts

@@ -0,0 +1 @@
+export { VALIDATOR_TYPE, autocompleteValidator } from './autocompleteValidator';

package/validators/autocompleteValidator/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+exports.__esModule = true;
+exports.autocompleteValidator = exports.VALIDATOR_TYPE = void 0;
+var _autocompleteValidator = require("./autocompleteValidator");
+exports.VALIDATOR_TYPE = _autocompleteValidator.VALIDATOR_TYPE;
+exports.autocompleteValidator = _autocompleteValidator.autocompleteValidator;

package/validators/autocompleteValidator/index.mjs

@@ -0,0 +1 @@
+export { VALIDATOR_TYPE, autocompleteValidator } from "./autocompleteValidator.mjs";

package/validators/base.d.ts

@@ -0,0 +1,6 @@
+import { CellProperties } from '../settings';
+import { CellValue } from '../common';
+
+export function baseValidator(this: CellProperties, value: CellValue, callback: (valid: boolean) => void): void;
+
+export type BaseValidator = typeof baseValidator;

package/validators/dateValidator/dateValidator.d.ts

@@ -0,0 +1,5 @@
+import { CellProperties } from '../../settings';
+import { CellValue } from '../../common';
+
+export const VALIDATOR_TYPE: 'date';
+export function dateValidator(this: CellProperties, value: CellValue, callback: (valid: boolean) => void): void;

package/validators/dateValidator/dateValidator.js

@@ -0,0 +1,77 @@
+"use strict";
+
+exports.__esModule = true;
+exports.VALIDATOR_TYPE = void 0;
+exports.correctFormat = correctFormat;
+exports.dateValidator = dateValidator;
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.search.js");
+var _moment = _interopRequireDefault(require("moment"));
+var _registry = require("../../editors/registry");
+var _dateEditor = require("../../editors/dateEditor");
+var _date = require("../../helpers/date");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var VALIDATOR_TYPE = 'date';
+
+/**
+ * The Date cell validator.
+ *
+ * @private
+ * @param {*} value Value of edited cell.
+ * @param {Function} callback Callback called with validation result.
+ */
+exports.VALIDATOR_TYPE = VALIDATOR_TYPE;
+function dateValidator(value, callback) {
+  var dateEditor = (0, _registry.getEditorInstance)(_dateEditor.EDITOR_TYPE, this.instance);
+  var valueToValidate = value;
+  var valid = true;
+  if (valueToValidate === null || valueToValidate === void 0) {
+    valueToValidate = '';
+  }
+  var isValidFormat = (0, _moment.default)(valueToValidate, this.dateFormat || dateEditor.defaultDateFormat, true).isValid();
+  var isValidDate = (0, _moment.default)(new Date(valueToValidate)).isValid() || isValidFormat;
+  if (this.allowEmpty && valueToValidate === '') {
+    isValidDate = true;
+    isValidFormat = true;
+  }
+  if (!isValidDate) {
+    valid = false;
+  }
+  if (!isValidDate && isValidFormat) {
+    valid = true;
+  }
+  if (isValidDate && !isValidFormat) {
+    if (this.correctFormat === true) {
+      // if format correction is enabled
+      var correctedValue = correctFormat(valueToValidate, this.dateFormat);
+      var row = this.instance.toVisualRow(this.row);
+      var column = this.instance.toVisualColumn(this.col);
+      this.instance.setDataAtCell(row, column, correctedValue, 'dateValidator');
+      valid = true;
+    } else {
+      valid = false;
+    }
+  }
+  callback(valid);
+}
+dateValidator.VALIDATOR_TYPE = VALIDATOR_TYPE;
+
+/**
+ * Format the given string using moment.js' format feature.
+ *
+ * @param {string} value The value to format.
+ * @param {string} dateFormat The date pattern to format to.
+ * @returns {string}
+ */
+function correctFormat(value, dateFormat) {
+  var dateFromDate = (0, _moment.default)((0, _date.getNormalizedDate)(value));
+  var dateFromMoment = (0, _moment.default)(value, dateFormat);
+  var isAlphanumeric = value.search(/[A-z]/g) > -1;
+  var date;
+  if (dateFromDate.isValid() && dateFromDate.format('x') === dateFromMoment.format('x') || !dateFromMoment.isValid() || isAlphanumeric) {
+    date = dateFromDate;
+  } else {
+    date = dateFromMoment;
+  }
+  return date.format(dateFormat);
+}

package/validators/dateValidator/dateValidator.mjs

@@ -0,0 +1,69 @@
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.string.search.js";
+import moment from 'moment';
+import { getEditorInstance } from "../../editors/registry.mjs";
+import { EDITOR_TYPE as DATE_EDITOR_TYPE } from "../../editors/dateEditor/index.mjs";
+import { getNormalizedDate } from "../../helpers/date.mjs";
+export var VALIDATOR_TYPE = 'date';
+
+/**
+ * The Date cell validator.
+ *
+ * @private
+ * @param {*} value Value of edited cell.
+ * @param {Function} callback Callback called with validation result.
+ */
+export function dateValidator(value, callback) {
+  var dateEditor = getEditorInstance(DATE_EDITOR_TYPE, this.instance);
+  var valueToValidate = value;
+  var valid = true;
+  if (valueToValidate === null || valueToValidate === void 0) {
+    valueToValidate = '';
+  }
+  var isValidFormat = moment(valueToValidate, this.dateFormat || dateEditor.defaultDateFormat, true).isValid();
+  var isValidDate = moment(new Date(valueToValidate)).isValid() || isValidFormat;
+  if (this.allowEmpty && valueToValidate === '') {
+    isValidDate = true;
+    isValidFormat = true;
+  }
+  if (!isValidDate) {
+    valid = false;
+  }
+  if (!isValidDate && isValidFormat) {
+    valid = true;
+  }
+  if (isValidDate && !isValidFormat) {
+    if (this.correctFormat === true) {
+      // if format correction is enabled
+      var correctedValue = correctFormat(valueToValidate, this.dateFormat);
+      var row = this.instance.toVisualRow(this.row);
+      var column = this.instance.toVisualColumn(this.col);
+      this.instance.setDataAtCell(row, column, correctedValue, 'dateValidator');
+      valid = true;
+    } else {
+      valid = false;
+    }
+  }
+  callback(valid);
+}
+dateValidator.VALIDATOR_TYPE = VALIDATOR_TYPE;
+
+/**
+ * Format the given string using moment.js' format feature.
+ *
+ * @param {string} value The value to format.
+ * @param {string} dateFormat The date pattern to format to.
+ * @returns {string}
+ */
+export function correctFormat(value, dateFormat) {
+  var dateFromDate = moment(getNormalizedDate(value));
+  var dateFromMoment = moment(value, dateFormat);
+  var isAlphanumeric = value.search(/[A-z]/g) > -1;
+  var date;
+  if (dateFromDate.isValid() && dateFromDate.format('x') === dateFromMoment.format('x') || !dateFromMoment.isValid() || isAlphanumeric) {
+    date = dateFromDate;
+  } else {
+    date = dateFromMoment;
+  }
+  return date.format(dateFormat);
+}

package/validators/dateValidator/index.d.ts

@@ -0,0 +1 @@
+export { VALIDATOR_TYPE, dateValidator } from './dateValidator';