@swimlane/ngx-datatable 19.0.0 → 20.0.0-alpha-1

package/esm2020/lib/utils/math.mjs

@@ -0,0 +1,146 @@
+import { columnsByPin, columnsTotalWidth } from './column';
+/**
+ * Calculates the Total Flex Grow
+ */
+export function getTotalFlexGrow(columns) {
+    let totalFlexGrow = 0;
+    for (const c of columns) {
+        totalFlexGrow += c.flexGrow || 0;
+    }
+    return totalFlexGrow;
+}
+/**
+ * Adjusts the column widths.
+ * Inspired by: https://github.com/facebook/fixed-data-table/blob/master/src/FixedDataTableWidthHelper.js
+ */
+export function adjustColumnWidths(allColumns, expectedWidth) {
+    const columnsWidth = columnsTotalWidth(allColumns);
+    const totalFlexGrow = getTotalFlexGrow(allColumns);
+    const colsByGroup = columnsByPin(allColumns);
+    if (columnsWidth !== expectedWidth) {
+        scaleColumns(colsByGroup, expectedWidth, totalFlexGrow);
+    }
+}
+/**
+ * Resizes columns based on the flexGrow property, while respecting manually set widths
+ */
+function scaleColumns(colsByGroup, maxWidth, totalFlexGrow) {
+    // calculate total width and flexgrow points for coulumns that can be resized
+    for (const attr in colsByGroup) {
+        for (const column of colsByGroup[attr]) {
+            if (!column.canAutoResize) {
+                maxWidth -= column.width;
+                totalFlexGrow -= column.flexGrow ? column.flexGrow : 0;
+            }
+            else {
+                column.width = 0;
+            }
+        }
+    }
+    const hasMinWidth = {};
+    let remainingWidth = maxWidth;
+    // resize columns until no width is left to be distributed
+    do {
+        const widthPerFlexPoint = remainingWidth / totalFlexGrow;
+        remainingWidth = 0;
+        for (const attr in colsByGroup) {
+            for (const column of colsByGroup[attr]) {
+                // if the column can be resize and it hasn't reached its minimum width yet
+                if (column.canAutoResize && !hasMinWidth[column.prop]) {
+                    const newWidth = column.width + column.flexGrow * widthPerFlexPoint;
+                    if (column.minWidth !== undefined && newWidth < column.minWidth) {
+                        remainingWidth += newWidth - column.minWidth;
+                        column.width = column.minWidth;
+                        hasMinWidth[column.prop] = true;
+                    }
+                    else {
+                        column.width = newWidth;
+                    }
+                }
+            }
+        }
+    } while (remainingWidth !== 0);
+}
+/**
+ * Forces the width of the columns to
+ * distribute equally but overflowing when necessary
+ *
+ * Rules:
+ *
+ *  - If combined withs are less than the total width of the grid,
+ *    proportion the widths given the min / max / normal widths to fill the width.
+ *
+ *  - If the combined widths, exceed the total width of the grid,
+ *    use the standard widths.
+ *
+ *  - If a column is resized, it should always use that width
+ *
+ *  - The proportional widths should never fall below min size if specified.
+ *
+ *  - If the grid starts off small but then becomes greater than the size ( + / - )
+ *    the width should use the original width; not the newly proportioned widths.
+ */
+export function forceFillColumnWidths(allColumns, expectedWidth, startIdx, allowBleed, defaultColWidth = 300) {
+    const columnsToResize = allColumns.slice(startIdx + 1, allColumns.length).filter(c => {
+        return c.canAutoResize !== false;
+    });
+    for (const column of columnsToResize) {
+        if (!column.$$oldWidth) {
+            column.$$oldWidth = column.width;
+        }
+    }
+    let additionWidthPerColumn = 0;
+    let exceedsWindow = false;
+    let contentWidth = getContentWidth(allColumns, defaultColWidth);
+    let remainingWidth = expectedWidth - contentWidth;
+    const columnsProcessed = [];
+    const remainingWidthLimit = 1; // when to stop
+    // This loop takes care of the
+    do {
+        additionWidthPerColumn = remainingWidth / columnsToResize.length;
+        exceedsWindow = contentWidth >= expectedWidth;
+        for (const column of columnsToResize) {
+            if (exceedsWindow && allowBleed) {
+                column.width = column.$$oldWidth || column.width || defaultColWidth;
+            }
+            else {
+                const newSize = (column.width || defaultColWidth) + additionWidthPerColumn;
+                if (column.minWidth && newSize < column.minWidth) {
+                    column.width = column.minWidth;
+                    columnsProcessed.push(column);
+                }
+                else if (column.maxWidth && newSize > column.maxWidth) {
+                    column.width = column.maxWidth;
+                    columnsProcessed.push(column);
+                }
+                else {
+                    column.width = newSize;
+                }
+            }
+            column.width = Math.max(0, column.width);
+        }
+        contentWidth = getContentWidth(allColumns);
+        remainingWidth = expectedWidth - contentWidth;
+        removeProcessedColumns(columnsToResize, columnsProcessed);
+    } while (remainingWidth > remainingWidthLimit && columnsToResize.length !== 0);
+}
+/**
+ * Remove the processed columns from the current active columns.
+ */
+function removeProcessedColumns(columnsToResize, columnsProcessed) {
+    for (const column of columnsProcessed) {
+        const index = columnsToResize.indexOf(column);
+        columnsToResize.splice(index, 1);
+    }
+}
+/**
+ * Gets the width of the columns
+ */
+function getContentWidth(allColumns, defaultColWidth = 300) {
+    let contentWidth = 0;
+    for (const column of allColumns) {
+        contentWidth += column.width || defaultColWidth;
+    }
+    return contentWidth;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"math.js","sourceRoot":"","sources":["../../../../../../projects/swimlane/ngx-datatable/src/lib/utils/math.ts"],"names":[],"mappings":"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","sourcesContent":["import { columnsByPin, columnsTotalWidth } from './column';\n\n/**\n * Calculates the Total Flex Grow\n */\nexport function getTotalFlexGrow(columns: any[]) {\n  let totalFlexGrow = 0;\n\n  for (const c of columns) {\n    totalFlexGrow += c.flexGrow || 0;\n  }\n\n  return totalFlexGrow;\n}\n\n/**\n * Adjusts the column widths.\n * Inspired by: https://github.com/facebook/fixed-data-table/blob/master/src/FixedDataTableWidthHelper.js\n */\nexport function adjustColumnWidths(allColumns: any, expectedWidth: any) {\n  const columnsWidth = columnsTotalWidth(allColumns);\n  const totalFlexGrow = getTotalFlexGrow(allColumns);\n  const colsByGroup = columnsByPin(allColumns);\n\n  if (columnsWidth !== expectedWidth) {\n    scaleColumns(colsByGroup, expectedWidth, totalFlexGrow);\n  }\n}\n\n/**\n * Resizes columns based on the flexGrow property, while respecting manually set widths\n */\nfunction scaleColumns(colsByGroup: any, maxWidth: any, totalFlexGrow: any) {\n  // calculate total width and flexgrow points for coulumns that can be resized\n  for (const attr in colsByGroup) {\n    for (const column of colsByGroup[attr]) {\n      if (!column.canAutoResize) {\n        maxWidth -= column.width;\n        totalFlexGrow -= column.flexGrow ? column.flexGrow : 0;\n      } else {\n        column.width = 0;\n      }\n    }\n  }\n\n  const hasMinWidth = {};\n  let remainingWidth = maxWidth;\n\n  // resize columns until no width is left to be distributed\n  do {\n    const widthPerFlexPoint = remainingWidth / totalFlexGrow;\n    remainingWidth = 0;\n\n    for (const attr in colsByGroup) {\n      for (const column of colsByGroup[attr]) {\n        // if the column can be resize and it hasn't reached its minimum width yet\n        if (column.canAutoResize && !hasMinWidth[column.prop]) {\n          const newWidth = column.width + column.flexGrow * widthPerFlexPoint;\n          if (column.minWidth !== undefined && newWidth < column.minWidth) {\n            remainingWidth += newWidth - column.minWidth;\n            column.width = column.minWidth;\n            hasMinWidth[column.prop] = true;\n          } else {\n            column.width = newWidth;\n          }\n        }\n      }\n    }\n  } while (remainingWidth !== 0);\n}\n\n/**\n * Forces the width of the columns to\n * distribute equally but overflowing when necessary\n *\n * Rules:\n *\n *  - If combined withs are less than the total width of the grid,\n *    proportion the widths given the min / max / normal widths to fill the width.\n *\n *  - If the combined widths, exceed the total width of the grid,\n *    use the standard widths.\n *\n *  - If a column is resized, it should always use that width\n *\n *  - The proportional widths should never fall below min size if specified.\n *\n *  - If the grid starts off small but then becomes greater than the size ( + / - )\n *    the width should use the original width; not the newly proportioned widths.\n */\nexport function forceFillColumnWidths(\n  allColumns: any[],\n  expectedWidth: number,\n  startIdx: number,\n  allowBleed: boolean,\n  defaultColWidth: number = 300\n) {\n  const columnsToResize = allColumns.slice(startIdx + 1, allColumns.length).filter(c => {\n    return c.canAutoResize !== false;\n  });\n\n  for (const column of columnsToResize) {\n    if (!column.$$oldWidth) {\n      column.$$oldWidth = column.width;\n    }\n  }\n\n  let additionWidthPerColumn = 0;\n  let exceedsWindow = false;\n  let contentWidth = getContentWidth(allColumns, defaultColWidth);\n  let remainingWidth = expectedWidth - contentWidth;\n  const columnsProcessed: any[] = [];\n  const remainingWidthLimit = 1; // when to stop\n\n  // This loop takes care of the\n  do {\n    additionWidthPerColumn = remainingWidth / columnsToResize.length;\n    exceedsWindow = contentWidth >= expectedWidth;\n\n    for (const column of columnsToResize) {\n      if (exceedsWindow && allowBleed) {\n        column.width = column.$$oldWidth || column.width || defaultColWidth;\n      } else {\n        const newSize = (column.width || defaultColWidth) + additionWidthPerColumn;\n\n        if (column.minWidth && newSize < column.minWidth) {\n          column.width = column.minWidth;\n          columnsProcessed.push(column);\n        } else if (column.maxWidth && newSize > column.maxWidth) {\n          column.width = column.maxWidth;\n          columnsProcessed.push(column);\n        } else {\n          column.width = newSize;\n        }\n      }\n\n      column.width = Math.max(0, column.width);\n    }\n\n    contentWidth = getContentWidth(allColumns);\n    remainingWidth = expectedWidth - contentWidth;\n    removeProcessedColumns(columnsToResize, columnsProcessed);\n  } while (remainingWidth > remainingWidthLimit && columnsToResize.length !== 0);\n}\n\n/**\n * Remove the processed columns from the current active columns.\n */\nfunction removeProcessedColumns(columnsToResize: any[], columnsProcessed: any[]) {\n  for (const column of columnsProcessed) {\n    const index = columnsToResize.indexOf(column);\n    columnsToResize.splice(index, 1);\n  }\n}\n\n/**\n * Gets the width of the columns\n */\nfunction getContentWidth(allColumns: any, defaultColWidth: number = 300): number {\n  let contentWidth = 0;\n\n  for (const column of allColumns) {\n    contentWidth += column.width || defaultColWidth;\n  }\n\n  return contentWidth;\n}\n"]}

package/esm2020/lib/utils/prefixes.mjs

@@ -0,0 +1,38 @@
+import { camelCase } from './camel-case';
+const cache = {};
+const testStyle = typeof document !== 'undefined' ? document.createElement('div').style : undefined;
+// Get Prefix
+// http://davidwalsh.name/vendor-prefix
+const prefix = (function () {
+    const styles = typeof window !== 'undefined' ? window.getComputedStyle(document.documentElement, '') : undefined;
+    const match = typeof styles !== 'undefined'
+        ? Array.prototype.slice
+            .call(styles)
+            .join('')
+            .match(/-(moz|webkit|ms)-/)
+        : null;
+    const pre = match !== null ? match[1] : undefined;
+    // tslint:disable-next-line: tsr-detect-non-literal-regexp
+    const dom = typeof pre !== 'undefined' ? 'WebKit|Moz|MS|O'.match(new RegExp('(' + pre + ')', 'i'))[1] : undefined;
+    return dom
+        ? {
+            dom,
+            lowercase: pre,
+            css: `-${pre}-`,
+            js: pre[0].toUpperCase() + pre.substr(1)
+        }
+        : undefined;
+})();
+export function getVendorPrefixedName(property) {
+    const name = camelCase(property);
+    if (!cache[name]) {
+        if (prefix !== undefined && testStyle[prefix.css + property] !== undefined) {
+            cache[name] = prefix.css + property;
+        }
+        else if (testStyle[property] !== undefined) {
+            cache[name] = property;
+        }
+    }
+    return cache[name];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/row-height-cache.mjs

@@ -0,0 +1,138 @@
+/**
+ * This object contains the cache of the various row heights that are present inside
+ * the data table.   Its based on Fenwick tree data structure that helps with
+ * querying sums that have time complexity of log n.
+ *
+ * Fenwick Tree Credits: http://petr-mitrichev.blogspot.com/2013/05/fenwick-tree-range-updates.html
+ * https://github.com/mikolalysenko/fenwick-tree
+ *
+ */
+export class RowHeightCache {
+    constructor() {
+        /**
+         * Tree Array stores the cumulative information of the row heights to perform efficient
+         * range queries and updates.  Currently the tree is initialized to the base row
+         * height instead of the detail row height.
+         */
+        this.treeArray = [];
+    }
+    /**
+     * Clear the Tree array.
+     */
+    clearCache() {
+        this.treeArray = [];
+    }
+    /**
+     * Initialize the Fenwick tree with row Heights.
+     *
+     * @param rows The array of rows which contain the expanded status.
+     * @param rowHeight The row height.
+     * @param detailRowHeight The detail row height.
+     */
+    initCache(details) {
+        const { rows, rowHeight, detailRowHeight, externalVirtual, rowCount, rowIndexes, rowExpansions } = details;
+        const isFn = typeof rowHeight === 'function';
+        const isDetailFn = typeof detailRowHeight === 'function';
+        if (!isFn && isNaN(rowHeight)) {
+            throw new Error(`Row Height cache initialization failed. Please ensure that 'rowHeight' is a
+        valid number or function value: (${rowHeight}) when 'scrollbarV' is enabled.`);
+        }
+        // Add this additional guard in case detailRowHeight is set to 'auto' as it wont work.
+        if (!isDetailFn && isNaN(detailRowHeight)) {
+            throw new Error(`Row Height cache initialization failed. Please ensure that 'detailRowHeight' is a
+        valid number or function value: (${detailRowHeight}) when 'scrollbarV' is enabled.`);
+        }
+        const n = externalVirtual ? rowCount : rows.length;
+        this.treeArray = new Array(n);
+        for (let i = 0; i < n; ++i) {
+            this.treeArray[i] = 0;
+        }
+        for (let i = 0; i < n; ++i) {
+            const row = rows[i];
+            let currentRowHeight = rowHeight;
+            if (isFn) {
+                currentRowHeight = rowHeight(row);
+            }
+            // Add the detail row height to the already expanded rows.
+            // This is useful for the table that goes through a filter or sort.
+            const expanded = rowExpansions.has(row);
+            if (row && expanded) {
+                if (isDetailFn) {
+                    const index = rowIndexes.get(row);
+                    currentRowHeight += detailRowHeight(row, index);
+                }
+                else {
+                    currentRowHeight += detailRowHeight;
+                }
+            }
+            this.update(i, currentRowHeight);
+        }
+    }
+    /**
+     * Given the ScrollY position i.e. sum, provide the rowIndex
+     * that is present in the current view port.  Below handles edge cases.
+     */
+    getRowIndex(scrollY) {
+        if (scrollY === 0)
+            return 0;
+        return this.calcRowIndex(scrollY);
+    }
+    /**
+     * When a row is expanded or rowHeight is changed, update the height.  This can
+     * be utilized in future when Angular Data table supports dynamic row heights.
+     */
+    update(atRowIndex, byRowHeight) {
+        if (!this.treeArray.length) {
+            throw new Error(`Update at index ${atRowIndex} with value ${byRowHeight} failed:
+        Row Height cache not initialized.`);
+        }
+        const n = this.treeArray.length;
+        atRowIndex |= 0;
+        while (atRowIndex < n) {
+            this.treeArray[atRowIndex] += byRowHeight;
+            atRowIndex |= atRowIndex + 1;
+        }
+    }
+    /**
+     * Range Sum query from 1 to the rowIndex
+     */
+    query(atIndex) {
+        if (!this.treeArray.length) {
+            throw new Error(`query at index ${atIndex} failed: Fenwick tree array not initialized.`);
+        }
+        let sum = 0;
+        atIndex |= 0;
+        while (atIndex >= 0) {
+            sum += this.treeArray[atIndex];
+            atIndex = (atIndex & (atIndex + 1)) - 1;
+        }
+        return sum;
+    }
+    /**
+     * Find the total height between 2 row indexes
+     */
+    queryBetween(atIndexA, atIndexB) {
+        return this.query(atIndexB) - this.query(atIndexA - 1);
+    }
+    /**
+     * Given the ScrollY position i.e. sum, provide the rowIndex
+     * that is present in the current view port.
+     */
+    calcRowIndex(sum) {
+        if (!this.treeArray.length)
+            return 0;
+        let pos = -1;
+        const dataLength = this.treeArray.length;
+        // Get the highest bit for the block size.
+        const highestBit = Math.pow(2, dataLength.toString(2).length - 1);
+        for (let blockSize = highestBit; blockSize !== 0; blockSize >>= 1) {
+            const nextPos = pos + blockSize;
+            if (nextPos < dataLength && sum >= this.treeArray[nextPos]) {
+                sum -= this.treeArray[nextPos];
+                pos = nextPos;
+            }
+        }
+        return pos + 1;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"row-height-cache.js","sourceRoot":"","sources":["../../../../../../projects/swimlane/ngx-datatable/src/lib/utils/row-height-cache.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This object contains the cache of the various row heights that are present inside\n * the data table.   Its based on Fenwick tree data structure that helps with\n * querying sums that have time complexity of log n.\n *\n * Fenwick Tree Credits: http://petr-mitrichev.blogspot.com/2013/05/fenwick-tree-range-updates.html\n * https://github.com/mikolalysenko/fenwick-tree\n *\n */\nexport class RowHeightCache {\n  /**\n   * Tree Array stores the cumulative information of the row heights to perform efficient\n   * range queries and updates.  Currently the tree is initialized to the base row\n   * height instead of the detail row height.\n   */\n  private treeArray: number[] = [];\n\n  /**\n   * Clear the Tree array.\n   */\n  clearCache(): void {\n    this.treeArray = [];\n  }\n\n  /**\n   * Initialize the Fenwick tree with row Heights.\n   *\n   * @param rows The array of rows which contain the expanded status.\n   * @param rowHeight The row height.\n   * @param detailRowHeight The detail row height.\n   */\n  initCache(details: any): void {\n    const { rows, rowHeight, detailRowHeight, externalVirtual, rowCount, rowIndexes, rowExpansions } = details;\n    const isFn = typeof rowHeight === 'function';\n    const isDetailFn = typeof detailRowHeight === 'function';\n\n    if (!isFn && isNaN(rowHeight)) {\n      throw new Error(`Row Height cache initialization failed. Please ensure that 'rowHeight' is a\n        valid number or function value: (${rowHeight}) when 'scrollbarV' is enabled.`);\n    }\n\n    // Add this additional guard in case detailRowHeight is set to 'auto' as it wont work.\n    if (!isDetailFn && isNaN(detailRowHeight)) {\n      throw new Error(`Row Height cache initialization failed. Please ensure that 'detailRowHeight' is a\n        valid number or function value: (${detailRowHeight}) when 'scrollbarV' is enabled.`);\n    }\n\n    const n = externalVirtual ? rowCount : rows.length;\n    this.treeArray = new Array(n);\n\n    for (let i = 0; i < n; ++i) {\n      this.treeArray[i] = 0;\n    }\n\n    for (let i = 0; i < n; ++i) {\n      const row = rows[i];\n      let currentRowHeight = rowHeight;\n      if (isFn) {\n        currentRowHeight = rowHeight(row);\n      }\n\n      // Add the detail row height to the already expanded rows.\n      // This is useful for the table that goes through a filter or sort.\n      const expanded = rowExpansions.has(row);\n      if (row && expanded) {\n        if (isDetailFn) {\n          const index = rowIndexes.get(row);\n          currentRowHeight += detailRowHeight(row, index);\n        } else {\n          currentRowHeight += detailRowHeight;\n        }\n      }\n\n      this.update(i, currentRowHeight);\n    }\n  }\n\n  /**\n   * Given the ScrollY position i.e. sum, provide the rowIndex\n   * that is present in the current view port.  Below handles edge cases.\n   */\n  getRowIndex(scrollY: number): number {\n    if (scrollY === 0) return 0;\n    return this.calcRowIndex(scrollY);\n  }\n\n  /**\n   * When a row is expanded or rowHeight is changed, update the height.  This can\n   * be utilized in future when Angular Data table supports dynamic row heights.\n   */\n  update(atRowIndex: number, byRowHeight: number): void {\n    if (!this.treeArray.length) {\n      throw new Error(`Update at index ${atRowIndex} with value ${byRowHeight} failed:\n        Row Height cache not initialized.`);\n    }\n\n    const n = this.treeArray.length;\n    atRowIndex |= 0;\n\n    while (atRowIndex < n) {\n      this.treeArray[atRowIndex] += byRowHeight;\n      atRowIndex |= atRowIndex + 1;\n    }\n  }\n\n  /**\n   * Range Sum query from 1 to the rowIndex\n   */\n  query(atIndex: number): number {\n    if (!this.treeArray.length) {\n      throw new Error(`query at index ${atIndex} failed: Fenwick tree array not initialized.`);\n    }\n\n    let sum = 0;\n    atIndex |= 0;\n\n    while (atIndex >= 0) {\n      sum += this.treeArray[atIndex];\n      atIndex = (atIndex & (atIndex + 1)) - 1;\n    }\n\n    return sum;\n  }\n\n  /**\n   * Find the total height between 2 row indexes\n   */\n  queryBetween(atIndexA: number, atIndexB: number): number {\n    return this.query(atIndexB) - this.query(atIndexA - 1);\n  }\n\n  /**\n   * Given the ScrollY position i.e. sum, provide the rowIndex\n   * that is present in the current view port.\n   */\n  private calcRowIndex(sum: number): number {\n    if (!this.treeArray.length) return 0;\n\n    let pos = -1;\n    const dataLength = this.treeArray.length;\n\n    // Get the highest bit for the block size.\n    const highestBit = Math.pow(2, dataLength.toString(2).length - 1);\n\n    for (let blockSize = highestBit; blockSize !== 0; blockSize >>= 1) {\n      const nextPos = pos + blockSize;\n      if (nextPos < dataLength && sum >= this.treeArray[nextPos]) {\n        sum -= this.treeArray[nextPos];\n        pos = nextPos;\n      }\n    }\n\n    return pos + 1;\n  }\n}\n"]}

package/esm2020/lib/utils/selection.mjs

@@ -0,0 +1,40 @@
+export function selectRows(selected, row, comparefn) {
+    const selectedIndex = comparefn(row, selected);
+    if (selectedIndex > -1) {
+        selected.splice(selectedIndex, 1);
+    }
+    else {
+        selected.push(row);
+    }
+    return selected;
+}
+export function selectRowsBetween(selected, rows, index, prevIndex, comparefn) {
+    const reverse = index < prevIndex;
+    for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        const greater = i >= prevIndex && i <= index;
+        const lesser = i <= prevIndex && i >= index;
+        let range = { start: 0, end: 0 };
+        if (reverse) {
+            range = {
+                start: index,
+                end: prevIndex
+            };
+        }
+        else {
+            range = {
+                start: prevIndex,
+                end: index + 1
+            };
+        }
+        if ((reverse && lesser) || (!reverse && greater)) {
+            // if in the positive range to be added to `selected`, and
+            // not already in the selected array, add it
+            if (i >= range.start && i <= range.end) {
+                selected.push(row);
+            }
+        }
+    }
+    return selected;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/sort.mjs

@@ -0,0 +1,127 @@
+import { getterForProp } from './column-prop-getters';
+import { SortType } from '../types/sort.type';
+import { SortDirection } from '../types/sort-direction.type';
+/**
+ * Gets the next sort direction
+ */
+export function nextSortDir(sortType, current) {
+    if (sortType === SortType.single) {
+        if (current === SortDirection.asc) {
+            return SortDirection.desc;
+        }
+        else {
+            return SortDirection.asc;
+        }
+    }
+    else {
+        if (!current) {
+            return SortDirection.asc;
+        }
+        else if (current === SortDirection.asc) {
+            return SortDirection.desc;
+        }
+        else if (current === SortDirection.desc) {
+            return undefined;
+        }
+        // avoid TS7030: Not all code paths return a value.
+        return undefined;
+    }
+}
+/**
+ * Adapted from fueld-ui on 6/216
+ * https://github.com/FuelInteractive/fuel-ui/tree/master/src/pipes/OrderBy
+ */
+export function orderByComparator(a, b) {
+    if (a === null || typeof a === 'undefined')
+        a = 0;
+    if (b === null || typeof b === 'undefined')
+        b = 0;
+    if (a instanceof Date && b instanceof Date) {
+        if (a < b)
+            return -1;
+        if (a > b)
+            return 1;
+    }
+    else if (isNaN(parseFloat(a)) || !isFinite(a) || isNaN(parseFloat(b)) || !isFinite(b)) {
+        // Convert to string in case of a=0 or b=0
+        a = String(a);
+        b = String(b);
+        // Isn't a number so lowercase the string to properly compare
+        if (a.toLowerCase() < b.toLowerCase())
+            return -1;
+        if (a.toLowerCase() > b.toLowerCase())
+            return 1;
+    }
+    else {
+        // Parse strings as numbers to compare properly
+        if (parseFloat(a) < parseFloat(b))
+            return -1;
+        if (parseFloat(a) > parseFloat(b))
+            return 1;
+    }
+    // equal each other
+    return 0;
+}
+/**
+ * creates a shallow copy of the `rows` input and returns the sorted copy. this function
+ * does not sort the `rows` argument in place
+ */
+export function sortRows(rows, columns, dirs) {
+    if (!rows)
+        return [];
+    if (!dirs || !dirs.length || !columns)
+        return [...rows];
+    /**
+     * record the row ordering of results from prior sort operations (if applicable)
+     * this is necessary to guarantee stable sorting behavior
+     */
+    const rowToIndexMap = new Map();
+    rows.forEach((row, index) => rowToIndexMap.set(row, index));
+    const temp = [...rows];
+    const cols = columns.reduce((obj, col) => {
+        if (col.comparator && typeof col.comparator === 'function') {
+            obj[col.prop] = col.comparator;
+        }
+        return obj;
+    }, {});
+    // cache valueGetter and compareFn so that they
+    // do not need to be looked-up in the sort function body
+    const cachedDirs = dirs.map(dir => {
+        const prop = dir.prop;
+        return {
+            prop,
+            dir: dir.dir,
+            valueGetter: getterForProp(prop),
+            compareFn: cols[prop] || orderByComparator
+        };
+    });
+    return temp.sort(function (rowA, rowB) {
+        for (const cachedDir of cachedDirs) {
+            // Get property and valuegetters for column to be sorted
+            const { prop, valueGetter } = cachedDir;
+            // Get A and B cell values from rows based on properties of the columns
+            const propA = valueGetter(rowA, prop);
+            const propB = valueGetter(rowB, prop);
+            // Compare function gets five parameters:
+            // Two cell values to be compared as propA and propB
+            // Two rows corresponding to the cells as rowA and rowB
+            // Direction of the sort for this column as SortDirection
+            // Compare can be a standard JS comparison function (a,b) => -1|0|1
+            // as additional parameters are silently ignored. The whole row and sort
+            // direction enable more complex sort logic.
+            const comparison = cachedDir.dir !== SortDirection.desc
+                ? cachedDir.compareFn(propA, propB, rowA, rowB, cachedDir.dir)
+                : -cachedDir.compareFn(propA, propB, rowA, rowB, cachedDir.dir);
+            // Don't return 0 yet in case of needing to sort by next property
+            if (comparison !== 0)
+                return comparison;
+        }
+        if (!(rowToIndexMap.has(rowA) && rowToIndexMap.has(rowB)))
+            return 0;
+        /**
+         * all else being equal, preserve original order of the rows (stable sort)
+         */
+        return rowToIndexMap.get(rowA) < rowToIndexMap.get(rowB) ? -1 : 1;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sort.js","sourceRoot":"","sources":["../../../../../../projects/swimlane/ngx-datatable/src/lib/utils/sort.ts"],"names":[],"mappings":"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","sourcesContent":["import { getterForProp } from './column-prop-getters';\nimport { SortType } from '../types/sort.type';\nimport { SortDirection } from '../types/sort-direction.type';\nimport { SortPropDir } from '../types/sort-prop-dir.type';\n/**\n * Gets the next sort direction\n */\nexport function nextSortDir(sortType: SortType, current: SortDirection): SortDirection | undefined {\n  if (sortType === SortType.single) {\n    if (current === SortDirection.asc) {\n      return SortDirection.desc;\n    } else {\n      return SortDirection.asc;\n    }\n  } else {\n    if (!current) {\n      return SortDirection.asc;\n    } else if (current === SortDirection.asc) {\n      return SortDirection.desc;\n    } else if (current === SortDirection.desc) {\n      return undefined;\n    }\n    // avoid TS7030: Not all code paths return a value.\n    return undefined;\n  }\n}\n\n/**\n * Adapted from fueld-ui on 6/216\n * https://github.com/FuelInteractive/fuel-ui/tree/master/src/pipes/OrderBy\n */\nexport function orderByComparator(a: any, b: any): number {\n  if (a === null || typeof a === 'undefined') a = 0;\n  if (b === null || typeof b === 'undefined') b = 0;\n  if (a instanceof Date && b instanceof Date) {\n    if (a < b) return -1;\n    if (a > b) return 1;\n  } else if (isNaN(parseFloat(a)) || !isFinite(a) || isNaN(parseFloat(b)) || !isFinite(b)) {\n    // Convert to string in case of a=0 or b=0\n    a = String(a);\n    b = String(b);\n    // Isn't a number so lowercase the string to properly compare\n    if (a.toLowerCase() < b.toLowerCase()) return -1;\n    if (a.toLowerCase() > b.toLowerCase()) return 1;\n  } else {\n    // Parse strings as numbers to compare properly\n    if (parseFloat(a) < parseFloat(b)) return -1;\n    if (parseFloat(a) > parseFloat(b)) return 1;\n  }\n\n  // equal each other\n  return 0;\n}\n\n/**\n * creates a shallow copy of the `rows` input and returns the sorted copy. this function\n * does not sort the `rows` argument in place\n */\nexport function sortRows(rows: any[], columns: any[], dirs: SortPropDir[]): any[] {\n  if (!rows) return [];\n  if (!dirs || !dirs.length || !columns) return [...rows];\n\n  /**\n   * record the row ordering of results from prior sort operations (if applicable)\n   * this is necessary to guarantee stable sorting behavior\n   */\n  const rowToIndexMap = new Map<any, number>();\n  rows.forEach((row, index) => rowToIndexMap.set(row, index));\n\n  const temp = [...rows];\n  const cols = columns.reduce((obj, col) => {\n    if (col.comparator && typeof col.comparator === 'function') {\n      obj[col.prop] = col.comparator;\n    }\n    return obj;\n  }, {});\n\n  // cache valueGetter and compareFn so that they\n  // do not need to be looked-up in the sort function body\n  const cachedDirs = dirs.map(dir => {\n    const prop = dir.prop;\n    return {\n      prop,\n      dir: dir.dir,\n      valueGetter: getterForProp(prop),\n      compareFn: cols[prop] || orderByComparator\n    };\n  });\n\n  return temp.sort(function (rowA: any, rowB: any) {\n    for (const cachedDir of cachedDirs) {\n      // Get property and valuegetters for column to be sorted\n      const { prop, valueGetter } = cachedDir;\n      // Get A and B cell values from rows based on properties of the columns\n      const propA = valueGetter(rowA, prop);\n      const propB = valueGetter(rowB, prop);\n\n      // Compare function gets five parameters:\n      // Two cell values to be compared as propA and propB\n      // Two rows corresponding to the cells as rowA and rowB\n      // Direction of the sort for this column as SortDirection\n      // Compare can be a standard JS comparison function (a,b) => -1|0|1\n      // as additional parameters are silently ignored. The whole row and sort\n      // direction enable more complex sort logic.\n      const comparison =\n        cachedDir.dir !== SortDirection.desc\n          ? cachedDir.compareFn(propA, propB, rowA, rowB, cachedDir.dir)\n          : -cachedDir.compareFn(propA, propB, rowA, rowB, cachedDir.dir);\n\n      // Don't return 0 yet in case of needing to sort by next property\n      if (comparison !== 0) return comparison;\n    }\n\n    if (!(rowToIndexMap.has(rowA) && rowToIndexMap.has(rowB))) return 0;\n\n    /**\n     * all else being equal, preserve original order of the rows (stable sort)\n     */\n    return rowToIndexMap.get(rowA) < rowToIndexMap.get(rowB) ? -1 : 1;\n  });\n}\n"]}

package/esm2020/lib/utils/throttle.mjs

@@ -0,0 +1,60 @@
+/**
+ * Throttle a function
+ */
+export function throttle(func, wait, options) {
+    options = options || {};
+    let context;
+    let args;
+    let result;
+    let timeout = null;
+    let previous = 0;
+    function later() {
+        previous = options.leading === false ? 0 : +new Date();
+        timeout = null;
+        result = func.apply(context, args);
+    }
+    return function () {
+        const now = +new Date();
+        if (!previous && options.leading === false) {
+            previous = now;
+        }
+        const remaining = wait - (now - previous);
+        context = this;
+        args = arguments;
+        if (remaining <= 0) {
+            clearTimeout(timeout);
+            timeout = null;
+            previous = now;
+            result = func.apply(context, args);
+        }
+        else if (!timeout && options.trailing !== false) {
+            timeout = setTimeout(later, remaining);
+        }
+        return result;
+    };
+}
+/**
+ * Throttle decorator
+ *
+ *  class MyClass {
+ *    throttleable(10)
+ *    myFn() { ... }
+ *  }
+ */
+export function throttleable(duration, options) {
+    return function innerDecorator(target, key, descriptor) {
+        return {
+            configurable: true,
+            enumerable: descriptor.enumerable,
+            get: function getter() {
+                Object.defineProperty(this, key, {
+                    configurable: true,
+                    enumerable: descriptor.enumerable,
+                    value: throttle(descriptor.value, duration, options)
+                });
+                return this[key];
+            }
+        };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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