@triptyk/ember-yeti-table 3.0.0

package/src/themes/default-theme.js

@@ -0,0 +1,53 @@
+// BEGIN-SNIPPET default-theme.js
+export default {
+  // applied to the <table> element
+  table: 'yeti-table',
+  // applied to any <tr>, wether it is from the header, body or footer
+  row: '',
+
+  // applied to the <thead> element
+  thead: '',
+  // applied to <tr> rows inside the <thead> element
+  theadRow: '',
+  // applied to <th> cells inside the <thead> element
+  theadCell: '',
+
+  // applied to the <tbody> element
+  tbody: '',
+  // applied to <tr> rows inside the <tbody> element
+  tbodyRow: '',
+  // applied to <td> cells inside the <thead> element
+  tbodyCell: '',
+
+  // applied to the <tfoot> element
+  tfoot: '',
+  // applied to <tr> rows inside the <tfoot> element
+  tfootRow: '',
+  // applied to <td> cells inside the <tfoot> element
+  tfootCell: '',
+
+  sorting: {
+    // applied to <th> header cells when column is sortable
+    columnSortable: 'yeti-table-sortable',
+    // applied to <th> header cells when column is currently sorted
+    columnSorted: 'yeti-table-sorted',
+    // applied to <th> header cells when column is currently sorted ascending
+    columnSortedAsc: 'yeti-table-sorted-asc',
+    // applied to <th> header cells when column is currently sorted descending
+    columnSortedDesc: 'yeti-table-sorted-desc',
+  },
+
+  pagination: {
+    // applied to the pagination controls container
+    controls: 'yeti-table-pagination-controls',
+    // applied to the pagination information element
+    info: 'yeti-table-pagination-controls-page-info',
+    // applied to the pageSize select element
+    pageSize: 'yeti-table-pagination-controls-page-size',
+    // applied to the next button
+    next: 'yeti-table-pagination-controls-next',
+    // applied to the previous button
+    previous: 'yeti-table-pagination-controls-previous',
+  },
+};
+// END-SNIPPET

package/src/utils/create-regex.js

@@ -0,0 +1,65 @@
+import { isBlank } from '@ember/utils';
+
+const ESCAPE_REGEX = new RegExp(
+  '(\\' +
+    [
+      '/',
+      '.',
+      '*',
+      '+',
+      '?',
+      '|',
+      '(',
+      ')',
+      '[',
+      ']',
+      '{',
+      '}',
+      '\\',
+      '$',
+      '^',
+      '-',
+    ].join('|\\') +
+    ')',
+  'g',
+);
+
+function escapeRegex(val) {
+  return val.replace(ESCAPE_REGEX, '\\$1');
+}
+
+export default function createRegex(
+  search,
+  regex = false,
+  smart = true,
+  caseInsensitive = true,
+) {
+  if (isBlank(search)) {
+    return;
+  }
+
+  search = regex ? search : escapeRegex(search);
+
+  if (smart) {
+    /* For smart filtering we want to allow the search to work regardless of
+     * word order. We also want double quoted text to be preserved, so word
+     * order is important - a la google. So this is what we want to
+     * generate:
+     *
+     * ^(?=.*?\bone\b)(?=.*?\btwo three\b)(?=.*?\bfour\b).*$
+     */
+    let words = search.match(/"[^"]+"|[^ ]+/g) || [''];
+    let a = words.map((word) => {
+      if (word.charAt(0) === '"') {
+        let m = word.match(/^"(.*)"$/);
+        word = m ? m[1] : word;
+      }
+
+      return word.replace('"', '');
+    });
+
+    search = `^(?=.*?${a.join(')(?=.*?')}).*$`;
+  }
+
+  return new RegExp(search, caseInsensitive ? 'i' : '');
+}

package/src/utils/filtering-utils.js

@@ -0,0 +1,75 @@
+import { isEmpty } from '@ember/utils';
+import { get } from '@ember/object';
+
+import createRegex from './create-regex.js';
+
+function createColumnFilters(columns) {
+  let searcheableColumns = columns.filter((c) => {
+    return !isEmpty(c.filter) || !isEmpty(c.filterFunction);
+  });
+
+  return searcheableColumns.map((c) => {
+    let regex = createRegex(c.filter);
+
+    return (row) => {
+      let value = get(row, c.prop);
+      let passesRegex = true;
+
+      if (!isEmpty(c.filter)) {
+        passesRegex = regex.test(value);
+      }
+
+      let passesCustom = true;
+
+      if (!isEmpty(c.filterFunction)) {
+        passesCustom = c.filterFunction(value, c.filterUsing);
+      }
+
+      return passesRegex && passesCustom;
+    };
+  });
+}
+
+export default function filterData(
+  data,
+  columns,
+  globalFilter,
+  filterFunction,
+  filterUsing,
+) {
+  if (isEmpty(data)) {
+    return [];
+  }
+
+  if (isEmpty(columns)) {
+    // bail out if there are no columns to filter
+    return data;
+  }
+
+  let globalRegex = createRegex(globalFilter, false, true, true);
+
+  let columnFilters = createColumnFilters(columns);
+
+  return data.filter((row) => {
+    let passesGeneral = true;
+
+    if (!isEmpty(globalRegex)) {
+      passesGeneral = columns.some((c) => {
+        return globalRegex.test(get(row, c.prop));
+      });
+    }
+
+    let passesColumn = true;
+
+    if (!isEmpty(columnFilters)) {
+      passesColumn = columnFilters.every((fn) => fn(row));
+    }
+
+    let passesCustom = true;
+    if (!isEmpty(filterFunction)) {
+      passesColumn = filterFunction(row, filterUsing);
+    }
+
+    return passesGeneral && passesColumn && passesCustom;
+  });
+}

package/src/utils/sorting-utils.js

@@ -0,0 +1,108 @@
+import { get } from '@ember/object';
+import { compare, isNone } from '@ember/utils';
+
+function merge(left, right, comparator) {
+  let mergedArray = [];
+  let leftIndex = 0;
+  let rightIndex = 0;
+
+  while (leftIndex < left.length && rightIndex < right.length) {
+    let comparison = comparator(left[leftIndex], right[rightIndex]);
+
+    if (comparison <= 0) {
+      mergedArray.push(left[leftIndex]);
+      leftIndex++;
+    } else {
+      mergedArray.push(right[rightIndex]);
+      rightIndex++;
+    }
+  }
+
+  if (leftIndex < left.length) {
+    mergedArray.splice(mergedArray.length, 0, ...left.slice(leftIndex));
+  }
+
+  if (rightIndex < right.length) {
+    mergedArray.splice(mergedArray.length, 0, ...right.slice(rightIndex));
+  }
+
+  return mergedArray;
+}
+
+/**
+ * An implementation of the standard merge sort algorithm.
+ *
+ * This is necessary because we need a stable sorting algorithm that accepts
+ * a general comparator. The built in sort function and Ember's sort functions
+ * are not stable, and `_.sortBy` doesn't take a general comparator. Ideally
+ * lodash would add a `_.sort` function whose API would mimic this function's.
+ *
+ * @function
+ * @param {Array} array The array to be sorted
+ * @param {Comparator} comparator The comparator function to compare elements with.
+ * @return {Array} A sorted array
+ */
+export function mergeSort(array, comparator = compare) {
+  if (array.length <= 1) {
+    return array;
+  }
+
+  let middleIndex = Math.floor(array.length / 2);
+  let leftArray = mergeSort(array.slice(0, middleIndex), comparator);
+  let rightArray = mergeSort(array.slice(middleIndex), comparator);
+
+  return merge(leftArray, rightArray, comparator);
+}
+
+export function sortMultiple(itemA, itemB, sorts, compare) {
+  let compareValue;
+
+  for (let { prop, direction } of sorts) {
+    let valueA = get(itemA, prop);
+    let valueB = get(itemB, prop);
+
+    compareValue =
+      direction === 'asc' ? compare(valueA, valueB) : -compare(valueA, valueB);
+
+    if (compareValue !== 0) {
+      break;
+    }
+  }
+
+  return compareValue;
+}
+
+function isExactlyNaN(value) {
+  return typeof value === 'number' && isNaN(value);
+}
+
+function isEmpty(value) {
+  return isNone(value) || isExactlyNaN(value);
+}
+
+function orderEmptyValues(itemA, itemB) {
+  let aIsEmpty = isEmpty(itemA);
+  let bIsEmpty = isEmpty(itemB);
+
+  if (aIsEmpty && !bIsEmpty) {
+    return -1;
+  } else if (bIsEmpty && !aIsEmpty) {
+    return 1;
+  } else if (isNone(itemA) && isExactlyNaN(itemB)) {
+    return -1;
+  } else if (isExactlyNaN(itemA) && isNone(itemB)) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+export function compareValues(itemA, itemB) {
+  if (isEmpty(itemA) || isEmpty(itemB)) {
+    return orderEmptyValues(itemA, itemB);
+  }
+
+  return compare(itemA, itemB);
+}
+
+export default compareValues;