@cloudflare/realtimekit-ui 1.1.0-staging.4 → 1.1.0-staging.6

package/dist/collection/components/rtk-paginated-list/rtk-paginated-list.js

@@ -1,3 +1,31 @@
+/**
+ * HOW INFINITE SCROLL WORKS:
+ *
+ * We use intersectionObserver to scroll up.
+ * We use scrollEnd listener to scroll down.
+ *
+ * Why?
+ * intersectionObserver doesn't work reliably for 2 way scrolling but has great ux,
+ * so we use it to smoothly scroll up.
+ *
+ * We have empty divs at the top and bottom ($topRef, $bottomRef)
+ * which act as triggers to tell that we have reached the top or end of our messages and need to fetch new messages,
+ *
+ * When scrolling up, we can't remove pages as intersectionObserver relies on
+ * the index of dom elements to work properly.
+ * So instead, we fetch older messages and push them to the end of the 2d array
+ * if length exceeds pagesAllowed, we free up the pages and keep the first empty index in memory (firstEmptyIndex).
+ *
+ * For scrolling down, when scroll ends we see if the bottomRef is in view.
+ * If yes, we fetch the new page and insert it at the firstEmptyIndex.
+ * We update timestamps & firstEmptyIndex, then we rerender.
+ *
+ * If we have exceeded our page allowance we delete old pages.
+ *
+ * In this case deleting pages is okay as we are not relying on the index of dom elements to detect page end.
+ *
+ * This also simplifies the code because when a user scrolls up we do not need to manage a lastEmptyIndex.
+ */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -9,277 +37,275 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Host, h, writeTask } from "@stencil/core";
-import { debounce } from "lodash-es";
 import { defaultIconPack } from "../../lib/icons";
 import { useLanguage } from "../../lib/lang";
 import { SyncWithStore } from "../../utils/sync-with-store";
-import { smoothScrollToBottom } from "../../utils/scroll";
+import { debounce } from "lodash-es";
 export class RtkPaginatedList {
     constructor() {
+        /**
+         * when scrolling up, we can't remove pages as intersectionObserver relies on
+         * the index of dom elements to stay stable.
+         * So, instead we free up the pages and keep the last empty index in memory.
+         */
+        this.firstEmptyIndex = -1;
+        this.maxTS = 0;
+        // the length of pages will always be pageSize + 2
+        this.pages = [];
+        /** label to show when empty */
+        this.emptyListLabel = null;
+        this.rerenderBoolean = false;
+        this.showEmptyListLabel = false;
         /** Icon pack */
         this.iconPack = defaultIconPack;
         /** Language */
         this.t = useLanguage();
-        /** label to show when empty */
-        this.emptyListLabel = null;
         this.isLoading = false;
         this.isLoadingTop = false;
         this.isLoadingBottom = false;
-        this.hasMoreDataAtTop = false;
-        this.rerenderBoolean = false;
-        /**
-         * This gets disabled when the user scrolls up and the bottom node
-         * is not visible anymore.
-         */
-        this.shouldRenderNewNodes = true;
         /**
-         * This gets disabled when the user scrolls up and the bottom node
-         * is not visible anymore.
-         */
-        this.hasNewNodesToRender = false;
-        this.showEmptyListLabel = false;
-        /**
-         * This is a private variable not a state
-         * since we want to debounce rerenders
-         *
-         * A list of pages where each page contains a number of Nodes
-         * [
-         *  [Node 1, Node 2, Node 3.... Node N],
-         *  [Node 1, Node 2, Node 3.... Node N],
-         * ]
-         */
-        this.pagesToRender = [[]];
-        this.currentTime = () => {
-            return new Date().getTime();
-        };
+         * Even when auto scroll is enabled, we only want to scroll if a new realtime message has arrived.
+         * This variable tells us if we should respect auto scroll after a new page has been loaded.
+         * It is also used by the scroll to bottom button.
+         *  */
+        this.shouldScrollToBottom = false;
+        /** UI Indicator for the "scroll to bottom" button.
+         * Toggles on when a new node is added and autoscroll is disabled.
+         * Toggles off when all nodes are loaded */
+        this.showNewMessagesCTR = false;
         this.observe = (el) => {
             if (!el)
                 return;
             this.intersectionObserver.observe(el);
         };
+        this.isAtBottom = () => {
+            const rect = this.$bottomRef.getBoundingClientRect();
+            return rect.top >= 0 && rect.bottom <= window.innerHeight;
+        };
     }
     /**
-     * On a new node created
+     * Adds a new node to the beginning of the paginated list
+     * @param {DataNode} node - The data node to add to the beginning of the list
      */
     async onNewNode(node) {
-        if (!this.shouldRenderNewNodes) {
-            this.hasNewNodesToRender = true;
-            return;
+        // Always update the maxTS. New messages will load on scroll till the end cursor (newTS) reaches this value.
+        this.maxTS = Math.max(this.maxTS, node.timeMs);
+        // if we are at the bottom of the page
+        if (this.firstEmptyIndex === -1) {
+            // if there are no pages, load the first page
+            if (this.pages.length < 1) {
+                // update old timer to 1ms ahead of the latest message as we subtract this value to avoid loading duplicate messages when scrolling
+                this.oldTS = node.timeMs + 1;
+                this.loadPrevPage();
+            }
+            else {
+                // append messages to the page if page has not reached full capacity
+                if (this.pages[0].length < this.pageSize) {
+                    this.pages[0].unshift(node);
+                    this.newTS = node.timeMs;
+                    this.rerender();
+                }
+                else {
+                    // if page is at full capacity, load next page
+                    this.loadNextPage();
+                }
+            }
         }
-        this.addNodeToRender(node, false);
-        this.rerender();
-    }
-    /**
-     * On node deleted
-     */
-    async onNodeDelete(key) {
-        const oldLength = this.pagesToRender.flat().length;
-        this.pagesToRender = this.pagesToRender.map((page) => page.filter((item) => item.id !== key));
-        if (oldLength !== this.pagesToRender.flat().length) {
-            this.rerender();
+        // If autoscroll is enabled, this method will scroll to the bottom
+        if (this.autoScroll) {
+            this.shouldScrollToBottom = true;
+            this.scrollToBottom();
+        }
+        else {
+            this.showNewMessagesCTR = true;
         }
     }
+    // this method is called recursively based on shouldScrollToBottom (see scrollEnd listener)
+    scrollToBottom() {
+        this.$bottomRef.scrollIntoView({ behavior: 'smooth' });
+    }
     /**
-     * On node updated
-     */
-    async onNodeUpdate(key, newItem) {
-        let shouldRerender = false;
-        this.pagesToRender = this.pagesToRender.map((page) => page.map((item) => {
-            if (item.id === key) {
-                shouldRerender = true;
-                return newItem;
+     * Deletes a node anywhere from the list
+     * @param {string} id - The id of the node to delete
+     * */
+    async onNodeDelete(id) {
+        // Iterate only over pages that have content (not empty)
+        for (let i = this.pages.length - 1; i > this.firstEmptyIndex; i--) {
+            const index = this.pages[i].findIndex((node) => node.id === id);
+            // message in view
+            if (index !== -1) {
+                // delete message
+                this.pages[i].splice(index, 1);
+                // if we are on the first page and it's now empty, we need to go back to initial state
+                if (i === 0 && this.pages[i].length === 0) {
+                    this.pages.shift();
+                    this.firstEmptyIndex = -1;
+                }
+                else if (i === this.firstEmptyIndex + 1) {
+                    //  if newest page is empty, update first empty index
+                    if (this.pages[i].length === 0)
+                        this.firstEmptyIndex++;
+                    // update timestamp, first empty index could be -1, so we need to cap it at 0
+                    this.newTS = this.pages[Math.max(this.firstEmptyIndex, 0)][0].timeMs;
+                }
+                else if (i === this.firstEmptyIndex + this.pagesAllowed) {
+                    //  if oldest page is empty, remove it
+                    if (this.pages[i].length === 0)
+                        this.pages.pop();
+                    // update timestamp
+                    const lastPage = this.pages[this.firstEmptyIndex + this.pagesAllowed];
+                    this.oldTS = lastPage[lastPage.length - 1].timeMs;
+                }
+                this.rerender();
             }
-            return item;
-        }));
-        if (shouldRerender)
-            this.rerender();
-    }
-    onItemChanged(newItemId, oldItemId) {
-        if (newItemId !== oldItemId) {
-            this.pagesToRender = [[]];
-            this.loadFirstPage().then(() => this.rerender());
         }
     }
+    /**
+     * Updates a new node anywhere in the list
+     * @param {string} _id - The id of the node to update
+     * @param {DataNode} _node - The updated data node
+     * */
+    async onNodeUpdate(_id, _node) { }
+    rerender() {
+        this.rerenderBoolean = !this.rerenderBoolean;
+    }
     connectedCallback() {
         this.rerender = debounce(this.rerender.bind(this), 50, { maxWait: 200 });
-        this.autoScroll = true;
         this.intersectionObserver = new IntersectionObserver((entries) => {
-            writeTask(() => {
+            writeTask(async () => {
                 for (const entry of entries) {
-                    if (entry.target.id === 'bottom-scroll') {
-                        if (entry.isIntersecting)
-                            this.loadBottom();
-                        else
-                            this.shouldRenderNewNodes = false;
-                    }
                     if (entry.target.id === 'top-scroll' && entry.isIntersecting) {
-                        this.loadTop();
+                        this.isLoadingTop = true;
+                        await this.loadPrevPage();
+                        this.isLoadingTop = false;
                     }
                 }
             });
         });
     }
-    disconnectedCallback() {
-        this.intersectionObserver.disconnect();
-    }
     componentDidLoad() {
-        /**
-         * Adding observes here so that on the first render we scroll down
-         * and shouldRenderNewNodes remains true
-         */
-        this.loadFirstPage();
         this.observe(this.$topRef);
-        this.observe(this.$bottomRef);
-    }
-    componentDidRender() {
-        if (this.shouldRenderNewNodes && this.autoScroll)
-            smoothScrollToBottom(this.$paginatedList);
-    }
-    loadFirstPage() {
-        return this.loadPage(this.currentTime(), this.pageSize, true, (data) => {
-            if (data.length === 0) {
-                this.showEmptyListLabel = true;
-            }
-        });
+        if (this.$containerRef) {
+            this.$containerRef.onscrollend = async () => {
+                /**
+                 * Load new page if:
+                 * if there are nodes to load at the bottom (maxTS > newTS)
+                 * or if there are pages to fill at the bottom (firstEmptyIndex > -1)
+                 */
+                if (this.isAtBottom() && (this.maxTS > this.newTS || this.firstEmptyIndex > -1)) {
+                    this.isLoadingBottom = true;
+                    await this.loadNextPage();
+                    this.isLoadingBottom = false;
+                    if (this.shouldScrollToBottom)
+                        this.scrollToBottom();
+                }
+            };
+        }
     }
-    loadTop() {
-        /**
-         * If there is only one unfilled page or no page, no need to check
-         * for top since it will be empty
-         */
-        if (this.pagesToRender.length === 0)
-            return;
-        if (this.pagesToRender.length === 1 && this.pagesToRender[0].length < this.pageSize)
+    async loadPrevPage() {
+        if (this.isLoading)
             return;
         /**
-         * TODO: Make this more flexible currently this only works with chat
+         * NOTE(ikabra): this case also runs on initial load
+         * if scrolling up ->
+         * fetch older messages and push to the end of the array
+         * cleanup 1st non empty page from the array if length exceeds pagesAllowed
          */
-        const oldestVNode = this.pagesToRender[0][0];
-        const oldestTimestamp = oldestVNode.timeMs;
-        // TODO: scrollIntoView
-        const onPageRendered = () => { }; // oldestVNode.$elm$?.scrollIntoView();
-        this.isLoadingTop = true;
-        this.loadPage(oldestTimestamp - 1, this.pageSize, true, onPageRendered, 'top');
+        // if no old timestamp, it means we are at initial state
+        if (!this.oldTS)
+            this.oldTS = new Date().getTime();
+        // load data
+        this.isLoading = true;
+        const data = await this.fetchData(this.oldTS - 1, this.pageSize, true);
+        this.isLoading = false;
+        // no more old messages to show, we are at the top of the page
+        if (!data.length)
+            return;
+        // add old data to the end of the array
+        this.pages.push(data);
+        // clear old pages when we reach the limit
+        if (this.pages.length > this.pagesAllowed) {
+            this.pages[this.pages.length - this.pagesAllowed - 1] = [];
+            /**
+             * find last non empty page in range (this.pages.length, this.firstEmptyIndex)
+             * we are doing this because any of the middle pages in the currently rendered pages
+             * could be empty as we allow deleting messages.
+             * This helps us set the first empty index correctly.
+             */
+            for (let i = this.firstEmptyIndex + 1; i < this.pages.length; i++) {
+                if (this.pages[i].length > 0)
+                    break;
+                this.firstEmptyIndex = i;
+            }
+        }
+        // update the old timestamp
+        const lastPage = this.pages[this.pages.length - 1];
+        this.oldTS = lastPage[lastPage.length - 1].timeMs;
+        // update the new timestamp
+        this.newTS = this.pages[this.firstEmptyIndex + 1][0].timeMs;
+        this.rerender();
     }
-    loadBottom() {
-        /**
-         * If there is only one unfilled page or no page, no need to check
-         * for top since it will be empty
-         */
-        if (this.pagesToRender.length === 0) {
-            this.shouldRenderNewNodes = true;
+    async loadNextPage() {
+        if (this.isLoading)
+            return;
+        // new timestamp needs to be assigned by loadPrevPage method
+        if (!this.newTS) {
+            this.showNewMessagesCTR = false;
+            this.shouldScrollToBottom = false;
             return;
         }
-        if (this.pagesToRender.length === 1 && this.pagesToRender[0].length < this.pageSize) {
-            this.shouldRenderNewNodes = true;
+        // load data
+        this.isLoading = true;
+        const data = await this.fetchData(this.newTS + 1, this.pageSize, false);
+        this.isLoading = false;
+        // no more new messages to load
+        if (!data.length) {
+            this.showNewMessagesCTR = false;
+            this.shouldScrollToBottom = false;
+            // remove extra pages from the start if any (could be due to users deleting messages)
+            this.pages = this.pages.filter((page) => page.length > 0);
+            this.firstEmptyIndex = -1;
             return;
         }
-        const newestVNode = this.pagesToRender.at(-1).at(-1);
-        const newestTimestamp = newestVNode.timeMs;
-        // TODO: scrollIntoView
-        const onPageRendered = () => smoothScrollToBottom(this.$paginatedList);
-        this.isLoadingBottom = true;
-        this.loadPage(newestTimestamp + 1, this.pageSize, false, onPageRendered, 'bottom');
-    }
-    addNodeToRender(node, addToStart) {
-        if (addToStart) {
-            const firstPage = this.pagesToRender[0];
-            if (firstPage && (firstPage === null || firstPage === void 0 ? void 0 : firstPage.length) < this.pageSize) {
-                /**
-                 * If first page is not full then just add to that page
-                 */
-                firstPage.unshift(node);
-            }
-            else {
-                /**
-                 * If first page is full then add a new page to the start
-                 */
-                const newPage = [node];
-                this.pagesToRender.unshift(newPage);
-                this.removeLastPageIfNeeded(false);
-            }
+        // when filling empty pages
+        if (this.firstEmptyIndex > -1) {
+            this.pages[this.firstEmptyIndex] = data.reverse();
         }
         else {
-            const [lastPage] = this.pagesToRender.slice(-1);
-            if (lastPage && (lastPage === null || lastPage === void 0 ? void 0 : lastPage.length) < this.pageSize) {
-                /**
-                 * If last page is not full then just add it
-                 */
-                lastPage.push(node);
-            }
-            else {
-                /**
-                 * If last page is full add a new page with just
-                 * this node
-                 */
-                const newPage = [node];
-                this.pagesToRender.push(newPage);
-                this.removeLastPageIfNeeded(true);
-            }
+            // when already at the bottom and loading messages in realtime
+            this.pages.unshift(data.reverse());
         }
-    }
-    /**
-     * @param start
-     * @param end
-     * @param reversed Defines whether to add the page at the beginning or the end
-     * @param onPageLoaded Callback for when all new nodes are rendered
-     * @param direction Indicates if loading from 'top' or 'bottom'
-     */
-    async loadPage(timestamp, size, reversed, onPageRendered = () => { }, direction) {
-        this.isLoading = true;
-        const data = (await this.fetchData(timestamp, size, reversed));
-        this.isLoading = false;
-        if (direction === 'top') {
-            this.isLoadingTop = false;
-            this.hasMoreDataAtTop = (data === null || data === void 0 ? void 0 : data.length) > 0;
+        if (this.pages.length > this.pagesAllowed) {
+            this.pages.pop();
         }
-        if (direction === 'bottom') {
-            this.isLoadingBottom = false;
+        // smallest value for firstEmptyIndex can be -1, so we cap the index at 0
+        this.newTS = this.pages[Math.max(0, this.firstEmptyIndex)][0].timeMs;
+        // remove all empty pages from the end
+        for (let i = this.pages.length - 1; i > this.firstEmptyIndex; i--) {
+            if (this.pages[i].length > 0)
+                break;
+            // if page is empty, remove it
+            this.pages.pop();
         }
-        if (!(data === null || data === void 0 ? void 0 : data.length)) {
-            /**
-             * While scrolling down if there were no new items found
-             * then start rendering new nodes;
-             */
-            if (!reversed) {
-                this.hasNewNodesToRender = false;
-                this.shouldRenderNewNodes = true;
-            }
-            onPageRendered([]);
-            return;
-        }
-        data.forEach((node) => this.addNodeToRender(node, reversed));
+        // update the old timestamp
+        const lastPage = this.pages[this.pages.length - 1];
+        this.oldTS = lastPage[lastPage.length - 1].timeMs;
+        // when scrolling too fast scroll a bit to the top to be able to load new messages when you scroll down
+        if (this.$containerRef.scrollTop === 0)
+            this.$containerRef.scrollTop = -60;
+        // smallest value for this index can be -1 (indicates we are at the bottom of the page).
+        this.firstEmptyIndex = Math.max(-1, this.firstEmptyIndex - 1);
         this.rerender();
-        onPageRendered(data);
-    }
-    rerender() {
-        this.rerenderBoolean = !this.rerenderBoolean;
-    }
-    removeLastPageIfNeeded(removeFromStart) {
-        if (this.pagesToRender.length > this.pagesAllowed) {
-            if (removeFromStart)
-                this.pagesToRender.shift();
-            else
-                this.pagesToRender.pop();
-        }
-    }
-    onDownArrowClicked() {
-        /**
-         * Load the freshest pages
-         */
-        this.loadBottom();
-    }
-    onLoadMoreOnTopClicked() {
-        this.loadTop();
     }
     render() {
-        var _a;
         /**
          * div.container is flex=column-reverse
          * which is why div#bottom-scroll comes before div#top-scroll
-         * div.page-wrapper prevents reversal of messages
          */
-        return (h(Host, { key: '2ee90baa6b1b9f88829d04632c129287b936ba30' }, h("div", { key: 'd68db998539fd1df12e92d61828a04628f7d9f0a', class: "scrollbar container", part: "container", ref: (el) => (this.$paginatedList = el) }, h("div", { key: '4fe1ae2b1aa961242ba6be8ca3b8b6c6e504ef5c', class: { 'show-new-messages-ctr': true, active: !this.shouldRenderNewNodes } }, h("rtk-button", { key: '5c7ad4c553eb6f1b7f14bad406e49fe18f63d100', class: "show-new-messages", kind: "icon", variant: "secondary", part: "show-new-messages", onClick: () => this.onDownArrowClicked() }, h("rtk-icon", { key: 'dacfc24e3fb9ec34e40447b606e256eefaefdc6e', icon: this.iconPack.chevron_down }))), h("div", { key: '569ffce0c198638b831a3eb0bac9a032c863ed9d', class: "smallest-dom-element", id: "bottom-scroll", ref: (el) => (this.$bottomRef = el) }), this.isLoadingBottom && h("rtk-spinner", { key: '06f571694e1877d8eba4ec939bc6a74f68f16caa', size: "sm" }), this.isLoading && this.pagesToRender.flat().length === 0 && h("rtk-spinner", { key: '628c0eef27fe29d2c3cbf6f0da7d10a12560c127', size: "lg" }), this.pagesToRender.flat().length === 0 && this.showEmptyListLabel ? (h("div", { class: "empty-list" }, (_a = this.emptyListLabel) !== null && _a !== void 0 ? _a : this.t('list.empty'))) : (h("div", { class: "page-wrapper" }, this.pagesToRender.map((page) => this.createNodes(page)))), this.hasMoreDataAtTop && !this.isLoadingTop && (h("div", { key: 'fc5207945ed0949074e3460d9943130eb4289409', class: "load-more-on-top-container" }, h("rtk-button", { key: '4fff7d14798340dc576e4aeeebfe9e3946cbcf6a', class: "load-more-icon", kind: "icon", variant: "secondary", part: "load-more-icon", onClick: () => this.onLoadMoreOnTopClicked() }, h("rtk-icon", { key: '87b2abaf1c850189246d1b9aa84b55c374b31d1d', icon: this.iconPack.chevron_up })))), this.isLoadingTop && h("rtk-spinner", { key: '766ac48eebaa236a9a44f770d777c2c31fabe10e', size: "sm" }), h("div", { key: '6a5287556030f9f426ac2d8b6063b13a966135ff', class: "smallest-dom-element", id: "top-scroll", ref: (el) => (this.$topRef = el) }))));
+        return (h(Host, { key: '9bf695bccf42f2dd43b04725a855b6b77a4062fd' }, h("div", { key: '7c6805ed8b5e831ea6d932cfb5dc3ecf3d312775', class: "scrollbar container", part: "container", ref: (el) => (this.$containerRef = el) }, h("div", { key: 'eb6c68f97385b5a14a94ab2dc0abff4836f016f3', class: { 'show-new-messages-ctr': true, active: this.showNewMessagesCTR } }, h("rtk-button", { key: 'd1f04db290a9e4128ca58c9bd20b2146a7fc8f12', class: "show-new-messages", kind: "icon", variant: "secondary", part: "show-new-messages", onClick: () => {
+                this.shouldScrollToBottom = true;
+                this.scrollToBottom();
+            } }, h("rtk-icon", { key: '71d8a85911513bb4069578a63ae45f21ac53554c', icon: this.iconPack.chevron_down }))), h("div", { key: 'b1aa46b8163431df6060163d7c5a87eb1ebcffa3', class: "smallest-dom-element", id: "bottom-scroll", ref: (el) => (this.$bottomRef = el) }), this.isLoadingBottom && this.pages.length > 0 && h("rtk-spinner", { key: 'a3de0e7b8ca1ac505a596d86c0b8ecafee5fabba', size: "sm" }), this.isLoading && this.pages.length < 1 && h("rtk-spinner", { key: '21fa3a4091d3f1311f5d575c277859602718338c', size: "lg" }), !this.isLoading && this.pages.flat().length === 0 ? (h("div", { class: "empty-list" }, this.t('list.empty'))) : (h("div", { class: "page-wrapper" }, this.pages.map((page, pageIndex) => (h("div", { class: "page", "data-page-index": pageIndex }, this.createNodes([...page].reverse())))))), this.isLoadingTop && this.pages.length > 0 && h("rtk-spinner", { key: '7e018af534e7cd0be3345ca9ad9c8f0a7ab7cc3f', size: "sm" }), h("div", { key: '6c877368fc03c884338402bbcd878929cd4034fb', class: "smallest-dom-element", id: "top-scroll", ref: (el) => (this.$topRef = el) }))));
     }
     static get is() { return "rtk-paginated-list"; }
     static get encapsulation() { return "shadow"; }
@@ -333,6 +359,26 @@ export class RtkPaginatedList {
                 "attribute": "pages-allowed",
                 "reflect": false
             },
+            "emptyListLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "label to show when empty"
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "empty-list-label",
+                "reflect": false,
+                "defaultValue": "null"
+            },
             "fetchData": {
                 "type": "unknown",
                 "mutable": false,
@@ -463,39 +509,16 @@ export class RtkPaginatedList {
                 "getter": false,
                 "setter": false,
                 "defaultValue": "useLanguage()"
-            },
-            "emptyListLabel": {
-                "type": "string",
-                "mutable": false,
-                "complexType": {
-                    "original": "string",
-                    "resolved": "string",
-                    "references": {}
-                },
-                "required": false,
-                "optional": false,
-                "docs": {
-                    "tags": [],
-                    "text": "label to show when empty"
-                },
-                "getter": false,
-                "setter": false,
-                "attribute": "empty-list-label",
-                "reflect": false,
-                "defaultValue": "null"
             }
         };
     }
     static get states() {
         return {
+            "rerenderBoolean": {},
+            "showEmptyListLabel": {},
             "isLoading": {},
             "isLoadingTop": {},
-            "isLoadingBottom": {},
-            "hasMoreDataAtTop": {},
-            "rerenderBoolean": {},
-            "shouldRenderNewNodes": {},
-            "hasNewNodesToRender": {},
-            "showEmptyListLabel": {}
+            "isLoadingBottom": {}
         };
     }
     static get methods() {
@@ -506,7 +529,7 @@ export class RtkPaginatedList {
                     "parameters": [{
                             "name": "node",
                             "type": "DataNode",
-                            "docs": ""
+                            "docs": "- The data node to add to the beginning of the list"
                         }],
                     "references": {
                         "Promise": {
@@ -522,17 +545,20 @@ export class RtkPaginatedList {
                     "return": "Promise<void>"
                 },
                 "docs": {
-                    "text": "On a new node created",
-                    "tags": []
+                    "text": "Adds a new node to the beginning of the paginated list",
+                    "tags": [{
+                            "name": "param",
+                            "text": "node - The data node to add to the beginning of the list"
+                        }]
                 }
             },
             "onNodeDelete": {
                 "complexType": {
-                    "signature": "(key: string) => Promise<void>",
+                    "signature": "(id: string) => Promise<void>",
                     "parameters": [{
-                            "name": "key",
+                            "name": "id",
                             "type": "string",
-                            "docs": ""
+                            "docs": "- The id of the node to delete"
                         }],
                     "references": {
                         "Promise": {
@@ -543,21 +569,24 @@ export class RtkPaginatedList {
                     "return": "Promise<void>"
                 },
                 "docs": {
-                    "text": "On node deleted",
-                    "tags": []
+                    "text": "Deletes a node anywhere from the list",
+                    "tags": [{
+                            "name": "param",
+                            "text": "id - The id of the node to delete"
+                        }]
                 }
             },
             "onNodeUpdate": {
                 "complexType": {
-                    "signature": "(key: string, newItem: DataNode) => Promise<void>",
+                    "signature": "(_id: string, _node: DataNode) => Promise<void>",
                     "parameters": [{
-                            "name": "key",
+                            "name": "_id",
                             "type": "string",
-                            "docs": ""
+                            "docs": "- The id of the node to update"
                         }, {
-                            "name": "newItem",
+                            "name": "_node",
                             "type": "DataNode",
-                            "docs": ""
+                            "docs": "- The updated data node"
                         }],
                     "references": {
                         "Promise": {
@@ -573,18 +602,18 @@ export class RtkPaginatedList {
                     "return": "Promise<void>"
                 },
                 "docs": {
-                    "text": "On node updated",
-                    "tags": []
+                    "text": "Updates a new node anywhere in the list",
+                    "tags": [{
+                            "name": "param",
+                            "text": "_id - The id of the node to update"
+                        }, {
+                            "name": "param",
+                            "text": "_node - The updated data node"
+                        }]
                 }
             }
         };
     }
-    static get watchers() {
-        return [{
-                "propName": "selectedItemId",
-                "methodName": "onItemChanged"
-            }];
-    }
 }
 __decorate([
     SyncWithStore()