@cloudflare/realtimekit-ui 1.1.0-staging.1 → 1.1.0-staging.10

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

@@ -1,3 +1,29 @@
+/**
+ * NOTE(ikabra): INFINITE SCROLL IMPLEMENTATION:
+ *
+ * Uses scrollend listener for 2way scrolling.
+ * Empty divs ($topRef, $bottomRef) act as scroll triggers to fetch new messages.
+ *
+ * UPWARD SCROLLING:
+ * - Fetch top anchor (element currently visible to the user near top)
+ * - Fetch older messages, push to end of 2D array
+ * - When exceeding pagesAllowed, delete pages and scroll back to anchor
+ *
+ * DOWNWARD SCROLLING:
+ * - Fetch bottom anchor (element currently visible to the user near bottom)
+ * - Fetch new page, insert at the start
+ * - Update timestamps & firstEmptyIndex, then rerender
+ * - When exceeding pagesAllowed, delete pages and scroll back to anchor
+ *
+ * ADDING NEW NODES:
+ * - If no pages exist, load old page
+ * - If on 1st page, append messages till page size is full and then load new page
+ *
+ * DELETE NODE:
+ * - If deleting the only available node, reset to initial state
+ * - If page is empty, delete it
+ * - Update timestamp curors
+ */
 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")
@@ -8,278 +34,312 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
                 r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { Host, h, writeTask } from "@stencil/core";
-import { debounce } from "lodash-es";
+import { Host, h } from "@stencil/core";
 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() {
+        // Timestamp pertaining to the oldest stored message
+        this.oldestPaginatedTimestamp = null;
+        // Timestamp pertaining to the latest stored message
+        this.latestPaginatedTimestamp = null;
+        // Timestamp pertaining to the latest message stored in backend
+        this.latestMessageTimestamp = null;
+        // the length of pages will always be pageSize + 2
+        this.pages = [];
+        // Controls whether to keep auto-scrolling when a new page load.
+        this.shouldScrollToBottom = false;
+        // Shows "scroll to bottom" button when new nodes arrive and autoscroll is off.
+        this.showNewMessagesCTR = false;
+        /** label to show when empty */
+        this.emptyListLabel = null;
         /** Icon pack */
         this.iconPack = defaultIconPack;
         /** Language */
         this.t = useLanguage();
-        /** label to show when empty */
-        this.emptyListLabel = null;
+        this.rerenderBoolean = false;
+        this.showEmptyListLabel = false;
         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();
-        };
-        this.observe = (el) => {
-            if (!el)
-                return;
-            this.intersectionObserver.observe(el);
+        // Tells us if we need to scroll to a specific anchor after a rerender
+        this.pendingScrollAnchor = null;
+        this.isInView = (el) => {
+            const rect = el.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;
+        // if there are no pages, append to the first page
+        if (this.pages.length < 1) {
+            this.oldestPaginatedTimestamp = node.timeMs;
+            this.pages.unshift([node]);
+            this.latestPaginatedTimestamp = node.timeMs;
+            this.latestMessageTimestamp = node.timeMs;
+            this.rerender();
+            if (this.autoScroll)
+                this.$bottomRef.scrollIntoView({ behavior: 'smooth' });
         }
-        this.addNodeToRender(node, false);
-        this.rerender();
+        else if (this.latestMessageTimestamp === this.latestPaginatedTimestamp) {
+            // 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.latestPaginatedTimestamp = node.timeMs;
+                this.latestMessageTimestamp = node.timeMs;
+                this.rerender();
+            }
+            else {
+                // if page is at full capacity, load next page
+                this.pages.unshift([node]);
+                this.latestPaginatedTimestamp = node.timeMs;
+                this.latestMessageTimestamp = node.timeMs;
+                // remove pages if out of bounds
+                if (this.pages.length > this.pagesAllowed)
+                    this.pages.pop();
+                // update timestamps
+                const lastPage = this.pages[this.pages.length - 1];
+                this.oldestPaginatedTimestamp = lastPage[lastPage.length - 1].timeMs;
+                this.rerender();
+            }
+            if (this.autoScroll)
+                this.$bottomRef.scrollIntoView({ behavior: 'smooth' });
+        }
+        else {
+            if (this.autoScroll)
+                this.scrollToBottom();
+        }
+        this.pendingScrollAnchor = null;
     }
     /**
-     * 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) {
+     * Deletes a node anywhere from the list
+     * @param {string} id - The id of the node to delete
+     * */
+    async onNodeDelete(id) {
+        var _a, _b;
+        for (let i = this.pages.length - 1; i >= 0; i--) {
+            const index = this.pages[i].findIndex((node) => node.id === id);
+            // if message not found, move on
+            if (index === -1)
+                continue;
+            // delete message
+            this.pages[i].splice(index, 1);
+            // if page is empty, delete it
+            if (this.pages[i].length === 0)
+                this.pages.splice(i, 1);
+            // update timestamps
+            const firstPage = this.pages[0];
+            const lastPage = this.pages[this.pages.length - 1];
+            this.latestPaginatedTimestamp = (_a = firstPage === null || firstPage === void 0 ? void 0 : firstPage[0]) === null || _a === void 0 ? void 0 : _a.timeMs;
+            this.oldestPaginatedTimestamp = (_b = lastPage === null || lastPage === void 0 ? void 0 : lastPage[lastPage.length - 1]) === null || _b === void 0 ? void 0 : _b.timeMs;
+            // if I have deleted the latest message, update latestMessageTimestamp
+            if (index === 0 && i === 0)
+                this.latestMessageTimestamp = this.latestPaginatedTimestamp;
             this.rerender();
+            break;
         }
     }
     /**
-     * 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;
-            }
-            return item;
-        }));
-        if (shouldRerender)
+     * 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) {
+        for (let i = this.pages.length - 1; i >= 0; i--) {
+            const index = this.pages[i].findIndex((node) => node.id === id);
+            // if message not found, move on
+            if (index === -1)
+                continue;
+            // edit message
+            this.pages[i][index] = node;
             this.rerender();
-    }
-    onItemChanged(newItemId, oldItemId) {
-        if (newItemId !== oldItemId) {
-            this.pagesToRender = [[]];
-            this.loadFirstPage().then(() => this.rerender());
+            break;
         }
     }
     connectedCallback() {
         this.rerender = debounce(this.rerender.bind(this), 50, { maxWait: 200 });
-        this.autoScroll = true;
-        this.intersectionObserver = new IntersectionObserver((entries) => {
-            writeTask(() => {
-                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();
-                    }
-                }
-            });
-        });
-    }
-    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);
+        // initial load
+        this.loadPrevPage();
+        if (this.$containerRef) {
+            this.$containerRef.onscrollend = async () => {
+                // do not do anything if we are scrolling to bottom
+                if (this.shouldScrollToBottom)
+                    return;
+                // handle top and bottom scroll
+                if (this.isInView(this.$bottomRef) &&
+                    this.latestMessageTimestamp > this.latestPaginatedTimestamp) {
+                    await this.loadNextPage();
+                }
+                else if (this.isInView(this.$topRef)) {
+                    this.showNewMessagesCTR = true;
+                    await this.loadPrevPage();
+                }
+            };
+        }
     }
     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;
-            }
-        });
-    }
-    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)
+        if (!this.pendingScrollAnchor)
             return;
-        /**
-         * TODO: Make this more flexible currently this only works with chat
-         */
-        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');
+        const anchor = this.pendingScrollAnchor;
+        this.pendingScrollAnchor = null;
+        this.restoreScrollToAnchor(anchor);
     }
-    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 loadPrevPage() {
+        if (this.isLoading)
             return;
-        }
-        if (this.pagesToRender.length === 1 && this.pagesToRender[0].length < this.pageSize) {
-            this.shouldRenderNewNodes = true;
+        const scrollAnchor = this.getScrollAnchor('top');
+        // if no old timestamp, it means we are at initial state
+        if (!this.oldestPaginatedTimestamp)
+            this.oldestPaginatedTimestamp = new Date().getTime();
+        // load data
+        this.isLoading = true;
+        this.isLoadingTop = true;
+        const data = await this.fetchData(this.oldestPaginatedTimestamp - 1, this.pageSize, true);
+        this.isLoading = false;
+        this.isLoadingTop = 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.shift();
+        // update timestamps
+        const lastPage = this.pages[this.pages.length - 1];
+        this.oldestPaginatedTimestamp = lastPage[lastPage.length - 1].timeMs;
+        this.latestPaginatedTimestamp = this.pages[0][0].timeMs;
+        if (!this.latestMessageTimestamp)
+            this.latestMessageTimestamp = this.latestPaginatedTimestamp;
+        this.rerender();
+        // fix scroll position
+        if (scrollAnchor)
+            this.pendingScrollAnchor = scrollAnchor;
+    }
+    async loadNextPage() {
+        if (this.isLoading)
+            return [];
+        // Do nothing. New timestamp needs to be assigned by loadPrevPage method
+        if (!this.latestPaginatedTimestamp) {
+            this.showNewMessagesCTR = false;
+            return [];
         }
-        const newestVNode = this.pagesToRender.at(-1).at(-1);
-        const newestTimestamp = newestVNode.timeMs;
-        // TODO: scrollIntoView
-        const onPageRendered = () => smoothScrollToBottom(this.$paginatedList);
+        this.isLoading = true;
         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);
-            }
+        const scrollAnchor = this.getScrollAnchor('bottom');
+        const data = await this.fetchData(this.latestPaginatedTimestamp + 1, this.pageSize, false);
+        this.isLoading = false;
+        this.isLoadingBottom = false;
+        // no more new messages to load
+        if (!data.length) {
+            this.latestMessageTimestamp = this.latestPaginatedTimestamp;
+            this.showNewMessagesCTR = false;
+            return [];
         }
-        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);
+        // load new messages and append to the start
+        const incoming = [...data].reverse();
+        if (this.pages.length === 0)
+            this.pages.unshift([]);
+        const firstPage = this.pages[0];
+        const spaceInFirstPage = this.pageSize - firstPage.length;
+        if (spaceInFirstPage > 0) {
+            const toFill = incoming.splice(0, spaceInFirstPage);
+            firstPage.unshift(...toFill);
+        }
+        while (incoming.length > 0) {
+            this.pages.unshift(incoming.splice(0, this.pageSize));
+        }
+        // remove pages if out of bounds
+        if (this.pages.length > this.pagesAllowed)
+            this.pages.pop();
+        // update timestamps
+        const lastPage = this.pages[this.pages.length - 1];
+        this.oldestPaginatedTimestamp = lastPage[lastPage.length - 1].timeMs;
+        this.latestPaginatedTimestamp = this.pages[0][0].timeMs;
+        this.rerender();
+        this.pendingScrollAnchor = scrollAnchor;
+        return data;
+    }
+    // Find the element that is closest to the top/bottom of the container
+    getScrollAnchor(edge = 'top') {
+        if (!this.$containerRef)
+            return null;
+        const containerRect = this.$containerRef.getBoundingClientRect();
+        const candidates = Array.from(this.$containerRef.querySelectorAll('[id]')).filter((el) => el.id !== 'top-scroll' && el.id !== 'bottom-scroll');
+        let best = null;
+        for (const el of candidates) {
+            const rect = el.getBoundingClientRect();
+            const isVisibleInContainer = rect.bottom > containerRect.top && rect.top < containerRect.bottom;
+            if (!isVisibleInContainer)
+                continue;
+            if (edge === 'top') {
+                const offsetTop = rect.top - containerRect.top;
+                if (best == null || (best.edge === 'top' && offsetTop < best.offsetTop)) {
+                    best = { id: el.id, edge: 'top', offsetTop };
+                }
             }
             else {
-                /**
-                 * If last page is full add a new page with just
-                 * this node
-                 */
-                const newPage = [node];
-                this.pagesToRender.push(newPage);
-                this.removeLastPageIfNeeded(true);
+                const offsetBottom = containerRect.bottom - rect.bottom;
+                if (best == null || (best.edge === 'bottom' && offsetBottom < best.offsetBottom)) {
+                    best = { id: el.id, edge: 'bottom', offsetBottom };
+                }
             }
         }
+        return best;
     }
-    /**
-     * @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;
+    //instant scroll to anchor to make sure we are at the same position after a rerender
+    restoreScrollToAnchor(anchor) {
+        if (!this.$containerRef)
+            return;
+        // make element id safe to use inside a CSS selector
+        const escapeId = (id) => {
+            var _a;
+            const cssEscape = (_a = globalThis.CSS) === null || _a === void 0 ? void 0 : _a.escape;
+            return typeof cssEscape === 'function'
+                ? cssEscape(id)
+                : id.replace(/[^a-zA-Z0-9_-]/g, '\\$&');
+        };
+        const el = this.$containerRef.querySelector(`#${escapeId(anchor.id)}`);
+        if (!el)
+            return;
+        const containerRect = this.$containerRef.getBoundingClientRect();
+        const rect = el.getBoundingClientRect();
+        if (anchor.edge === 'top') {
+            const newOffsetTop = rect.top - containerRect.top;
+            this.$containerRef.scrollTop += newOffsetTop - anchor.offsetTop;
         }
-        if (direction === 'bottom') {
-            this.isLoadingBottom = false;
+        else {
+            const newOffsetBottom = containerRect.bottom - rect.bottom;
+            this.$containerRef.scrollTop += anchor.offsetBottom - newOffsetBottom;
         }
-        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;
+    }
+    // this method is called recursively based on shouldScrollToBottom (see loadNextPage)
+    async scrollToBottom() {
+        this.shouldScrollToBottom = true;
+        while (this.shouldScrollToBottom) {
+            const response = await this.loadNextPage();
+            this.$bottomRef.scrollIntoView({ behavior: 'smooth' });
+            if (response.length === 0)
+                this.shouldScrollToBottom = false;
         }
-        data.forEach((node) => this.addNodeToRender(node, reversed));
-        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
+         * div.container is flex=column-reversewhich is why div#bottom-scroll comes before div#top-scroll
          */
-        return (h(Host, { key: '23e10f12b079213650cf9c947d30650ba8c95a4d' }, h("div", { key: 'b5406069fd69ff117b19d437184c38b3c7d2fc28', class: "scrollbar container", part: "container", ref: (el) => (this.$paginatedList = el) }, h("div", { key: '7be947f2409ff810e0d10beea53ace8fdec334ce', class: { 'show-new-messages-ctr': true, active: !this.shouldRenderNewNodes } }, h("rtk-button", { key: '45c43d6ca1cc39376334dffa10f3f2c137d65add', class: "show-new-messages", kind: "icon", variant: "secondary", part: "show-new-messages", onClick: () => this.onDownArrowClicked() }, h("rtk-icon", { key: '519b0db80f7d16cc4d03983e227d4897a5868ec9', icon: this.iconPack.chevron_down }))), h("div", { key: '53691e3943b90ef9e422c8da8f5facaa23f01920', class: "smallest-dom-element", id: "bottom-scroll", ref: (el) => (this.$bottomRef = el) }), this.isLoadingBottom && h("rtk-spinner", { key: '2a393cb0bbb07c356144464dcc7c597f5cc9771b', size: "sm" }), this.isLoading && this.pagesToRender.flat().length === 0 && h("rtk-spinner", { key: '4ce03be69368db0d6d0d4ad079b14f2c7d93f26d', 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: '5c85806854687efe098e4bd6d06d109060445378', class: "load-more-on-top-container" }, h("rtk-button", { key: '6d73a030fad5ba133aa2841b2feb196646592ada', class: "load-more-icon", kind: "icon", variant: "secondary", part: "load-more-icon", onClick: () => this.onLoadMoreOnTopClicked() }, h("rtk-icon", { key: '61a4f376749938df280e5c734dd3fa8a9b0b7201', icon: this.iconPack.chevron_up })))), this.isLoadingTop && h("rtk-spinner", { key: '3e55b99c60ed7bc2cd937091a33663dd19c9ca68', size: "sm" }), h("div", { key: 'a69e0a3a26d295783f4f729b33770b206ab5d46b', class: "smallest-dom-element", id: "top-scroll", ref: (el) => (this.$topRef = el) }))));
+        return (h(Host, { key: 'd3a69c210794a552e1a45d0d184b16657cbfde79' }, h("div", { key: 'c9cdb45d5cea872660bc8e2170c3d94c9331a861', class: "scrollbar container", part: "container", ref: (el) => (this.$containerRef = el) }, h("div", { key: '1bacf2a627e8a7f11f75e0ecbda873609cd347b9', class: { 'show-new-messages-ctr': true, active: this.showNewMessagesCTR } }, h("rtk-button", { key: '0c4e3f79e2a7447f1195e03aa026d0f228d09f90', class: "show-new-messages", kind: "icon", variant: "secondary", part: "show-new-messages", onClick: () => {
+                this.scrollToBottom();
+            } }, this.shouldScrollToBottom ? (h("rtk-spinner", { size: "sm" })) : (h("rtk-icon", { icon: this.iconPack.chevron_down })))), h("div", { key: '439f9e943266f60c933812771682bc414b86d418', class: "smallest-dom-element", id: "bottom-scroll", ref: (el) => (this.$bottomRef = el) }), this.isLoadingBottom && this.pages.length > 0 && h("rtk-spinner", { key: 'd79aa2e74a62b14a456c8437362bb01a9df933e1', size: "sm" }), this.isLoading && this.pages.length < 1 && h("rtk-spinner", { key: '7ccfd41966d0337a8abe9a3086ca3f07fe051dc0', 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: '1c6c11863adba0205d0dd2ce649f3bdf51c9df60', size: "sm" }), h("div", { key: '413506236882f6d516967db0f642f5db63c7971f', 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 +393,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 +543,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 +563,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 +579,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 +603,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 +636,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()