handsontable 0.0.0-next-9ec04ce-20221121

package/helpers/object.mjs

@@ -0,0 +1,352 @@
+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.includes.js";
+import "core-js/modules/es.string.includes.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/web.dom-collections.for-each.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.iterator.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+import { arrayEach } from "./array.mjs";
+/**
+ * Generate schema for passed object.
+ *
+ * @param {Array|object} object An object to analyze.
+ * @returns {Array|object}
+ */
+export function duckSchema(object) {
+  var schema;
+  if (Array.isArray(object)) {
+    schema = [];
+  } else {
+    schema = {};
+    objectEach(object, function (value, key) {
+      if (key === '__children') {
+        return;
+      }
+      if (value && _typeof(value) === 'object' && !Array.isArray(value)) {
+        schema[key] = duckSchema(value);
+      } else if (Array.isArray(value)) {
+        if (value.length && _typeof(value[0]) === 'object' && !Array.isArray(value[0])) {
+          schema[key] = [duckSchema(value[0])];
+        } else {
+          schema[key] = [];
+        }
+      } else {
+        schema[key] = null;
+      }
+    });
+  }
+  return schema;
+}
+
+/**
+ * Inherit without without calling parent constructor, and setting `Child.prototype.constructor` to `Child` instead of `Parent`.
+ * Creates temporary dummy function to call it as constructor.
+ * Described in ticket: https://github.com/handsontable/handsontable/pull/516.
+ *
+ * @param {object} Child The child class.
+ * @param {object} Parent The parent class.
+ * @returns {object}
+ */
+export function inherit(Child, Parent) {
+  Parent.prototype.constructor = Parent;
+  Child.prototype = new Parent();
+  Child.prototype.constructor = Child;
+  return Child;
+}
+
+/**
+ * Perform shallow extend of a target object with extension's own properties.
+ *
+ * @param {object} target An object that will receive the new properties.
+ * @param {object} extension An object containing additional properties to merge into the target.
+ * @param {string[]} [writableKeys] An array of keys that are writable to target object.
+ * @returns {object}
+ */
+export function extend(target, extension, writableKeys) {
+  var hasWritableKeys = Array.isArray(writableKeys);
+  objectEach(extension, function (value, key) {
+    if (hasWritableKeys === false || writableKeys.includes(key)) {
+      target[key] = value;
+    }
+  });
+  return target;
+}
+
+/**
+ * Perform deep extend of a target object with extension's own properties.
+ *
+ * @param {object} target An object that will receive the new properties.
+ * @param {object} extension An object containing additional properties to merge into the target.
+ */
+export function deepExtend(target, extension) {
+  objectEach(extension, function (value, key) {
+    if (extension[key] && _typeof(extension[key]) === 'object') {
+      if (!target[key]) {
+        if (Array.isArray(extension[key])) {
+          target[key] = [];
+        } else if (Object.prototype.toString.call(extension[key]) === '[object Date]') {
+          target[key] = extension[key];
+        } else {
+          target[key] = {};
+        }
+      }
+      deepExtend(target[key], extension[key]);
+    } else {
+      target[key] = extension[key];
+    }
+  });
+}
+
+/**
+ * Perform deep clone of an object.
+ * WARNING! Only clones JSON properties. Will cause error when `obj` contains a function, Date, etc.
+ *
+ * @param {object} obj An object that will be cloned.
+ * @returns {object}
+ */
+export function deepClone(obj) {
+  if (_typeof(obj) === 'object') {
+    return JSON.parse(JSON.stringify(obj));
+  }
+  return obj;
+}
+
+/**
+ * Shallow clone object.
+ *
+ * @param {object} object An object to clone.
+ * @returns {object}
+ */
+export function clone(object) {
+  var result = {};
+  objectEach(object, function (value, key) {
+    result[key] = value;
+  });
+  return result;
+}
+
+/**
+ * Extend the Base object (usually prototype) of the functionality the `mixins` objects.
+ *
+ * @param {object} Base Base object which will be extended.
+ * @param {object} mixins The object of the functionality will be "copied".
+ * @returns {object}
+ */
+export function mixin(Base) {
+  if (!Base.MIXINS) {
+    Base.MIXINS = [];
+  }
+  for (var _len = arguments.length, mixins = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    mixins[_key - 1] = arguments[_key];
+  }
+  arrayEach(mixins, function (mixinItem) {
+    Base.MIXINS.push(mixinItem.MIXIN_NAME);
+    objectEach(mixinItem, function (value, key) {
+      if (Base.prototype[key] !== void 0) {
+        throw new Error("Mixin conflict. Property '".concat(key, "' already exist and cannot be overwritten."));
+      }
+      if (typeof value === 'function') {
+        Base.prototype[key] = value;
+      } else {
+        var getter = function _getter(property, initialValue) {
+          var propertyName = "_".concat(property);
+          var initValue = function initValue(newValue) {
+            var result = newValue;
+            if (Array.isArray(result) || isObject(result)) {
+              result = deepClone(result);
+            }
+            return result;
+          };
+          return function () {
+            if (this[propertyName] === void 0) {
+              this[propertyName] = initValue(initialValue);
+            }
+            return this[propertyName];
+          };
+        };
+        var setter = function _setter(property) {
+          var propertyName = "_".concat(property);
+          return function (newValue) {
+            this[propertyName] = newValue;
+          };
+        };
+        Object.defineProperty(Base.prototype, key, {
+          get: getter(key, value),
+          set: setter(key),
+          configurable: true
+        });
+      }
+    });
+  });
+  return Base;
+}
+
+/**
+ * Checks if two objects or arrays are (deep) equal.
+ *
+ * @param {object|Array} object1 The first object to compare.
+ * @param {object|Array} object2 The second object to compare.
+ * @returns {boolean}
+ */
+export function isObjectEqual(object1, object2) {
+  return JSON.stringify(object1) === JSON.stringify(object2);
+}
+
+/**
+ * Determines whether given object is a plain Object.
+ * Note: String and Array are not plain Objects.
+ *
+ * @param {*} object An object to check.
+ * @returns {boolean}
+ */
+export function isObject(object) {
+  return Object.prototype.toString.call(object) === '[object Object]';
+}
+
+/**
+ * @param {object} object The object on which to define the property.
+ * @param {string} property The name of the property to be defined or modified.
+ * @param {*} value The value associated with the property.
+ * @param {object} options The descriptor for the property being defined or modified.
+ */
+export function defineGetter(object, property, value, options) {
+  options.value = value;
+  options.writable = options.writable !== false;
+  options.enumerable = options.enumerable !== false;
+  options.configurable = options.configurable !== false;
+  Object.defineProperty(object, property, options);
+}
+
+/**
+ * A specialized version of `.forEach` for objects.
+ *
+ * @param {object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {object} Returns `object`.
+ */
+export function objectEach(object, iteratee) {
+  // eslint-disable-next-line no-restricted-syntax
+  for (var key in object) {
+    if (!object.hasOwnProperty || object.hasOwnProperty && Object.prototype.hasOwnProperty.call(object, key)) {
+      if (iteratee(object[key], key, object) === false) {
+        break;
+      }
+    }
+  }
+  return object;
+}
+
+/**
+ * Get object property by its name. Access to sub properties can be achieved by dot notation (e.q. `'foo.bar.baz'`).
+ *
+ * @param {object} object Object which value will be exported.
+ * @param {string} name Object property name.
+ * @returns {*}
+ */
+export function getProperty(object, name) {
+  var names = name.split('.');
+  var result = object;
+  objectEach(names, function (nameItem) {
+    result = result[nameItem];
+    if (result === void 0) {
+      result = void 0;
+      return false;
+    }
+  });
+  return result;
+}
+
+/**
+ * Set a property value on the provided object. Works on nested object prop names as well (e.g. `first.name`).
+ *
+ * @param {object} object Object to work on.
+ * @param {string} name Prop name.
+ * @param {*} value Value to be assigned at the provided property.
+ */
+export function setProperty(object, name, value) {
+  var names = name.split('.');
+  var workingObject = object;
+  names.forEach(function (propName, index) {
+    if (index !== names.length - 1) {
+      if (!hasOwnProperty(workingObject, propName)) {
+        workingObject[propName] = {};
+      }
+      workingObject = workingObject[propName];
+    } else {
+      workingObject[propName] = value;
+    }
+  });
+}
+
+/**
+ * Return object length (recursively).
+ *
+ * @param {*} object Object for which we want get length.
+ * @returns {number}
+ */
+export function deepObjectSize(object) {
+  if (!isObject(object)) {
+    return 0;
+  }
+  var recursObjLen = function recursObjLen(obj) {
+    var result = 0;
+    if (isObject(obj)) {
+      objectEach(obj, function (value, key) {
+        if (key === '__children') {
+          return;
+        }
+        result += recursObjLen(value);
+      });
+    } else {
+      result += 1;
+    }
+    return result;
+  };
+  return recursObjLen(object);
+}
+
+/**
+ * Create object with property where its value change will be observed.
+ *
+ * @param {*} [defaultValue=undefined] Default value.
+ * @param {string} [propertyToListen='value'] Property to listen.
+ * @returns {object}
+ */
+export function createObjectPropListener(defaultValue) {
+  var _holder;
+  var propertyToListen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'value';
+  var privateProperty = "_".concat(propertyToListen);
+  var holder = (_holder = {
+    _touched: false
+  }, _defineProperty(_holder, privateProperty, defaultValue), _defineProperty(_holder, "isTouched", function isTouched() {
+    return this._touched;
+  }), _holder);
+  Object.defineProperty(holder, propertyToListen, {
+    get: function get() {
+      return this[privateProperty];
+    },
+    set: function set(value) {
+      this._touched = true;
+      this[privateProperty] = value;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  return holder;
+}
+
+/**
+ * Check if at specified `key` there is any value for `object`.
+ *
+ * @param {object} object Object to search value at specyfic key.
+ * @param {string} key String key to check.
+ * @returns {boolean}
+ */
+export function hasOwnProperty(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}

package/helpers/string.d.ts

@@ -0,0 +1,7 @@
+export function toUpperCaseFirst(string: string): string;
+export function equalsIgnoreCase(...strings: string[]): boolean;
+export function randomString(): string;
+export function isPercentValue(value: string): boolean;
+export function substitute(template: string, variables?: object): string;
+export function stripTags(string: string): string;
+export function sanitize(string: string, options?: any): string;

package/helpers/string.js

@@ -0,0 +1,115 @@
+"use strict";
+
+exports.__esModule = true;
+exports.equalsIgnoreCase = equalsIgnoreCase;
+exports.isPercentValue = isPercentValue;
+exports.randomString = randomString;
+exports.sanitize = sanitize;
+exports.stripTags = stripTags;
+exports.substitute = substitute;
+exports.toUpperCaseFirst = toUpperCaseFirst;
+require("core-js/modules/es.array.index-of.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.replace.js");
+var _dompurify = _interopRequireDefault(require("dompurify"));
+var _mixed = require("./mixed");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Convert string to upper case first letter.
+ *
+ * @param {string} string String to convert.
+ * @returns {string}
+ */
+function toUpperCaseFirst(string) {
+  return string[0].toUpperCase() + string.substr(1);
+}
+
+/**
+ * Compare strings case insensitively.
+ *
+ * @param {...string} strings Strings to compare.
+ * @returns {boolean}
+ */
+function equalsIgnoreCase() {
+  var unique = [];
+  for (var _len = arguments.length, strings = new Array(_len), _key = 0; _key < _len; _key++) {
+    strings[_key] = arguments[_key];
+  }
+  var length = strings.length;
+  while (length) {
+    length -= 1;
+    var string = (0, _mixed.stringify)(strings[length]).toLowerCase();
+    if (unique.indexOf(string) === -1) {
+      unique.push(string);
+    }
+  }
+  return unique.length === 1;
+}
+
+/**
+ * Generates a random hex string. Used as namespace for Handsontable instance events.
+ *
+ * @returns {string} Returns 16-long character random string (eq. `'92b1bfc74ec4'`).
+ */
+function randomString() {
+  /**
+   * @returns {string}
+   */
+  function s4() {
+    return Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);
+  }
+  return s4() + s4() + s4() + s4();
+}
+
+/**
+ * Checks if value is valid percent.
+ *
+ * @param {string} value The value to check.
+ * @returns {boolean}
+ */
+function isPercentValue(value) {
+  return /^([0-9][0-9]?%$)|(^100%$)/.test(value);
+}
+
+/**
+ * Substitute strings placed beetwen square brackets into value defined in `variables` object. String names defined in
+ * square brackets must be the same as property name of `variables` object.
+ *
+ * @param {string} template Template string.
+ * @param {object} variables Object which contains all available values which can be injected into template.
+ * @returns {string}
+ */
+function substitute(template) {
+  var variables = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return "".concat(template).replace(/(?:\\)?\[([^[\]]+)]/g, function (match, name) {
+    if (match.charAt(0) === '\\') {
+      return match.substr(1, match.length - 1);
+    }
+    return variables[name] === void 0 ? '' : variables[name];
+  });
+}
+
+/**
+ * Strip any HTML tag from the string.
+ *
+ * @param {string} string String to cut HTML from.
+ * @returns {string}
+ */
+function stripTags(string) {
+  return sanitize("".concat(string), {
+    ALLOWED_TAGS: []
+  });
+}
+
+/**
+ * Sanitizes string from potential security vulnerabilities.
+ *
+ * @param {string} string String to sanitize.
+ * @param {object} [options] DOMPurify's configuration object.
+ * @returns {string}
+ */
+function sanitize(string, options) {
+  return _dompurify.default.sanitize(string, options);
+}

package/helpers/string.mjs

@@ -0,0 +1,104 @@
+import "core-js/modules/es.array.index-of.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.regexp.to-string.js";
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.string.replace.js";
+import DOMPurify from 'dompurify';
+import { stringify } from "./mixed.mjs";
+/**
+ * Convert string to upper case first letter.
+ *
+ * @param {string} string String to convert.
+ * @returns {string}
+ */
+export function toUpperCaseFirst(string) {
+  return string[0].toUpperCase() + string.substr(1);
+}
+
+/**
+ * Compare strings case insensitively.
+ *
+ * @param {...string} strings Strings to compare.
+ * @returns {boolean}
+ */
+export function equalsIgnoreCase() {
+  var unique = [];
+  for (var _len = arguments.length, strings = new Array(_len), _key = 0; _key < _len; _key++) {
+    strings[_key] = arguments[_key];
+  }
+  var length = strings.length;
+  while (length) {
+    length -= 1;
+    var string = stringify(strings[length]).toLowerCase();
+    if (unique.indexOf(string) === -1) {
+      unique.push(string);
+    }
+  }
+  return unique.length === 1;
+}
+
+/**
+ * Generates a random hex string. Used as namespace for Handsontable instance events.
+ *
+ * @returns {string} Returns 16-long character random string (eq. `'92b1bfc74ec4'`).
+ */
+export function randomString() {
+  /**
+   * @returns {string}
+   */
+  function s4() {
+    return Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);
+  }
+  return s4() + s4() + s4() + s4();
+}
+
+/**
+ * Checks if value is valid percent.
+ *
+ * @param {string} value The value to check.
+ * @returns {boolean}
+ */
+export function isPercentValue(value) {
+  return /^([0-9][0-9]?%$)|(^100%$)/.test(value);
+}
+
+/**
+ * Substitute strings placed beetwen square brackets into value defined in `variables` object. String names defined in
+ * square brackets must be the same as property name of `variables` object.
+ *
+ * @param {string} template Template string.
+ * @param {object} variables Object which contains all available values which can be injected into template.
+ * @returns {string}
+ */
+export function substitute(template) {
+  var variables = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return "".concat(template).replace(/(?:\\)?\[([^[\]]+)]/g, function (match, name) {
+    if (match.charAt(0) === '\\') {
+      return match.substr(1, match.length - 1);
+    }
+    return variables[name] === void 0 ? '' : variables[name];
+  });
+}
+
+/**
+ * Strip any HTML tag from the string.
+ *
+ * @param {string} string String to cut HTML from.
+ * @returns {string}
+ */
+export function stripTags(string) {
+  return sanitize("".concat(string), {
+    ALLOWED_TAGS: []
+  });
+}
+
+/**
+ * Sanitizes string from potential security vulnerabilities.
+ *
+ * @param {string} string String to sanitize.
+ * @param {object} [options] DOMPurify's configuration object.
+ * @returns {string}
+ */
+export function sanitize(string, options) {
+  return DOMPurify.sanitize(string, options);
+}

package/helpers/templateLiteralTag.d.ts

@@ -0,0 +1 @@
+export function toSingleLine(strings: string[], ...expressions: string[]): string;

package/helpers/templateLiteralTag.js

@@ -0,0 +1,26 @@
+"use strict";
+
+exports.__esModule = true;
+exports.toSingleLine = toSingleLine;
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.replace.js");
+require("core-js/modules/es.string.trim.js");
+var _array = require("../helpers/array");
+/**
+ * Tags a multiline string and return new one without line break characters and following spaces.
+ *
+ * @param {Array} strings Parts of the entire string without expressions.
+ * @param {...string} expressions Expressions converted to strings, which are added to the entire string.
+ * @returns {string}
+ */
+function toSingleLine(strings) {
+  for (var _len = arguments.length, expressions = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    expressions[_key - 1] = arguments[_key];
+  }
+  var result = (0, _array.arrayReduce)(strings, function (previousValue, currentValue, index) {
+    var valueWithoutWhiteSpaces = currentValue.replace(/\r?\n\s*/g, '');
+    var expressionForIndex = expressions[index] ? expressions[index] : '';
+    return previousValue + valueWithoutWhiteSpaces + expressionForIndex;
+  }, '');
+  return result.trim();
+}

package/helpers/templateLiteralTag.mjs

@@ -0,0 +1,22 @@
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.string.replace.js";
+import "core-js/modules/es.string.trim.js";
+import { arrayReduce } from "../helpers/array.mjs";
+/**
+ * Tags a multiline string and return new one without line break characters and following spaces.
+ *
+ * @param {Array} strings Parts of the entire string without expressions.
+ * @param {...string} expressions Expressions converted to strings, which are added to the entire string.
+ * @returns {string}
+ */
+export function toSingleLine(strings) {
+  for (var _len = arguments.length, expressions = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    expressions[_key - 1] = arguments[_key];
+  }
+  var result = arrayReduce(strings, function (previousValue, currentValue, index) {
+    var valueWithoutWhiteSpaces = currentValue.replace(/\r?\n\s*/g, '');
+    var expressionForIndex = expressions[index] ? expressions[index] : '';
+    return previousValue + valueWithoutWhiteSpaces + expressionForIndex;
+  }, '');
+  return result.trim();
+}

package/helpers/unicode.d.ts

@@ -0,0 +1,73 @@
+export function isPrintableChar(keyCode: number): boolean;
+export function isFunctionKey(keyCode: number): boolean;
+export function isCtrlKey(keyCode: number): boolean;
+export function isCtrlMetaKey(keyCode: number): boolean;
+export function isKey(keyCode: number, baseCode: string): boolean;
+export enum KEY_CODES {
+  ALT = 18,
+  ARROW_DOWN = 40,
+  ARROW_LEFT = 37,
+  ARROW_RIGHT = 39,
+  ARROW_UP = 38,
+  AUDIO_DOWN = 174,
+  AUDIO_MUTE = 173,
+  AUDIO_UP = 175,
+  BACKSPACE = 8,
+  CAPS_LOCK = 20,
+  COMMA = 188,
+  COMMAND_LEFT = 91,
+  COMMAND_RIGHT = 93,
+  COMMAND_FIREFOX = 224,
+  CONTROL = 17,
+  DELETE = 46,
+  END = 35,
+  ENTER = 13,
+  ESCAPE = 27,
+  F1 = 112,
+  F2 = 113,
+  F3 = 114,
+  F4 = 115,
+  F5 = 116,
+  F6 = 117,
+  F7 = 118,
+  F8 = 119,
+  F9 = 120,
+  F10 = 121,
+  F11 = 122,
+  F12 = 123,
+  F13 = 124,
+  F14 = 125,
+  F15 = 126,
+  F16 = 127,
+  F17 = 128,
+  F18 = 129,
+  F19 = 130,
+  HOME = 36,
+  INSERT = 45,
+  MEDIA_NEXT = 176,
+  MEDIA_PLAY_PAUSE = 179,
+  MEDIA_PREV = 177,
+  MEDIA_STOP = 178,
+  NULL = 0,
+  NUM_LOCK = 144,
+  PAGE_DOWN = 34,
+  PAGE_UP = 33,
+  PAUSE = 19,
+  PERIOD = 190,
+  SCROLL_LOCK = 145,
+  SHIFT = 16,
+  SPACE = 32,
+  TAB = 9,
+  A = 65,
+  C = 67,
+  D = 68,
+  F = 70,
+  L = 76,
+  O = 79,
+  P = 80,
+  S = 83,
+  V = 86,
+  X = 88,
+  Y = 89,
+  Z = 90,
+}