@dereekb/firebase 13.11.2 → 13.11.4

package/test/index.cjs.js

@@ -1723,6 +1723,119 @@ var mockItemUserIdentifier = '0';
         firestoreContext: firestoreContext
     });
 }
+// MARK: MockItemPaged
+/**
+ * {@link firestoreModelIdentity} for the MockItemPaged subcollection (`mockItemPaged` / `mip2`).
+ *
+ * Child of {@link mockItemIdentity}. Stores a logical {@link MockItemPagedEntry} array distributed
+ * across multiple page documents, plus an index document that summarizes the layout. See
+ * {@link PagedItemFirestoreCollection} for the underlying mechanism.
+ */ var mockItemPagedIdentity = firebase.firestoreModelIdentity(mockItemIdentity, 'mockItemPaged', 'mip2');
+/**
+ * {@link AbstractFirestoreDocumentWithParent} implementation for a single page document inside a
+ * {@link MockItemPagedFirestoreCollection}. Used by the model service factory to address pages
+ * the same way other subcollection documents are addressed.
+ */ var MockItemPagedDocument = /*#__PURE__*/ function(AbstractFirestoreDocumentWithParent) {
+    _inherits$4(MockItemPagedDocument, AbstractFirestoreDocumentWithParent);
+    function MockItemPagedDocument() {
+        _class_call_check$5(this, MockItemPagedDocument);
+        return _call_super$4(this, MockItemPagedDocument, arguments);
+    }
+    _create_class$4(MockItemPagedDocument, [
+        {
+            key: "modelIdentity",
+            get: function get() {
+                return mockItemPagedIdentity;
+            }
+        }
+    ]);
+    return MockItemPagedDocument;
+}(firebase.AbstractFirestoreDocumentWithParent);
+/**
+ * Per-item converter for {@link MockItemPagedEntry} used by the paged accessor.
+ *
+ * The mock entry shape is already Firestore-safe, so the converter is an identity
+ * pass-through. Production usage may wrap a real converter (e.g. for date fields).
+ */ var mockItemPagedEntryConverter = {
+    fromData: function fromData(data) {
+        return data;
+    },
+    toData: function toData(item) {
+        return item;
+    }
+};
+/**
+ * Static distribution scheme for {@link MockItemPagedEntry} that buckets items by their
+ * {@link MockItemPagedEntry.group} field across three page IDs (`a`, `b`, `c`).
+ */ var mockItemPagedAlphaDistributionScheme = {
+    pageIds: [
+        'a',
+        'b',
+        'c'
+    ],
+    distribute: function distribute(entry) {
+        return entry.group;
+    }
+};
+/**
+ * Default `maxItemsPerPage` used by the dynamic mock paged collection factory. Kept small to
+ * exercise multi-page boundary conditions in tests without writing many entries.
+ */ var MOCK_ITEM_PAGED_DEFAULT_MAX_ITEMS_PER_PAGE = 3;
+/**
+ * Creates a factory for producing {@link MockItemPagedFirestoreCollection} instances bound to a
+ * parent {@link MockItemDocument}.
+ *
+ * @param firestoreContext - The Firestore context used to resolve the underlying subcollection.
+ * @param config - Optional config selecting between dynamic (default) and static distribution.
+ * @returns A factory that, given a parent {@link MockItemDocument}, returns a paged subcollection
+ * wired with {@link mockItemPagedEntryConverter}.
+ */ function mockItemPagedFirestoreCollection(firestoreContext, config) {
+    var _ref = config !== null && config !== void 0 ? config : {}, distributionScheme = _ref.distributionScheme, _ref_maxItemsPerPage = _ref.maxItemsPerPage, maxItemsPerPage = _ref_maxItemsPerPage === void 0 ? MOCK_ITEM_PAGED_DEFAULT_MAX_ITEMS_PER_PAGE : _ref_maxItemsPerPage;
+    return function(parent) {
+        return firestoreContext.pagedItemFirestoreCollection({
+            modelIdentity: mockItemPagedIdentity,
+            collection: firestoreContext.subcollection(parent.documentRef, mockItemPagedIdentity.collectionName),
+            parent: parent,
+            makeDocument: function makeDocument(a, d) {
+                return new MockItemPagedDocument(a, d);
+            },
+            firestoreContext: firestoreContext,
+            maxItemsPerPage: maxItemsPerPage,
+            distributionScheme: distributionScheme,
+            itemConverter: mockItemPagedEntryConverter
+        });
+    };
+}
+/**
+ * Creates a {@link CollectionGroup} reference for querying all {@link MockItemPagedDocumentData}
+ * page documents across parents.
+ *
+ * Note: the index document (`_index`) lives in the same Firestore collection but has a different
+ * shape ({@link PagedItemIndexData}); collection-group queries will surface both. Consumers
+ * should filter by document id when only pages are desired.
+ *
+ * @param context - The Firestore context used to resolve the collection group.
+ * @returns A typed {@link CollectionGroup} reference for the MockItemPaged collection name.
+ */ function mockItemPagedCollectionReference(context) {
+    return context.collectionGroup(mockItemPagedIdentity.collectionName);
+}
+/**
+ * Creates a {@link MockItemPagedFirestoreCollectionGroup} for cross-parent access to paged
+ * page documents.
+ *
+ * @param firestoreContext - The Firestore context used to resolve the underlying collection group reference.
+ * @returns A typed {@link MockItemPagedFirestoreCollectionGroup}.
+ */ function mockItemPagedFirestoreCollectionGroup(firestoreContext) {
+    return firestoreContext.firestoreCollectionGroup({
+        modelIdentity: mockItemPagedIdentity,
+        converter: firebase.defaultPagedItemPageDataConverter(),
+        queryLike: mockItemPagedCollectionReference(firestoreContext),
+        makeDocument: function makeDocument(accessor, documentAccessor) {
+            return new MockItemPagedDocument(accessor, documentAccessor);
+        },
+        firestoreContext: firestoreContext
+    });
+}
 // MARK: Mock System Item
 /**
  * System state type identifier for mock system state data.
@@ -1780,6 +1893,14 @@ function _class_call_check$4(instance, Constructor) {
         mockItemSubItemCollectionGroup: mockItemSubItemFirestoreCollectionGroup(firestoreContext),
         mockItemSubItemDeepCollectionFactory: mockItemSubItemDeepFirestoreCollection(firestoreContext),
         mockItemSubItemDeepCollectionGroup: mockItemSubItemDeepFirestoreCollectionGroup(firestoreContext),
+        mockItemPagedCollectionFactory: mockItemPagedFirestoreCollection(firestoreContext),
+        mockItemPagedStaticCollectionFactory: mockItemPagedFirestoreCollection(firestoreContext, {
+            distributionScheme: mockItemPagedAlphaDistributionScheme
+        }),
+        mockItemPagedCollectionFactoryWithConfig: function mockItemPagedCollectionFactoryWithConfig(config) {
+            return mockItemPagedFirestoreCollection(firestoreContext, config);
+        },
+        mockItemPagedCollectionGroup: mockItemPagedFirestoreCollectionGroup(firestoreContext),
         mockItemSystemStateCollection: firebase.systemStateFirestoreCollection(firestoreContext, mockItemSystemStateStoredDataConverterMap)
     };
 }
@@ -1857,6 +1978,24 @@ function _class_call_check$4(instance, Constructor) {
         return c.app.mockItemSubItemDeepCollectionGroup;
     }
 });
+/**
+ * Model service factory for {@link MockItemPagedDocumentData} (paged page documents).
+ *
+ * Returns configurable roles from `context.rolesToReturn`, defaulting to `{ read: true }`. The
+ * page document is the framework envelope (`{ i, c }`); per-entry permissions are not modelled
+ * because entries live inside the page array, not as standalone documents.
+ */ var mockItemPagedFirebaseModelServiceFactory = firebase.firebaseModelServiceFactory({
+    roleMapForModel: function roleMapForModel(output, context, _model) {
+        var _context_rolesToReturn;
+        var roles = (_context_rolesToReturn = context.rolesToReturn) !== null && _context_rolesToReturn !== void 0 ? _context_rolesToReturn : {
+            read: true
+        };
+        return roles;
+    },
+    getFirestoreCollection: function getFirestoreCollection(c) {
+        return c.app.mockItemPagedCollectionGroup;
+    }
+});
 /**
  * Model service factory for {@link SystemState}. Only grants access to system admins via {@link grantFullAccessIfAdmin}.
  */ var mockItemSystemStateFirebaseModelServiceFactory = firebase.firebaseModelServiceFactory({
@@ -1877,7 +2016,8 @@ function _class_call_check$4(instance, Constructor) {
     mockItemPrivate: mockItemPrivateFirebaseModelServiceFactory,
     mockItemUser: mockItemUserFirebaseModelServiceFactory,
     mockItemSub: mockItemSubItemFirebaseModelServiceFactory,
-    mockItemSubItemDeep: mockItemSubItemDeepFirebaseModelServiceFactory
+    mockItemSubItemDeep: mockItemSubItemDeepFirebaseModelServiceFactory,
+    mockItemPaged: mockItemPagedFirebaseModelServiceFactory
 };
 /**
  * Composite model service built from {@link MOCK_FIREBASE_MODEL_SERVICE_FACTORIES}.
@@ -3580,6 +3720,894 @@ function _ts_generator$4(thisArg, body) {
                         });
                     });
                 });
+                describe('pagedItemFirestoreCollection (MockItemPaged)', function() {
+                    describe('configuration', function() {
+                        it('exposes indexDocumentId, distributionScheme, and isStaticDistribution flags', function() {
+                            var dynamicCollection = f.instance.collections.mockItemPagedCollectionFactory(itemDocument);
+                            expect(dynamicCollection.indexDocumentId).toBe('_index');
+                            expect(dynamicCollection.isStaticDistribution).toBe(false);
+                            expect(dynamicCollection.distributionScheme).toBeUndefined();
+                            var staticCollection = f.instance.collections.mockItemPagedStaticCollectionFactory(itemDocument);
+                            expect(staticCollection.indexDocumentId).toBe('_index');
+                            expect(staticCollection.isStaticDistribution).toBe(true);
+                            expect(staticCollection.distributionScheme).toBeDefined();
+                        });
+                    });
+                    describe('on an empty collection', function() {
+                        var collection;
+                        beforeEach(function() {
+                            collection = f.instance.collections.mockItemPagedCollectionFactory(itemDocument);
+                        });
+                        describe('loadIndex()', function() {
+                            it('returns undefined when the index document has not been written yet', function() {
+                                return _async_to_generator$4(function() {
+                                    var index;
+                                    return _ts_generator$4(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                return [
+                                                    4,
+                                                    collection.loadIndex()
+                                                ];
+                                            case 1:
+                                                index = _state.sent();
+                                                expect(index).toBeUndefined();
+                                                return [
+                                                    2
+                                                ];
+                                        }
+                                    });
+                                })();
+                            });
+                        });
+                        describe('loadAllItems()', function() {
+                            it('returns an empty array when the index document has not been written yet', function() {
+                                return _async_to_generator$4(function() {
+                                    var items;
+                                    return _ts_generator$4(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                return [
+                                                    4,
+                                                    collection.loadAllItems()
+                                                ];
+                                            case 1:
+                                                items = _state.sent();
+                                                expect(items).toEqual([]);
+                                                return [
+                                                    2
+                                                ];
+                                        }
+                                    });
+                                })();
+                            });
+                        });
+                        describe('loadItemsForPages()', function() {
+                            it('returns an empty array when no pages exist', function() {
+                                return _async_to_generator$4(function() {
+                                    var items;
+                                    return _ts_generator$4(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                return [
+                                                    4,
+                                                    collection.loadItemsForPages([
+                                                        '0',
+                                                        '1'
+                                                    ])
+                                                ];
+                                            case 1:
+                                                items = _state.sent();
+                                                expect(items).toEqual([]);
+                                                return [
+                                                    2
+                                                ];
+                                        }
+                                    });
+                                })();
+                            });
+                            it('returns an empty array when called with no page ids', function() {
+                                return _async_to_generator$4(function() {
+                                    var items;
+                                    return _ts_generator$4(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                return [
+                                                    4,
+                                                    collection.loadItemsForPages([])
+                                                ];
+                                            case 1:
+                                                items = _state.sent();
+                                                expect(items).toEqual([]);
+                                                return [
+                                                    2
+                                                ];
+                                        }
+                                    });
+                                })();
+                            });
+                        });
+                    });
+                    describe('writeAllItems() (dynamic distribution)', function() {
+                        var collection;
+                        beforeEach(function() {
+                            collection = f.instance.collections.mockItemPagedCollectionFactory(itemDocument);
+                        });
+                        it('splits items across pages by maxItemsPerPage and updates the index', function() {
+                            return _async_to_generator$4(function() {
+                                var items, index;
+                                return _ts_generator$4(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            items = [
+                                                {
+                                                    id: '1',
+                                                    group: 'a',
+                                                    value: 1
+                                                },
+                                                {
+                                                    id: '2',
+                                                    group: 'a',
+                                                    value: 2
+                                                },
+                                                {
+                                                    id: '3',
+                                                    group: 'b',
+                                                    value: 3
+                                                },
+                                                {
+                                                    id: '4',
+                                                    group: 'b',
+                                                    value: 4
+                                                },
+                                                {
+                                                    id: '5',
+                                                    group: 'c',
+                                                    value: 5
+                                                }
+                                            ];
+                                            return [
+                                                4,
+                                                collection.writeAllItems(items)
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                collection.loadIndex()
+                                            ];
+                                        case 2:
+                                            index = _state.sent();
+                                            expect(index).toBeDefined();
+                                            expect(index === null || index === void 0 ? void 0 : index.tc).toBe(items.length);
+                                            expect(index === null || index === void 0 ? void 0 : index.p).toEqual([
+                                                '0',
+                                                '1'
+                                            ]);
+                                            expect(index === null || index === void 0 ? void 0 : index.pc).toEqual({
+                                                '0': MOCK_ITEM_PAGED_DEFAULT_MAX_ITEMS_PER_PAGE,
+                                                '1': items.length - MOCK_ITEM_PAGED_DEFAULT_MAX_ITEMS_PER_PAGE
+                                            });
+                                            expect(index === null || index === void 0 ? void 0 : index.u).toBeGreaterThan(0);
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                        it('round-trips items via loadAllItems()', function() {
+                            return _async_to_generator$4(function() {
+                                var items, loaded;
+                                return _ts_generator$4(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            items = Array.from({
+                                                length: 7
+                                            }, function(_, i) {
+                                                return {
+                                                    id: "".concat(i),
+                                                    group: 'a',
+                                                    value: i
+                                                };
+                                            });
+                                            return [
+                                                4,
+                                                collection.writeAllItems(items)
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                collection.loadAllItems()
+                                            ];
+                                        case 2:
+                                            loaded = _state.sent();
+                                            expect(loaded).toHaveLength(items.length);
+                                            expect(loaded.map(function(x) {
+                                                return x.id;
+                                            }).sort()).toEqual(items.map(function(x) {
+                                                return x.id;
+                                            }).sort());
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                        it('writes a single page when items fit within maxItemsPerPage', function() {
+                            return _async_to_generator$4(function() {
+                                var items, index;
+                                return _ts_generator$4(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            items = [
+                                                {
+                                                    id: '1',
+                                                    group: 'a',
+                                                    value: 1
+                                                },
+                                                {
+                                                    id: '2',
+                                                    group: 'a',
+                                                    value: 2
+                                                }
+                                            ];
+                                            return [
+                                                4,
+                                                collection.writeAllItems(items)
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                collection.loadIndex()
+                                            ];
+                                        case 2:
+                                            index = _state.sent();
+                                            expect(index === null || index === void 0 ? void 0 : index.tc).toBe(2);
+                                            expect(index === null || index === void 0 ? void 0 : index.p).toEqual([
+                                                '0'
+                                            ]);
+                                            expect(index === null || index === void 0 ? void 0 : index.pc).toEqual({
+                                                '0': 2
+                                            });
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                        it('writes only the index when given an empty items array', function() {
+                            return _async_to_generator$4(function() {
+                                var index;
+                                return _ts_generator$4(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                collection.writeAllItems([])
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                collection.loadIndex()
+                                            ];
+                                        case 2:
+                                            index = _state.sent();
+                                            expect(index).toBeDefined();
+                                            expect(index === null || index === void 0 ? void 0 : index.tc).toBe(0);
+                                            expect(index === null || index === void 0 ? void 0 : index.p).toEqual([]);
+                                            expect(index === null || index === void 0 ? void 0 : index.pc).toEqual({});
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                        it('shrinks pages and deletes obsolete pages on a smaller rewrite', function() {
+                            return _async_to_generator$4(function() {
+                                var initialItems, initialIndex, smallerItems, newIndex, reloaded, removedPage;
+                                return _ts_generator$4(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            initialItems = Array.from({
+                                                length: 9
+                                            }, function(_, i) {
+                                                return {
+                                                    id: "".concat(i),
+                                                    group: 'a',
+                                                    value: i
+                                                };
+                                            });
+                                            return [
+                                                4,
+                                                collection.writeAllItems(initialItems)
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                collection.loadIndex()
+                                            ];
+                                        case 2:
+                                            initialIndex = _state.sent();
+                                            expect(initialIndex === null || initialIndex === void 0 ? void 0 : initialIndex.p).toEqual([
+                                                '0',
+                                                '1',
+                                                '2'
+                                            ]);
+                                            smallerItems = initialItems.slice(0, 2);
+                                            return [
+                                                4,
+                                                collection.writeAllItems(smallerItems)
+                                            ];
+                                        case 3:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                collection.loadIndex()
+                                            ];
+                                        case 4:
+                                            newIndex = _state.sent();
+                                            expect(newIndex === null || newIndex === void 0 ? void 0 : newIndex.tc).toBe(2);
+                                            expect(newIndex === null || newIndex === void 0 ? void 0 : newIndex.p).toEqual([
+                                                '0'
+                                            ]);
+                                            expect(newIndex === null || newIndex === void 0 ? void 0 : newIndex.pc).toEqual({
+                                                '0': 2
+                                            });
+                                            return [
+                                                4,
+                                                collection.loadAllItems()
+                                            ];
+                                        case 5:
+                                            reloaded = _state.sent();
+                                            expect(reloaded).toHaveLength(2);
+                                            return [
+                                                4,
+                                                collection.loadItemsForPages([
+                                                    '1'
+                                                ])
+                                            ];
+                                        case 6:
+                                            removedPage = _state.sent();
+                                            expect(removedPage).toEqual([]);
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                        it('replaces previously written items on rewrite (no merge)', function() {
+                            return _async_to_generator$4(function() {
+                                var firstItems, replacementItems, reloaded;
+                                return _ts_generator$4(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            firstItems = [
+                                                {
+                                                    id: 'A',
+                                                    group: 'a',
+                                                    value: 1
+                                                },
+                                                {
+                                                    id: 'B',
+                                                    group: 'a',
+                                                    value: 2
+                                                }
+                                            ];
+                                            return [
+                                                4,
+                                                collection.writeAllItems(firstItems)
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            replacementItems = [
+                                                {
+                                                    id: 'C',
+                                                    group: 'a',
+                                                    value: 3
+                                                },
+                                                {
+                                                    id: 'D',
+                                                    group: 'a',
+                                                    value: 4
+                                                }
+                                            ];
+                                            return [
+                                                4,
+                                                collection.writeAllItems(replacementItems)
+                                            ];
+                                        case 2:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                collection.loadAllItems()
+                                            ];
+                                        case 3:
+                                            reloaded = _state.sent();
+                                            expect(reloaded.map(function(x) {
+                                                return x.id;
+                                            }).sort()).toEqual([
+                                                'C',
+                                                'D'
+                                            ]);
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                    });
+                    describe('writeAllItems() with custom maxItemsPerPage', function() {
+                        it('writes one page per item when maxItemsPerPage is 1', function() {
+                            return _async_to_generator$4(function() {
+                                var collection, items, index, reloaded;
+                                return _ts_generator$4(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            collection = f.instance.collections.mockItemPagedCollectionFactoryWithConfig({
+                                                maxItemsPerPage: 1
+                                            })(itemDocument);
+                                            items = Array.from({
+                                                length: 10
+                                            }, function(_, i) {
+                                                return {
+                                                    id: "".concat(i),
+                                                    group: 'a',
+                                                    value: i
+                                                };
+                                            });
+                                            return [
+                                                4,
+                                                collection.writeAllItems(items)
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                collection.loadIndex()
+                                            ];
+                                        case 2:
+                                            index = _state.sent();
+                                            expect(index === null || index === void 0 ? void 0 : index.tc).toBe(items.length);
+                                            expect(index === null || index === void 0 ? void 0 : index.p).toEqual([
+                                                '0',
+                                                '1',
+                                                '2',
+                                                '3',
+                                                '4',
+                                                '5',
+                                                '6',
+                                                '7',
+                                                '8',
+                                                '9'
+                                            ]);
+                                            expect(index === null || index === void 0 ? void 0 : index.pc).toEqual({
+                                                '0': 1,
+                                                '1': 1,
+                                                '2': 1,
+                                                '3': 1,
+                                                '4': 1,
+                                                '5': 1,
+                                                '6': 1,
+                                                '7': 1,
+                                                '8': 1,
+                                                '9': 1
+                                            });
+                                            return [
+                                                4,
+                                                collection.loadAllItems()
+                                            ];
+                                        case 3:
+                                            reloaded = _state.sent();
+                                            expect(reloaded).toHaveLength(items.length);
+                                            expect(reloaded.map(function(x) {
+                                                return x.id;
+                                            }).sort()).toEqual(items.map(function(x) {
+                                                return x.id;
+                                            }).sort());
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                    });
+                    describe('writeAllItems() (static distribution)', function() {
+                        var collection;
+                        beforeEach(function() {
+                            collection = f.instance.collections.mockItemPagedStaticCollectionFactory(itemDocument);
+                        });
+                        it('routes items to scheme-defined page ids', function() {
+                            return _async_to_generator$4(function() {
+                                var items, index;
+                                return _ts_generator$4(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            items = [
+                                                {
+                                                    id: '1',
+                                                    group: 'a',
+                                                    value: 1
+                                                },
+                                                {
+                                                    id: '2',
+                                                    group: 'b',
+                                                    value: 2
+                                                },
+                                                {
+                                                    id: '3',
+                                                    group: 'b',
+                                                    value: 3
+                                                },
+                                                {
+                                                    id: '4',
+                                                    group: 'c',
+                                                    value: 4
+                                                }
+                                            ];
+                                            return [
+                                                4,
+                                                collection.writeAllItems(items)
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                collection.loadIndex()
+                                            ];
+                                        case 2:
+                                            index = _state.sent();
+                                            expect(index === null || index === void 0 ? void 0 : index.tc).toBe(items.length);
+                                            expect(index === null || index === void 0 ? void 0 : index.p).toEqual([
+                                                'a',
+                                                'b',
+                                                'c'
+                                            ]);
+                                            expect(index === null || index === void 0 ? void 0 : index.pc).toEqual({
+                                                a: 1,
+                                                b: 2,
+                                                c: 1
+                                            });
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                        it('omits empty scheme pages from the index', function() {
+                            return _async_to_generator$4(function() {
+                                var items, index;
+                                return _ts_generator$4(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            items = [
+                                                {
+                                                    id: '1',
+                                                    group: 'a',
+                                                    value: 1
+                                                },
+                                                {
+                                                    id: '2',
+                                                    group: 'c',
+                                                    value: 2
+                                                }
+                                            ];
+                                            return [
+                                                4,
+                                                collection.writeAllItems(items)
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                collection.loadIndex()
+                                            ];
+                                        case 2:
+                                            index = _state.sent();
+                                            expect(index === null || index === void 0 ? void 0 : index.p).toEqual([
+                                                'a',
+                                                'c'
+                                            ]);
+                                            expect(index === null || index === void 0 ? void 0 : index.pc).toEqual({
+                                                a: 1,
+                                                c: 1
+                                            });
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                        it('loadItemsForPages() returns only the requested static page', function() {
+                            return _async_to_generator$4(function() {
+                                var _aItems_, items, aItems, bItems;
+                                return _ts_generator$4(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            items = [
+                                                {
+                                                    id: '1',
+                                                    group: 'a',
+                                                    value: 1
+                                                },
+                                                {
+                                                    id: '2',
+                                                    group: 'b',
+                                                    value: 2
+                                                },
+                                                {
+                                                    id: '3',
+                                                    group: 'b',
+                                                    value: 3
+                                                },
+                                                {
+                                                    id: '4',
+                                                    group: 'c',
+                                                    value: 4
+                                                }
+                                            ];
+                                            return [
+                                                4,
+                                                collection.writeAllItems(items)
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                collection.loadItemsForPages([
+                                                    'a'
+                                                ])
+                                            ];
+                                        case 2:
+                                            aItems = _state.sent();
+                                            expect(aItems).toHaveLength(1);
+                                            expect((_aItems_ = aItems[0]) === null || _aItems_ === void 0 ? void 0 : _aItems_.id).toBe('1');
+                                            return [
+                                                4,
+                                                collection.loadItemsForPages([
+                                                    'b'
+                                                ])
+                                            ];
+                                        case 3:
+                                            bItems = _state.sent();
+                                            expect(bItems).toHaveLength(2);
+                                            expect(bItems.map(function(x) {
+                                                return x.id;
+                                            }).sort()).toEqual([
+                                                '2',
+                                                '3'
+                                            ]);
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                        it('loadItemsForPages() returns an empty array for an unwritten scheme page', function() {
+                            return _async_to_generator$4(function() {
+                                var items, missing;
+                                return _ts_generator$4(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            items = [
+                                                {
+                                                    id: '1',
+                                                    group: 'a',
+                                                    value: 1
+                                                }
+                                            ];
+                                            return [
+                                                4,
+                                                collection.writeAllItems(items)
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                collection.loadItemsForPages([
+                                                    'b'
+                                                ])
+                                            ];
+                                        case 2:
+                                            missing = _state.sent();
+                                            expect(missing).toEqual([]);
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                        test.itShouldFail('when distribute() returns a page id outside the scheme', function() {
+                            return _async_to_generator$4(function() {
+                                return _ts_generator$4(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                test.expectFail(function() {
+                                                    return collection.writeAllItems([
+                                                        {
+                                                            id: '1',
+                                                            group: 'z',
+                                                            value: 1
+                                                        }
+                                                    ]);
+                                                })
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                    });
+                    describe('writeAllItemsInTransaction()', function() {
+                        it('writes pages and updates the index inside a transaction', function() {
+                            return _async_to_generator$4(function() {
+                                var collection, items, index, reloaded;
+                                return _ts_generator$4(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            collection = f.instance.collections.mockItemPagedCollectionFactory(itemDocument);
+                                            items = Array.from({
+                                                length: 4
+                                            }, function(_, i) {
+                                                return {
+                                                    id: "".concat(i),
+                                                    group: 'a',
+                                                    value: i
+                                                };
+                                            });
+                                            return [
+                                                4,
+                                                f.parent.firestoreContext.runTransaction(function(transaction) {
+                                                    return _async_to_generator$4(function() {
+                                                        return _ts_generator$4(this, function(_state) {
+                                                            switch(_state.label){
+                                                                case 0:
+                                                                    return [
+                                                                        4,
+                                                                        collection.writeAllItemsInTransaction(transaction, items)
+                                                                    ];
+                                                                case 1:
+                                                                    _state.sent();
+                                                                    return [
+                                                                        2
+                                                                    ];
+                                                            }
+                                                        });
+                                                    })();
+                                                })
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                collection.loadIndex()
+                                            ];
+                                        case 2:
+                                            index = _state.sent();
+                                            expect(index === null || index === void 0 ? void 0 : index.tc).toBe(items.length);
+                                            expect(index === null || index === void 0 ? void 0 : index.p).toEqual([
+                                                '0',
+                                                '1'
+                                            ]);
+                                            return [
+                                                4,
+                                                collection.loadAllItems()
+                                            ];
+                                        case 3:
+                                            reloaded = _state.sent();
+                                            expect(reloaded).toHaveLength(items.length);
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                        it('shrinks and deletes obsolete pages inside a transaction', function() {
+                            return _async_to_generator$4(function() {
+                                var collection, initialItems, initialIndex, smallerItems, newIndex, removedPage;
+                                return _ts_generator$4(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            collection = f.instance.collections.mockItemPagedCollectionFactory(itemDocument);
+                                            initialItems = Array.from({
+                                                length: 7
+                                            }, function(_, i) {
+                                                return {
+                                                    id: "".concat(i),
+                                                    group: 'a',
+                                                    value: i
+                                                };
+                                            });
+                                            return [
+                                                4,
+                                                collection.writeAllItems(initialItems)
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                collection.loadIndex()
+                                            ];
+                                        case 2:
+                                            initialIndex = _state.sent();
+                                            expect(initialIndex === null || initialIndex === void 0 ? void 0 : initialIndex.p).toEqual([
+                                                '0',
+                                                '1',
+                                                '2'
+                                            ]);
+                                            smallerItems = initialItems.slice(0, 2);
+                                            return [
+                                                4,
+                                                f.parent.firestoreContext.runTransaction(function(transaction) {
+                                                    return _async_to_generator$4(function() {
+                                                        return _ts_generator$4(this, function(_state) {
+                                                            switch(_state.label){
+                                                                case 0:
+                                                                    return [
+                                                                        4,
+                                                                        collection.writeAllItemsInTransaction(transaction, smallerItems)
+                                                                    ];
+                                                                case 1:
+                                                                    _state.sent();
+                                                                    return [
+                                                                        2
+                                                                    ];
+                                                            }
+                                                        });
+                                                    })();
+                                                })
+                                            ];
+                                        case 3:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                collection.loadIndex()
+                                            ];
+                                        case 4:
+                                            newIndex = _state.sent();
+                                            expect(newIndex === null || newIndex === void 0 ? void 0 : newIndex.tc).toBe(2);
+                                            expect(newIndex === null || newIndex === void 0 ? void 0 : newIndex.p).toEqual([
+                                                '0'
+                                            ]);
+                                            return [
+                                                4,
+                                                collection.loadItemsForPages([
+                                                    '1'
+                                                ])
+                                            ];
+                                        case 5:
+                                            removedPage = _state.sent();
+                                            expect(removedPage).toEqual([]);
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                    });
+                });
             });
         });
         describe('documentAccessor()', function() {
@@ -12662,11 +13690,13 @@ function _ts_generator(thisArg, body) {
 exports.AUTHORIZED_FIRESTORE_RULES = AUTHORIZED_FIRESTORE_RULES;
 exports.AUTHORIZED_STORAGE_RULES = AUTHORIZED_STORAGE_RULES;
 exports.MOCK_FIREBASE_MODEL_SERVICE_FACTORIES = MOCK_FIREBASE_MODEL_SERVICE_FACTORIES;
+exports.MOCK_ITEM_PAGED_DEFAULT_MAX_ITEMS_PER_PAGE = MOCK_ITEM_PAGED_DEFAULT_MAX_ITEMS_PER_PAGE;
 exports.MOCK_SYSTEM_STATE_TYPE = MOCK_SYSTEM_STATE_TYPE;
 exports.MockItemCollectionFixture = MockItemCollectionFixture;
 exports.MockItemCollectionFixtureInstance = MockItemCollectionFixtureInstance;
 exports.MockItemCollections = MockItemCollections;
 exports.MockItemDocument = MockItemDocument;
+exports.MockItemPagedDocument = MockItemPagedDocument;
 exports.MockItemPrivateDocument = MockItemPrivateDocument;
 exports.MockItemStorageFixture = MockItemStorageFixture;
 exports.MockItemStorageFixtureInstance = MockItemStorageFixtureInstance;
@@ -12709,6 +13739,13 @@ exports.mockItemConverter = mockItemConverter;
 exports.mockItemFirebaseModelServiceFactory = mockItemFirebaseModelServiceFactory;
 exports.mockItemFirestoreCollection = mockItemFirestoreCollection;
 exports.mockItemIdentity = mockItemIdentity;
+exports.mockItemPagedAlphaDistributionScheme = mockItemPagedAlphaDistributionScheme;
+exports.mockItemPagedCollectionReference = mockItemPagedCollectionReference;
+exports.mockItemPagedEntryConverter = mockItemPagedEntryConverter;
+exports.mockItemPagedFirebaseModelServiceFactory = mockItemPagedFirebaseModelServiceFactory;
+exports.mockItemPagedFirestoreCollection = mockItemPagedFirestoreCollection;
+exports.mockItemPagedFirestoreCollectionGroup = mockItemPagedFirestoreCollectionGroup;
+exports.mockItemPagedIdentity = mockItemPagedIdentity;
 exports.mockItemPrivateCollectionReference = mockItemPrivateCollectionReference;
 exports.mockItemPrivateCollectionReferenceFactory = mockItemPrivateCollectionReferenceFactory;
 exports.mockItemPrivateConverter = mockItemPrivateConverter;