@dereekb/firebase 13.11.2 → 13.11.3

package/test/index.esm.js

@@ -1,6 +1,6 @@
 import { performAsyncTasks, cachedGetter, bitwiseObjectDencoder, modelFieldConversions, waitForMs, isEvenNumber, unique, arrayFactory, mapGetter, randomNumberFactory, randomFromArrayFactory, idBatchFactory, arrayContainsDuplicateValue, useCallback, readableStreamToBuffer, SLASH_PATH_SEPARATOR } from '@dereekb/util';
 import { initializeTestEnvironment } from '@firebase/rules-unit-testing';
-import { firebaseStorageContextFactory, firestoreContextFactory, firebaseFirestoreClientDrivers, firebaseStorageClientDrivers, firestoreModelIdentity, snapshotConverterFunctions, firestoreBoolean, optionalFirestoreNumber, optionalFirestoreDate, optionalFirestoreArray, optionalFirestoreString, firestoreDate, firestoreBitwiseObjectMap, firestoreUniqueStringArray, firestoreNumber, firestoreString, firestoreUID, copyUserRelatedDataAccessorFactoryFunction, firestoreSubObject, AbstractFirestoreDocument, AbstractFirestoreDocumentWithParent, firebaseModelServiceFactory, grantFullAccessIfAdmin, firebaseModelsService, systemStateFirestoreCollection, allChildDocumentsUnderParent, where, makeDocuments, getDocumentSnapshotPairs, useDocumentSnapshot, useDocumentSnapshotData, firestoreIdBatchVerifierFactory, limit, orderBy, limitToLast, whereDocumentId, loadAllFirestoreDocumentSnapshotPairs, loadAllFirestoreDocumentSnapshot, iterateFirestoreDocumentSnapshotPairs, iterateFirestoreDocumentSnapshots, iterateFirestoreDocumentSnapshotPairBatches, iterateFirestoreDocumentSnapshotBatches, whereStringHasRootIdentityModelKey, whereStringValueHasPrefix, whereDateIsAfterWithSort, whereDateIsBeforeWithSort, whereDateIsOnOrAfterWithSort, whereDateIsOnOrBeforeWithSort, whereDateIsInRange, whereDateIsBetween, startAt, orderByDocumentId, startAtValue, startAfter, endAt, endAtValue, endBefore, streamFromOnSnapshot, latestSnapshotsFromDocuments, newDocuments, loadDocumentsForDocumentReferences, loadDocumentsForDocumentReferencesFromValues, loadDocumentsForKeys, loadDocumentsForKeysFromValues, loadDocumentsForIds, loadDocumentsForIdsFromValues, firestoreDocumentLoader, setIdAndKeyFromKeyIdRefOnDocumentData, firestoreModelIdFromDocument, firestoreModelIdsFromDocuments, firestoreModelKeyFromDocument, firestoreModelKeysFromDocuments, documentReferenceFromDocument, documentReferencesFromDocuments, limitedFirestoreDocumentAccessorSnapshotCache, mapLatestSnapshotsFromDocuments, streamDocumentSnapshotsData, dataFromDocumentSnapshots, streamDocumentSnapshotDataPairs, streamDocumentSnapshotDataPairsWithData, getDocumentSnapshots, getDocumentSnapshotPair, getDocumentSnapshotDataPair, getDocumentSnapshotDataPairs, getDocumentSnapshotDataPairsWithData, getDocumentSnapshotDataTuples, getDocumentSnapshotData, getDocumentSnapshotsData, getDataFromDocumentSnapshots, loadDocumentsForSnapshots, firestoreDocumentSnapshotPairsLoader, documentData, documentDataFunction, documentDataWithIdAndKey, setIdAndKeyFromSnapshotOnDocumentData, firebaseQuerySnapshotAccumulator, firebaseQueryItemAccumulator, uploadFileWithStream, iterateStorageListFilesByEachFile } from '@dereekb/firebase';
+import { firebaseStorageContextFactory, firestoreContextFactory, firebaseFirestoreClientDrivers, firebaseStorageClientDrivers, firestoreModelIdentity, snapshotConverterFunctions, firestoreBoolean, optionalFirestoreNumber, optionalFirestoreDate, optionalFirestoreArray, optionalFirestoreString, firestoreDate, firestoreBitwiseObjectMap, firestoreUniqueStringArray, firestoreNumber, firestoreString, firestoreUID, copyUserRelatedDataAccessorFactoryFunction, firestoreSubObject, defaultPagedItemPageDataConverter, AbstractFirestoreDocument, AbstractFirestoreDocumentWithParent, firebaseModelServiceFactory, grantFullAccessIfAdmin, firebaseModelsService, systemStateFirestoreCollection, allChildDocumentsUnderParent, where, makeDocuments, getDocumentSnapshotPairs, useDocumentSnapshot, useDocumentSnapshotData, firestoreIdBatchVerifierFactory, limit, orderBy, limitToLast, whereDocumentId, loadAllFirestoreDocumentSnapshotPairs, loadAllFirestoreDocumentSnapshot, iterateFirestoreDocumentSnapshotPairs, iterateFirestoreDocumentSnapshots, iterateFirestoreDocumentSnapshotPairBatches, iterateFirestoreDocumentSnapshotBatches, whereStringHasRootIdentityModelKey, whereStringValueHasPrefix, whereDateIsAfterWithSort, whereDateIsBeforeWithSort, whereDateIsOnOrAfterWithSort, whereDateIsOnOrBeforeWithSort, whereDateIsInRange, whereDateIsBetween, startAt, orderByDocumentId, startAtValue, startAfter, endAt, endAtValue, endBefore, streamFromOnSnapshot, latestSnapshotsFromDocuments, newDocuments, loadDocumentsForDocumentReferences, loadDocumentsForDocumentReferencesFromValues, loadDocumentsForKeys, loadDocumentsForKeysFromValues, loadDocumentsForIds, loadDocumentsForIdsFromValues, firestoreDocumentLoader, setIdAndKeyFromKeyIdRefOnDocumentData, firestoreModelIdFromDocument, firestoreModelIdsFromDocuments, firestoreModelKeyFromDocument, firestoreModelKeysFromDocuments, documentReferenceFromDocument, documentReferencesFromDocuments, limitedFirestoreDocumentAccessorSnapshotCache, mapLatestSnapshotsFromDocuments, streamDocumentSnapshotsData, dataFromDocumentSnapshots, streamDocumentSnapshotDataPairs, streamDocumentSnapshotDataPairsWithData, getDocumentSnapshots, getDocumentSnapshotPair, getDocumentSnapshotDataPair, getDocumentSnapshotDataPairs, getDocumentSnapshotDataPairsWithData, getDocumentSnapshotDataTuples, getDocumentSnapshotData, getDocumentSnapshotsData, getDataFromDocumentSnapshots, loadDocumentsForSnapshots, firestoreDocumentSnapshotPairsLoader, documentData, documentDataFunction, documentDataWithIdAndKey, setIdAndKeyFromSnapshotOnDocumentData, firebaseQuerySnapshotAccumulator, firebaseQueryItemAccumulator, uploadFileWithStream, iterateStorageListFilesByEachFile } from '@dereekb/firebase';
 import { setLogLevel } from 'firebase/firestore';
 import { AbstractTestContextFixture, instanceWrapTestContextFactory, AbstractWrappedFixtureWithInstance, itShouldFail, callbackTest, expectFail } from '@dereekb/util/test';
 import { firstValueFrom, filter, skip, from, first, map, switchMap } from 'rxjs';
@@ -1721,6 +1721,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 = 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;
+}(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: 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.
@@ -1778,6 +1891,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: systemStateFirestoreCollection(firestoreContext, mockItemSystemStateStoredDataConverterMap)
     };
 }
@@ -1855,6 +1976,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 = 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 = firebaseModelServiceFactory({
@@ -1875,7 +2014,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}.
@@ -3578,6 +3718,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
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                        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,
+                                                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() {
@@ -12657,4 +13685,4 @@ function _ts_generator(thisArg, body) {
     });
 }
 
-export { AUTHORIZED_FIRESTORE_RULES, AUTHORIZED_STORAGE_RULES, MOCK_FIREBASE_MODEL_SERVICE_FACTORIES, MOCK_SYSTEM_STATE_TYPE, MockItemCollectionFixture, MockItemCollectionFixtureInstance, MockItemCollections, MockItemDocument, MockItemPrivateDocument, MockItemSettingsItemEnum, MockItemStorageFixture, MockItemStorageFixtureInstance, MockItemSubItemDeepDocument, MockItemSubItemDocument, MockItemUserDocument, RulesUnitTestFirebaseTestingContextFixture, RulesUnitTestTestFirebaseInstance, TESTING_AUTHORIZED_FIREBASE_USER_ID, TestFirebaseContextFixture, TestFirebaseInstance, TestFirebaseStorageContextFixture, TestFirebaseStorageInstance, TestFirestoreContextFixture, TestFirestoreInstance, allChildMockItemSubItemDeepsWithinMockItem, authorizedFirebaseFactory, authorizedFirestoreOnlyFactory, authorizedTestWithMockItemCollection, authorizedTestWithMockItemStorage, changeFirestoreLogLevelBeforeAndAfterTests, clearTestFirestoreContextCollections, describeFirebaseStorageAccessorDriverTests, describeFirestoreAccessorDriverTests, describeFirestoreDocumentAccessorTests, describeFirestoreDocumentUtilityTests, describeFirestoreIterationTests, describeFirestoreQueryDriverTests, firebaseRulesUnitTestBuilder, makeMockItemCollections, makeRulesTestFirebaseStorageContext, makeRulesTestFirestoreContext, makeTestingFirebaseStorageAccesorDriver, makeTestingFirebaseStorageDrivers, makeTestingFirestoreAccesorDriver, makeTestingFirestoreDrivers, mockFirebaseModelServices, mockItemCollectionReference, mockItemConverter, mockItemFirebaseModelServiceFactory, mockItemFirestoreCollection, mockItemIdentity, mockItemPrivateCollectionReference, mockItemPrivateCollectionReferenceFactory, mockItemPrivateConverter, mockItemPrivateFirebaseModelServiceFactory, mockItemPrivateFirestoreCollection, mockItemPrivateFirestoreCollectionGroup, mockItemPrivateIdentity, mockItemSettingsItemDencoder, mockItemSubItemCollectionReference, mockItemSubItemCollectionReferenceFactory, mockItemSubItemConverter, mockItemSubItemDeepCollectionReference, mockItemSubItemDeepCollectionReferenceFactory, mockItemSubItemDeepConverter, mockItemSubItemDeepFirebaseModelServiceFactory, mockItemSubItemDeepFirestoreCollection, mockItemSubItemDeepFirestoreCollectionGroup, mockItemSubItemDeepIdentity, mockItemSubItemFirebaseModelServiceFactory, mockItemSubItemFirestoreCollection, mockItemSubItemFirestoreCollectionGroup, mockItemSubItemIdentity, mockItemSystemDataConverter, mockItemSystemStateFirebaseModelServiceFactory, mockItemSystemStateStoredDataConverterMap, mockItemUserAccessorFactory, mockItemUserCollectionName, mockItemUserCollectionReference, mockItemUserCollectionReferenceFactory, mockItemUserConverter, mockItemUserFirebaseModelServiceFactory, mockItemUserFirestoreCollection, mockItemUserFirestoreCollectionGroup, mockItemUserIdentifier, mockItemUserIdentity, mockItemWithTestValue, mockItemWithValue, testWithMockItemCollectionFixture, testWithMockItemStorageFixture };
+export { AUTHORIZED_FIRESTORE_RULES, AUTHORIZED_STORAGE_RULES, MOCK_FIREBASE_MODEL_SERVICE_FACTORIES, MOCK_ITEM_PAGED_DEFAULT_MAX_ITEMS_PER_PAGE, MOCK_SYSTEM_STATE_TYPE, MockItemCollectionFixture, MockItemCollectionFixtureInstance, MockItemCollections, MockItemDocument, MockItemPagedDocument, MockItemPrivateDocument, MockItemSettingsItemEnum, MockItemStorageFixture, MockItemStorageFixtureInstance, MockItemSubItemDeepDocument, MockItemSubItemDocument, MockItemUserDocument, RulesUnitTestFirebaseTestingContextFixture, RulesUnitTestTestFirebaseInstance, TESTING_AUTHORIZED_FIREBASE_USER_ID, TestFirebaseContextFixture, TestFirebaseInstance, TestFirebaseStorageContextFixture, TestFirebaseStorageInstance, TestFirestoreContextFixture, TestFirestoreInstance, allChildMockItemSubItemDeepsWithinMockItem, authorizedFirebaseFactory, authorizedFirestoreOnlyFactory, authorizedTestWithMockItemCollection, authorizedTestWithMockItemStorage, changeFirestoreLogLevelBeforeAndAfterTests, clearTestFirestoreContextCollections, describeFirebaseStorageAccessorDriverTests, describeFirestoreAccessorDriverTests, describeFirestoreDocumentAccessorTests, describeFirestoreDocumentUtilityTests, describeFirestoreIterationTests, describeFirestoreQueryDriverTests, firebaseRulesUnitTestBuilder, makeMockItemCollections, makeRulesTestFirebaseStorageContext, makeRulesTestFirestoreContext, makeTestingFirebaseStorageAccesorDriver, makeTestingFirebaseStorageDrivers, makeTestingFirestoreAccesorDriver, makeTestingFirestoreDrivers, mockFirebaseModelServices, mockItemCollectionReference, mockItemConverter, mockItemFirebaseModelServiceFactory, mockItemFirestoreCollection, mockItemIdentity, mockItemPagedAlphaDistributionScheme, mockItemPagedCollectionReference, mockItemPagedEntryConverter, mockItemPagedFirebaseModelServiceFactory, mockItemPagedFirestoreCollection, mockItemPagedFirestoreCollectionGroup, mockItemPagedIdentity, mockItemPrivateCollectionReference, mockItemPrivateCollectionReferenceFactory, mockItemPrivateConverter, mockItemPrivateFirebaseModelServiceFactory, mockItemPrivateFirestoreCollection, mockItemPrivateFirestoreCollectionGroup, mockItemPrivateIdentity, mockItemSettingsItemDencoder, mockItemSubItemCollectionReference, mockItemSubItemCollectionReferenceFactory, mockItemSubItemConverter, mockItemSubItemDeepCollectionReference, mockItemSubItemDeepCollectionReferenceFactory, mockItemSubItemDeepConverter, mockItemSubItemDeepFirebaseModelServiceFactory, mockItemSubItemDeepFirestoreCollection, mockItemSubItemDeepFirestoreCollectionGroup, mockItemSubItemDeepIdentity, mockItemSubItemFirebaseModelServiceFactory, mockItemSubItemFirestoreCollection, mockItemSubItemFirestoreCollectionGroup, mockItemSubItemIdentity, mockItemSystemDataConverter, mockItemSystemStateFirebaseModelServiceFactory, mockItemSystemStateStoredDataConverterMap, mockItemUserAccessorFactory, mockItemUserCollectionName, mockItemUserCollectionReference, mockItemUserCollectionReferenceFactory, mockItemUserConverter, mockItemUserFirebaseModelServiceFactory, mockItemUserFirestoreCollection, mockItemUserFirestoreCollectionGroup, mockItemUserIdentifier, mockItemUserIdentity, mockItemWithTestValue, mockItemWithValue, testWithMockItemCollectionFixture, testWithMockItemStorageFixture };