@revolist/revogrid 3.2.13 → 3.2.16

package/custom-element/toNumber.js

@@ -0,0 +1,105 @@
+/*!
+ * Built by Revolist
+ */
+import { d as isSymbol_1, b as isObject_1 } from './isSymbol.js';
+
+/** Used to match a single whitespace character. */
+var reWhitespace = /\s/;
+
+/**
+ * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
+ * character of `string`.
+ *
+ * @private
+ * @param {string} string The string to inspect.
+ * @returns {number} Returns the index of the last non-whitespace character.
+ */
+function trimmedEndIndex(string) {
+  var index = string.length;
+
+  while (index-- && reWhitespace.test(string.charAt(index))) {}
+  return index;
+}
+
+var _trimmedEndIndex = trimmedEndIndex;
+
+/** Used to match leading whitespace. */
+var reTrimStart = /^\s+/;
+
+/**
+ * The base implementation of `_.trim`.
+ *
+ * @private
+ * @param {string} string The string to trim.
+ * @returns {string} Returns the trimmed string.
+ */
+function baseTrim(string) {
+  return string
+    ? string.slice(0, _trimmedEndIndex(string) + 1).replace(reTrimStart, '')
+    : string;
+}
+
+var _baseTrim = baseTrim;
+
+/** Used as references for various `Number` constants. */
+var NAN = 0 / 0;
+
+/** Used to detect bad signed hexadecimal string values. */
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+
+/** Used to detect binary string values. */
+var reIsBinary = /^0b[01]+$/i;
+
+/** Used to detect octal string values. */
+var reIsOctal = /^0o[0-7]+$/i;
+
+/** Built-in method references without a dependency on `root`. */
+var freeParseInt = parseInt;
+
+/**
+ * Converts `value` to a number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {number} Returns the number.
+ * @example
+ *
+ * _.toNumber(3.2);
+ * // => 3.2
+ *
+ * _.toNumber(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toNumber(Infinity);
+ * // => Infinity
+ *
+ * _.toNumber('3.2');
+ * // => 3.2
+ */
+function toNumber(value) {
+  if (typeof value == 'number') {
+    return value;
+  }
+  if (isSymbol_1(value)) {
+    return NAN;
+  }
+  if (isObject_1(value)) {
+    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
+    value = isObject_1(other) ? (other + '') : other;
+  }
+  if (typeof value != 'string') {
+    return value === 0 ? value : +value;
+  }
+  value = _baseTrim(value);
+  var isBinary = reIsBinary.test(value);
+  return (isBinary || reIsOctal.test(value))
+    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
+    : (reIsBadHex.test(value) ? NAN : +value);
+}
+
+var toNumber_1 = toNumber;
+
+export { toNumber_1 as t };

package/custom-element/utils.js

@@ -0,0 +1,69 @@
+/*!
+ * Built by Revolist
+ */
+/* Generate range on size
+ */
+// (arr1[index1] < arr2[index2])
+function simpleCompare(el1, el2) {
+  return el1 < el2;
+}
+function mergeSortedArray(arr1, arr2, compareFn = simpleCompare) {
+  const merged = [];
+  let index1 = 0;
+  let index2 = 0;
+  let current = 0;
+  while (current < arr1.length + arr2.length) {
+    let isArr1Depleted = index1 >= arr1.length;
+    let isArr2Depleted = index2 >= arr2.length;
+    if (!isArr1Depleted && (isArr2Depleted || compareFn(arr1[index1], arr2[index2]))) {
+      merged[current] = arr1[index1];
+      index1++;
+    }
+    else {
+      merged[current] = arr2[index2];
+      index2++;
+    }
+    current++;
+  }
+  return merged;
+}
+/* Calculate system scrollbar width */
+function getScrollbarWidth(doc) {
+  // Creating invisible container
+  const outer = doc.createElement('div');
+  const styles = outer.style;
+  styles.visibility = 'hidden';
+  styles.overflow = 'scroll'; // forcing scrollbar to appear
+  styles.msOverflowStyle = 'scrollbar'; // needed for WinJS apps
+  doc.body.appendChild(outer);
+  // Creating inner element and placing it in the container
+  const inner = doc.createElement('div');
+  outer.appendChild(inner);
+  // Calculating difference between container's full width and the child width
+  const scrollbarWidth = outer.offsetWidth - inner.offsetWidth;
+  // Removing temporary elements from the DOM
+  outer.parentNode.removeChild(outer);
+  return scrollbarWidth;
+}
+/* Scale a value between 2 ranges
+ *
+ * Sample:
+ * // 55 from a 0-100 range to a 0-1000 range (Ranges don't have to be positive)
+ * const n = scaleValue(55, [0,100], [0,1000]);
+ *
+ * Ranges of two values
+ * @from
+ * @to
+ *
+ * ~~ return value does the equivalent of Math.floor but faster.
+ */
+function scaleValue(value, from, to) {
+  return ((to[1] - to[0]) * (value - from[0])) / (from[1] - from[0]) + to[0];
+}
+async function timeout(delay = 0) {
+  await new Promise((r) => {
+    setTimeout(() => r(), delay);
+  });
+}
+
+export { getScrollbarWidth as g, mergeSortedArray as m, scaleValue as s, timeout as t };

package/dist/cjs/revo-grid_11.cjs.entry.js

@@ -5364,7 +5364,7 @@ class FilterPlugin extends BasePlugin {
         // testing each filter for a prop
         for (const [filterIndex, filterData] of propFilters.entries()) {
           // the filter LogicFunction based on the type
-          const filter = filterEntities[filterData.type];
+          const filter = this.possibleFilterEntities[filterData.type];
           // THE MAGIC OF FILTERING IS HERE
           if (filterData.relation === 'or') {
             lastFilterResults = [];

package/dist/collection/plugins/filter/filter.plugin.js

@@ -221,7 +221,7 @@ export default class FilterPlugin extends BasePlugin {
         // testing each filter for a prop
         for (const [filterIndex, filterData] of propFilters.entries()) {
           // the filter LogicFunction based on the type
-          const filter = filterEntities[filterData.type];
+          const filter = this.possibleFilterEntities[filterData.type];
           // THE MAGIC OF FILTERING IS HERE
           if (filterData.relation === 'or') {
             lastFilterResults = [];

package/dist/collection/utilsExternal/generate-data.js

@@ -65,6 +65,7 @@ export function generateFakeDataObject(config = {}) {
       columns[rgCol] = {
         name: generateHeader(rgCol),
         prop: rgCol,
+        filter:"myFilterType",
         sortable: true,
         size: 200,
         cellCompare: (rgCol % 2) == 0 ? naturalSort : undefined

package/dist/esm/revo-grid_11.entry.js

@@ -5360,7 +5360,7 @@ class FilterPlugin extends BasePlugin {
         // testing each filter for a prop
         for (const [filterIndex, filterData] of propFilters.entries()) {
           // the filter LogicFunction based on the type
-          const filter = filterEntities[filterData.type];
+          const filter = this.possibleFilterEntities[filterData.type];
           // THE MAGIC OF FILTERING IS HERE
           if (filterData.relation === 'or') {
             lastFilterResults = [];