@internetarchive/ads-table 0.0.6 → 0.0.8

package/dist/index.js

@@ -510,6 +510,10 @@ class AdsTable extends s {
     }
     get sortedRows() {
         var _a;
+        // if sorting has been done already, return the rows as-is.
+        if (this.selectedColumn.preSorted) {
+            return this.rows;
+        }
         const sortByPrimaryKey = this.getSortFunction(this.sortColumnDataType, this.sortDirection);
         const sortBySecondaryKey = this.getSortFunction(this.secondarySortDataType, ((_a = this.secondarySortDataType) === null || _a === void 0 ? void 0 : _a.defaultSortDirection) || this.sortDirection);
         return this.rows.sort((rowA, rowB) => {
@@ -524,9 +528,14 @@ class AdsTable extends s {
             }
         });
     }
+    // rows highlighted by user
     get selectedRows() {
         return this.selectedRowIds.map((id) => this.rowsById[id]).filter((x) => x);
     }
+    // the column you are currently sorting by
+    get selectedColumn() {
+        return this.columnByKey[this.sortKey];
+    }
     // handler for when a user clicks on a column header
     onColumnClick(column, defaultSortDirection = this
         .defaultSortDirection) {
@@ -541,15 +550,20 @@ class AdsTable extends s {
             this.sortDirection =
                 column.dataType.defaultSortDirection || defaultSortDirection;
         }
+        this.emitEvent("column-click", {
+            column,
+            sortKey: this.sortKey,
+            sortDirection: this.sortDirection,
+        });
     }
     // a map of column keys to their respective data types so we don't have to call .find everywhere
-    get columnKeyToDataType() {
-        return Object.fromEntries(this.columns.map((col) => [col.key, col.dataType]));
+    get columnByKey() {
+        return Object.fromEntries(this.columns.map((col) => [col.key, col]));
     }
     // data type of the currently sorted column
     get sortColumnDataType() {
         if (this.sortKey) {
-            return this.columnKeyToDataType[this.sortKey];
+            return this.columnByKey[this.sortKey].dataType;
         }
         else {
             return undefined;
@@ -558,7 +572,7 @@ class AdsTable extends s {
     // data type of the secondary sort column
     get secondarySortDataType() {
         if (this.secondarySortKey) {
-            return this.columnKeyToDataType[this.secondarySortKey];
+            return this.columnByKey[this.secondarySortKey].dataType;
         }
         else {
             return undefined;
@@ -899,41 +913,13 @@ const NumberDataType = {
     defaultSortDirection: "descending",
 };
 // for comparing and formatting dates - Note, date formatting operation
-// is considerably slower than any other ones here, so we keep an
-// internal rolling cache of 1k values since date values in general
-// are not liable to change often, and tables should not have more
-// items than this.
-class DateFormatCache {
-    // get a formatted date string from the cache
-    static get(date) {
-        return DateFormatCache.cache[date.toString()];
-    }
-    // note - date references always serialize to identical keys, probably
-    // using their internal millisecond values.
-    static getOrAdd(date) {
-        const cachedValue = DateFormatCache.get(date) || formatDate(date);
-        DateFormatCache.pruneCache();
-        DateFormatCache.cache[date.toString()] = cachedValue; // set idempotently
-        return cachedValue;
-    }
-    static pruneCache() {
-        const cacheKeys = Object.keys(DateFormatCache.cache);
-        if (cacheKeys.length >= DateFormatCache.MAX_CACHE_SIZE) {
-            const randomDeleteIndex = Math.floor(Math.random() * cacheKeys.length);
-            const deleteKey = cacheKeys[randomDeleteIndex];
-            console.log("deleting from cache", cacheKeys.length, deleteKey, DateFormatCache.cache);
-            delete DateFormatCache.cache[deleteKey];
-        }
-    }
-}
-DateFormatCache.MAX_CACHE_SIZE = 1000;
-DateFormatCache.cache = {};
+// is SLOW relative to some other operations.
 const DateDataType = {
     compare: (a, b) => {
         var _a;
         return ((_a = NumberDataType.compare) === null || _a === void 0 ? void 0 : _a.call(NumberDataType, a.getTime(), b.getTime())) || 0;
     },
-    format: (date) => DateFormatCache.getOrAdd(date),
+    format: (date) => formatDate(date),
     defaultSortDirection: "descending",
 };
 // for comparing and formatting numbers that represent bytes