shelving 1.26.0 → 1.29.0

package/api/Resource.js

@@ -1,4 +1,4 @@
-import { UNDEFINED, validate } from "../util/index.js";
+import { GET_UNDEFINED, validate } from "../util/index.js";
 import { Feedback } from "../feedback/index.js";
 import { ResourceValidationError } from "./errors.js";
 /**
@@ -37,6 +37,6 @@ export class Resource {
         }
     }
 }
-export function RESOURCE(payload = UNDEFINED, result = UNDEFINED) {
+export function RESOURCE(payload = GET_UNDEFINED, result = GET_UNDEFINED) {
     return new Resource(payload, result);
 }

package/db/Database.d.ts

@@ -1,8 +1,8 @@
-import { Entry, Observable, Observer, Result, Unsubscriber, ResultsMap, Validatable, Validator, Key, Data, Results, Datas, Validators, ValidatorType, Dispatcher } from "../util/index.js";
+import { Entry, Observable, Observer, Result, Unsubscriber, ResultsMap, Validatable, Validator, Key, Data, Results, Datas, Validators, ValidatorType, Dispatcher, Nullish } from "../util/index.js";
 import { PropUpdates, Update } from "../update/index.js";
 import type { Provider } from "../provider/Provider.js";
 import { Filters, Sorts, Query } from "../query/index.js";
-import { DocumentDelete, DocumentSet, DocumentUpdate, Write, Writes } from "./Write.js";
+import { DocumentDelete, DocumentSet, DocumentUpdate, Write } from "./Write.js";
 /**
  * Combines a database model and a provider.
  *
@@ -18,10 +18,10 @@ export declare class Database<V extends Validators<Datas> = Validators<Datas>> {
     query<K extends Key<V>>(collection: K, filters?: Filters<ValidatorType<V[K]>>, sorts?: Sorts<ValidatorType<V[K]>>, limit?: number | null): DataQuery<ValidatorType<V[K]>>;
     /** Reference a document in a collection in this model. */
     doc<K extends Key<V>>(collection: K, id: string): DataDocument<ValidatorType<V[K]>>;
-    /** Perform a write on this database and return the `Write` instance representing the changes. */
-    write(write: Write): Promise<Write>;
-    /** Perform multiple writes on this database by combining them into a single `Writes` instance representing the changes. */
-    writes(...writes: (Write | undefined)[]): Promise<Writes>;
+    /** Create a writer for this database from a set of separate writes. */
+    writer(...writes: Nullish<Write>[]): Write;
+    /** Perform one or more writes on this database and return the `Writes` instance representing the combined changes. */
+    write(...writes: Nullish<Write>[]): Promise<Write>;
 }
 /** A documents reference within a specific database. */
 export declare class DataQuery<T extends Data = Data> extends Query<T> implements Observable<Results<T>>, Validatable<Results<T>>, Iterable<Entry<T>> {
@@ -81,19 +81,19 @@ export declare class DataQuery<T extends Data = Data> extends Query<T> implement
      * @param data Complete data to set the document to.
      * @return Nothing (possibly promised).
      */
-    set(data: T): void | PromiseLike<void>;
+    set(data: T): number | PromiseLike<number>;
     /**
      * Update all matching documents with the same partial value.
      *
      * @param updates `Update` instance or set of updates to apply to every matching document.
      * @return Nothing (possibly promised).
      */
-    update(updates: Update<T> | PropUpdates<T>): void | PromiseLike<void>;
+    update(updates: Update<T> | PropUpdates<T>): number | PromiseLike<number>;
     /**
      * Delete all matching documents.
      * @return Nothing (possibly promised).
      */
-    delete(): void | PromiseLike<void>;
+    delete(): number | PromiseLike<number>;
     /** Iterate over the resuls (will throw `Promise` if the results are asynchronous). */
     [Symbol.iterator](): Iterator<Entry<T>, void>;
     /** Validate a set of results for this query reference. */

package/db/Database.js

@@ -1,4 +1,4 @@
-import { callAsync, getFirstItem, throwAsync, validate, toMap, countItems, TransformObserver, } from "../util/index.js";
+import { callAsync, getFirstItem, throwAsync, validate, toMap, countItems, TransformObserver, NOT_NULLISH, } from "../util/index.js";
 import { DataUpdate, Update } from "../update/index.js";
 import { Feedback, InvalidFeedback } from "../feedback/index.js";
 import { Filters, Query, EqualFilter } from "../query/index.js";
@@ -25,14 +25,13 @@ export class Database {
     doc(collection, id) {
         return new DataDocument(this.provider, this.validators[collection], collection, id);
     }
-    /** Perform a write on this database and return the `Write` instance representing the changes. */
-    async write(write) {
-        await write.transform(this);
-        return write;
+    /** Create a writer for this database from a set of separate writes. */
+    writer(...writes) {
+        return new Writes(...writes.filter(NOT_NULLISH));
     }
-    /** Perform multiple writes on this database by combining them into a single `Writes` instance representing the changes. */
-    async writes(...writes) {
-        const write = new Writes(...writes);
+    /** Perform one or more writes on this database and return the `Writes` instance representing the combined changes. */
+    async write(...writes) {
+        const write = new Writes(...writes.filter(NOT_NULLISH));
         await write.transform(this);
         return write;
     }

package/db/Pagination.d.ts

@@ -7,23 +7,15 @@ import { DataQuery } from "./Database.js";
  * - If you don't pass in initial values, it will autoload the first page.
  */
 export declare class Pagination<T extends Data> extends State<ResultsMap<T>> implements Iterable<Entry<T>> {
+    protected _pending: boolean;
     readonly ref: DataQuery<T>;
     readonly limit: number;
-    readonly startLoading: boolean;
-    readonly startDone: boolean;
-    readonly endLoading: boolean;
-    readonly endDone: boolean;
     constructor(ref: DataQuery<T>);
-    /**
-     * Load more results before the start.
-     * - Promise that needs to be handled.
-     */
-    loadStart: () => Promise<void>;
     /**
      * Load more results after the end.
      * - Promise that needs to be handled.
      */
-    loadEnd: () => Promise<void>;
+    more: () => Promise<void>;
     /**
      * Merge more results into this pagination.
      * @return The change in the number of results.

package/db/Pagination.js

@@ -1,4 +1,4 @@
-import { getFirstItem, getLastItem, assertLength, assertNumber, yieldMerged, toMap } from "../util/index.js";
+import { getLastItem, assertLength, assertNumber, yieldMerged, toMap, LOADING } from "../util/index.js";
 import { State } from "../stream/index.js";
 import { ConditionError } from "../index.js";
 /**
@@ -9,56 +9,33 @@ import { ConditionError } from "../index.js";
 export class Pagination extends State {
     constructor(ref) {
         super();
-        this.startLoading = false;
-        this.startDone = false;
-        this.endLoading = false;
-        this.endDone = false;
-        /**
-         * Load more results before the start.
-         * - Promise that needs to be handled.
-         */
-        this.loadStart = async () => {
-            if (this.closed)
-                throw new ConditionError();
-            if (!this.startLoading) {
-                this.startLoading = true;
-                if (!this.loading) {
-                    const firstItem = getFirstItem(this.value);
-                    if (firstItem) {
-                        const next = await this.ref.after(firstItem[0], firstItem[1]).resultsMap;
-                        this.startDone = next.size < this.limit;
-                        this.startLoading = false;
-                        return this.merge(next);
-                    }
-                }
-                const next = await this.ref.resultsMap;
-                this.startDone = next.size < this.limit;
-                this.startLoading = false;
-                return this.next(next);
-            }
-        };
+        this._pending = false; // Prevents double-loading.
         /**
          * Load more results after the end.
          * - Promise that needs to be handled.
          */
-        this.loadEnd = async () => {
+        this.more = async () => {
             if (this.closed)
-                throw new ConditionError();
-            if (!this.endLoading) {
-                this.endLoading = true;
+                throw new ConditionError("Pagination is closed");
+            if (!this._pending) {
+                this._pending = true;
                 if (!this.loading) {
                     const lastItem = getLastItem(this.value);
                     if (lastItem) {
                         const next = await this.ref.after(lastItem[0], lastItem[1]).resultsMap;
-                        this.endDone = next.size < this.limit;
-                        this.endLoading = false;
-                        return this.merge(next);
+                        this.merge(next);
+                        if (next.size < this.limit)
+                            this.complete();
+                        this._pending = false;
+                        return;
                     }
                 }
+                this._value === LOADING;
                 const next = await this.ref.resultsMap;
-                this.endDone = next.size < this.limit;
-                this.endLoading = false;
-                return this.next(next);
+                this.next(next);
+                if (next.size < this.limit)
+                    this.complete();
+                this._pending = false;
             }
         };
         this.ref = ref;

package/db/Write.d.ts

@@ -12,7 +12,7 @@ export declare abstract class Write implements Transformable<Database, void | Pr
  */
 export declare class Writes extends Write {
     readonly writes: ImmutableArray<Write>;
-    constructor(...writes: (Write | undefined)[]);
+    constructor(...writes: Write[]);
     transform(db: Database): Promise<void>;
 }
 /** Represent a write made to a single document in a database. */

package/db/Write.js

@@ -1,5 +1,5 @@
 import { DataUpdate, Update } from "../update/index.js";
-import { transform, IS_DEFINED } from "../util/index.js";
+import { transform } from "../util/index.js";
 /** Represent a write made to a database. */
 export class Write {
 }
@@ -11,7 +11,7 @@ export class Write {
 export class Writes extends Write {
     constructor(...writes) {
         super();
-        this.writes = writes.filter(IS_DEFINED);
+        this.writes = writes;
     }
     async transform(db) {
         for (const writes of this.writes)

package/firestore/client/FirestoreClientProvider.d.ts

@@ -17,7 +17,7 @@ export declare class FirestoreClientProvider extends Provider implements Asynchr
     delete<T extends Data>(ref: DataDocument<T>): Promise<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
     subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T): Promise<void>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<void>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<void>;
+    setQuery<T extends Data>(ref: DataQuery<T>, data: T): Promise<number>;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<number>;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<number>;
 }

package/firestore/client/FirestoreClientProvider.js

@@ -109,22 +109,18 @@ export class FirestoreClientProvider extends Provider {
     }
     async setQuery(ref, data) {
         const snapshot = await getDocs(getQuery(this.firestore, ref));
-        if (data instanceof Update) {
-            const updates = getFieldValues(data);
-            await Promise.all(snapshot.docs.map(s => updateDoc(s.ref, updates)));
-        }
-        else if (data)
-            await Promise.all(snapshot.docs.map(s => setDoc(s.ref, data)));
-        else
-            await Promise.all(snapshot.docs.map(s => deleteDoc(s.ref)));
+        await Promise.all(snapshot.docs.map(s => setDoc(s.ref, data)));
+        return snapshot.size;
     }
     async updateQuery(ref, updates) {
         const snapshot = await getDocs(getQuery(this.firestore, ref));
         const fieldValues = getFieldValues(updates);
         await Promise.all(snapshot.docs.map(s => updateDoc(s.ref, fieldValues)));
+        return snapshot.size;
     }
     async deleteQuery(ref) {
         const snapshot = await getDocs(getQuery(this.firestore, ref));
         await Promise.all(snapshot.docs.map(s => deleteDoc(s.ref)));
+        return snapshot.size;
     }
 }

package/firestore/lite/FirestoreLiteProvider.d.ts

@@ -17,7 +17,7 @@ export declare class FirestoreClientProvider extends Provider implements Asynchr
     delete<T extends Data>(ref: DataDocument<T>): Promise<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
     subscribeQuery(): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T | Update<T> | undefined): Promise<void>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<void>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<void>;
+    setQuery<T extends Data>(ref: DataQuery<T>, data: T | Update<T> | undefined): Promise<number>;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<number>;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<number>;
 }

package/firestore/lite/FirestoreLiteProvider.js

@@ -110,14 +110,17 @@ export class FirestoreClientProvider extends Provider {
     async setQuery(ref, data) {
         const snapshot = await getDocs(getQuery(this.firestore, ref));
         await Promise.all(snapshot.docs.map(s => setDoc(s.ref, data)));
+        return snapshot.size;
     }
     async updateQuery(ref, updates) {
         const snapshot = await getDocs(getQuery(this.firestore, ref));
         const fieldValues = getFieldValues(updates);
         await Promise.all(snapshot.docs.map(s => updateDoc(s.ref, fieldValues)));
+        return snapshot.size;
     }
     async deleteQuery(ref) {
         const snapshot = await getDocs(getQuery(this.firestore, ref));
         await Promise.all(snapshot.docs.map(s => deleteDoc(s.ref)));
+        return snapshot.size;
     }
 }

package/firestore/server/FirestoreServerProvider.d.ts

@@ -15,7 +15,7 @@ export declare class FirestoreServerProvider extends Provider implements Asynchr
     delete<T extends Data>(ref: DataDocument<T>): Promise<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): Promise<Iterable<Entry<T>>>;
     subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T | Update<T> | undefined): Promise<void>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<void>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<void>;
+    setQuery<T extends Data>(ref: DataQuery<T>, data: T | Update<T> | undefined): Promise<number>;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<number>;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<number>;
 }

package/firestore/server/FirestoreServerProvider.js

@@ -104,28 +104,31 @@ export class FirestoreServerProvider extends Provider {
         return getQuery(this.firestore, ref).onSnapshot(snapshot => dispatchNext(observer, getResults(snapshot)), thrown => dispatchError(observer, thrown));
     }
     async setQuery(ref, data) {
-        await bulkWrite(this.firestore, ref, (w, s) => void w.set(s.ref, data));
+        return await bulkWrite(this.firestore, ref, (w, s) => void w.set(s.ref, data));
     }
     async updateQuery(ref, updates) {
         const fieldValues = getFieldValues(updates);
-        await bulkWrite(this.firestore, ref, (w, s) => void w.update(s.ref, fieldValues));
+        return await bulkWrite(this.firestore, ref, (w, s) => void w.update(s.ref, fieldValues));
     }
     async deleteQuery(ref) {
-        await bulkWrite(this.firestore, ref, (w, s) => void w.delete(s.ref));
+        return await bulkWrite(this.firestore, ref, (w, s) => void w.delete(s.ref));
     }
 }
 /** Perform a bulk update on a set of documents using a `BulkWriter` */
 async function bulkWrite(firestore, ref, callback) {
+    let count = 0;
     const writer = firestore.bulkWriter();
     const query = getQuery(firestore, ref).limit(BATCH_SIZE).select(); // `select()` turs the query into a field mask query (with no field masks) which saves data transfer and memory.
     let current = query;
     while (current) {
-        const snapshot = await current.get();
-        for (const s of snapshot.docs)
+        const { docs, size } = await current.get();
+        count += size;
+        for (const s of docs)
             callback(writer, s);
-        current = snapshot.size >= BATCH_SIZE && query.startAfter(snapshot.docs.pop()).select();
+        current = size >= BATCH_SIZE && query.startAfter(docs.pop()).select();
         void writer.flush();
     }
     await writer.close();
+    return count;
 }
 const BATCH_SIZE = 1000;

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.26.0",
+	"version": "1.29.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/provider/CacheProvider.d.ts

@@ -27,9 +27,9 @@ export declare class CacheProvider extends ThroughProvider implements Asynchrono
     private _cacheResults;
     getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
     subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T): Promise<void>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<void>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<void>;
+    setQuery<T extends Data>(ref: DataQuery<T>, data: T): Promise<number>;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<number>;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<number>;
     /** Reset this provider and clear all data. */
     reset(): void;
 }

package/provider/CacheProvider.js

@@ -79,16 +79,19 @@ export class CacheProvider extends ThroughProvider {
         return super.subscribeQuery(ref, new TransformObserver(results => this._cacheResults(ref, results), observer));
     }
     async setQuery(ref, data) {
-        await super.setQuery(ref, data);
+        const count = await super.setQuery(ref, data);
         this.cache.setQuery(ref, data);
+        return count;
     }
     async updateQuery(ref, updates) {
-        await super.updateQuery(ref, updates);
+        const count = await super.updateQuery(ref, updates);
         this.cache.updateQuery(ref, updates);
+        return count;
     }
     async deleteQuery(ref) {
-        await super.deleteQuery(ref);
+        const count = await super.deleteQuery(ref);
         this.cache.deleteQuery(ref);
+        return count;
     }
     /** Reset this provider and clear all data. */
     reset() {

package/provider/MemoryProvider.d.ts

@@ -19,9 +19,9 @@ export declare class MemoryProvider extends Provider implements SynchronousProvi
     delete<T extends Data>(ref: DataDocument<T>): void;
     getQuery<T extends Data>(ref: DataQuery<T>): Results<T>;
     subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T): void;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): void;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): void;
+    setQuery<T extends Data>(ref: DataQuery<T>, data: T): number;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): number;
     /** Reset this provider and clear all data. */
     reset(): void;
 }

package/provider/MemoryProvider.js

@@ -86,22 +86,34 @@ export class MemoryProvider extends Provider {
         const table = this._table(ref);
         // If there's a limit set: run the full query.
         // If there's no limit set: only need to run the filtering (more efficient because sort order doesn't matter).
-        for (const [id] of ref.limit ? ref.transform(table.data) : ref.filters.transform(table.data))
+        let count = 0;
+        for (const [id] of ref.limit ? ref.transform(table.data) : ref.filters.transform(table.data)) {
             table.write(id, data);
+            count++;
+        }
+        return count;
     }
     updateQuery(ref, updates) {
         const table = this._table(ref);
         // If there's a limit set: run the full query.
         // If there's no limit set: only need to run the filtering (more efficient because sort order doesn't matter).
-        for (const [id, existing] of ref.limit ? ref.transform(table.data) : ref.filters.transform(table.data))
+        let count = 0;
+        for (const [id, existing] of ref.limit ? ref.transform(table.data) : ref.filters.transform(table.data)) {
             table.write(id, updates.transform(existing));
+            count++;
+        }
+        return count;
     }
     deleteQuery(ref) {
         const table = this._table(ref);
         // If there's a limit set: run the full query.
         // If there's no limit set: only need to run the filtering (more efficient because sort order doesn't matter).
-        for (const [id] of ref.limit ? ref.transform(table.data) : ref.filters.transform(table.data))
+        let count = 0;
+        for (const [id] of ref.limit ? ref.transform(table.data) : ref.filters.transform(table.data)) {
             table.write(id, undefined);
+            count++;
+        }
+        return count;
     }
     /** Reset this provider and clear all data. */
     reset() {

package/provider/Provider.d.ts

@@ -77,20 +77,23 @@ export declare abstract class Provider {
      *
      * @param ref Documents reference specifying which collection to set.
      * @param value Value to set the document to.
+     * @return Number of documents that were set.
      */
-    abstract setQuery<T extends Data>(ref: DataQuery<T>, data: T): void | PromiseLike<void>;
+    abstract setQuery<T extends Data>(ref: DataQuery<T>, data: T): number | PromiseLike<number>;
     /**
      * Update the data of all matching documents.
      *
      * @param ref Documents reference specifying which collection to set.
      * @param updates Update instance to set the document to.
+     * @return Number of documents that were updated.
      */
-    abstract updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): void | PromiseLike<void>;
+    abstract updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number | PromiseLike<number>;
     /**
      * Delete all matching documents.
      * @param ref Document reference specifying which document to delete.
+     * @return Number of documents that were deleted.
      */
-    abstract deleteQuery<T extends Data>(ref: DataQuery<T>): void | PromiseLike<void>;
+    abstract deleteQuery<T extends Data>(ref: DataQuery<T>): number | PromiseLike<number>;
 }
 /** Provider with a fully synchronous interface */
 export interface SynchronousProvider extends Provider {
@@ -100,9 +103,9 @@ export interface SynchronousProvider extends Provider {
     update<T extends Data>(ref: DataDocument<T>, value: Update<T>): void;
     delete<T extends Data>(ref: DataDocument<T>): void;
     getQuery<T extends Data>(ref: DataQuery<T>): Results<T>;
-    setQuery<T extends Data>(ref: DataQuery<T>, value: T): void;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): void;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): void;
+    setQuery<T extends Data>(ref: DataQuery<T>, value: T): number;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): number;
 }
 /** Provider with a fully asynchronous interface */
 export interface AsynchronousProvider extends Provider {
@@ -112,7 +115,7 @@ export interface AsynchronousProvider extends Provider {
     update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): PromiseLike<void>;
     delete<T extends Data>(ref: DataDocument<T>): PromiseLike<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): PromiseLike<Results<T>>;
-    setQuery<T extends Data>(ref: DataQuery<T>, value: T): PromiseLike<void>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): PromiseLike<void>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): PromiseLike<void>;
+    setQuery<T extends Data>(ref: DataQuery<T>, value: T): PromiseLike<number>;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): PromiseLike<number>;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): PromiseLike<number>;
 }

package/provider/ThroughProvider.d.ts

@@ -16,9 +16,9 @@ export declare class ThroughProvider extends Provider {
     delete<T extends Data>(ref: DataDocument<T>): void | PromiseLike<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): Results<T> | PromiseLike<Results<T>>;
     subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T): void | PromiseLike<void>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): void | PromiseLike<void>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): void | PromiseLike<void>;
+    setQuery<T extends Data>(ref: DataQuery<T>, data: T): number | PromiseLike<number>;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number | PromiseLike<number>;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): number | PromiseLike<number>;
 }
 /** Find a specific source provider in a database's provider stack. */
 export declare function findSourceProvider<P extends Provider>(provider: Provider, type: Class<P>): P;

package/provider/ValidationProvider.d.ts

@@ -11,6 +11,6 @@ export declare class ValidationProvider extends ThroughProvider {
     update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): void | PromiseLike<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): Results<T> | PromiseLike<Results<T>>;
     subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, value: T): void | PromiseLike<void>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): void | PromiseLike<void>;
+    setQuery<T extends Data>(ref: DataQuery<T>, value: T): number | PromiseLike<number>;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number | PromiseLike<number>;
 }

package/stream/DataState.d.ts

@@ -1,9 +1,24 @@
-import { Key, Data, PropTransformers } from "../util/index.js";
+import { Key, Data, PropTransformers, Result } from "../util/index.js";
 import { State } from "./State.js";
-/** State that stores an array and has additional methods to help with that. */
+/** State that stores a data object and has additional methods to help with that. */
 export declare class DataState<T extends Data> extends State<T> {
+    /** Get the data value of this state. */
+    get data(): T;
     /** Set a prop in this object to a new value. */
     set<K extends Key<T>>(key: K, value: T[K]): void;
     /** Update several props in this object. */
     update(updates: PropTransformers<T>): void;
 }
+/** State that stores an optional data object and has additional methods to help with that. */
+export declare class ResultState<T extends Data> extends State<Result<T>> {
+    /** Get the result value of this state. */
+    get result(): Result<T>;
+    /** Get current data value of this state (or throw `Promise` that resolves to the next required value). */
+    get data(): T;
+    /** Set a prop in this object to a new value. */
+    set<K extends Key<T>>(key: K, value: T[K]): void;
+    /** Update several props in this object. */
+    update(updates: PropTransformers<T>): void;
+    /** Delete this result. */
+    delete(): void;
+}

package/stream/DataState.js

@@ -1,13 +1,44 @@
-import { withProp, transformData } from "../util/index.js";
+import { withProp, transformData, NOERROR, LOADING, awaitNext, getData } from "../util/index.js";
 import { State } from "./State.js";
-/** State that stores an array and has additional methods to help with that. */
+/** State that stores a data object and has additional methods to help with that. */
 export class DataState extends State {
+    /** Get the data value of this state. */
+    get data() {
+        return this.value;
+    }
     /** Set a prop in this object to a new value. */
     set(key, value) {
-        this.next(withProp(this.value, key, value));
+        this.next(withProp(this.data, key, value));
     }
     /** Update several props in this object. */
     update(updates) {
-        this.next(transformData(this.value, updates));
+        this.next(transformData(this.data, updates));
+    }
+}
+/** State that stores an optional data object and has additional methods to help with that. */
+export class ResultState extends State {
+    /** Get the result value of this state. */
+    get result() {
+        return this.value;
+    }
+    /** Get current data value of this state (or throw `Promise` that resolves to the next required value). */
+    get data() {
+        if (this.reason !== NOERROR)
+            throw this.reason;
+        if (this._value === LOADING)
+            throw awaitNext(this).then(getData);
+        return getData(this._value);
+    }
+    /** Set a prop in this object to a new value. */
+    set(key, value) {
+        this.next(withProp(this.data, key, value));
+    }
+    /** Update several props in this object. */
+    update(updates) {
+        this.next(transformData(this.data, updates));
+    }
+    /** Delete this result. */
+    delete() {
+        this.next(undefined);
     }
 }

package/stream/State.d.ts

@@ -28,8 +28,6 @@ export declare class State<T> extends Stream<T> {
     /** Most recently dispatched value (or throw `Promise` that resolves to the next value). */
     get value(): T;
     protected _value: T | typeof LOADING;
-    /** Get current required value (or throw `Promise` that resolves to the next required value). */
-    get data(): Exclude<T, null | undefined>;
     /** Is there a current value, or is it still loading. */
     get loading(): boolean;
     /** Apply a transformer to this state. */

package/stream/State.js

@@ -1,5 +1,5 @@
 var _a;
-import { LOADING, NOERROR, dispatchNext, dispatchError, dispatchComplete, transform, getRequired, awaitNext, } from "../util/index.js";
+import { LOADING, NOERROR, dispatchNext, dispatchError, dispatchComplete, transform, awaitNext, } from "../util/index.js";
 import { Stream } from "./Stream.js";
 export class State extends Stream {
     constructor() {
@@ -22,14 +22,6 @@ export class State extends Stream {
             throw awaitNext(this);
         return this._value;
     }
-    /** Get current required value (or throw `Promise` that resolves to the next required value). */
-    get data() {
-        if (this.reason !== NOERROR)
-            throw this.reason;
-        if (this._value === LOADING)
-            throw awaitNext(this).then(getRequired);
-        return getRequired(this._value);
-    }
     /** Is there a current value, or is it still loading. */
     get loading() {
         return this._value === LOADING;

package/util/data.d.ts

@@ -25,9 +25,6 @@ export declare const isData: <T extends Data>(value: unknown) => value is T;
 /** Turn a data object into an array of entries (if it isn't one already). */
 export declare function toProps<T extends Data>(input: T): ImmutableArray<Prop<T>>;
 export declare function toProps<T extends Data>(input: Partial<T>): ImmutableArray<Prop<T>>;
-/** Get a required value (returns value or throws `RequiredError` if value is `null` or `undefined`). */
-export declare function getRequired<T>(v: T): Exclude<T, null | undefined>;
-export declare function getRequired<T>(v: T | null | undefined): T;
 /** Get the data of a result (returns data or throws `RequiredError` if value is `null` or `undefined`). */
 export declare function getData<T extends Data>(result: Result<T>): T;
 /**

package/util/data.js

@@ -4,11 +4,6 @@ export const isData = (value) => typeof value === "object" && value !== null;
 export function toProps(input) {
     return Object.entries(input);
 }
-export function getRequired(v) {
-    if (v === undefined || v === null)
-        throw new RequiredError(v === null ? "Required value is null" : "Required value is undefined");
-    return v;
-}
 /** Get the data of a result (returns data or throws `RequiredError` if value is `null` or `undefined`). */
 export function getData(result) {
     if (!result)

package/util/null.d.ts

@@ -3,4 +3,15 @@ export declare const IS_NULL: (v: unknown) => v is null;
 /** Is a value not null? */
 export declare const NOT_NULL: <T>(v: T | null) => v is T;
 /** Function that always returns null. */
-export declare const NULL: () => null;
+export declare const GET_NULL: () => null;
+/** Nullish is `null` or `undefined` */
+export declare type Nullish<T> = T | null | undefined;
+/** Nullish is `null` or `undefined` */
+export declare type NotNullish<T> = Exclude<T, null | undefined>;
+/** Is a value nullish? */
+export declare const IS_NULLISH: <T>(v: Nullish<T>) => v is null | undefined;
+/** Is a value nullish? */
+export declare const NOT_NULLISH: <T>(v: Nullish<T>) => v is T;
+/** Get a required value (returns value or throws `RequiredError` if value is `null` or `undefined`). */
+export declare function getRequired<T>(v: T): NotNullish<T>;
+export declare function getRequired<T>(v: Nullish<T>): T;

package/util/null.js

@@ -1,6 +1,16 @@
+import { RequiredError } from "../error/index.js";
 /** Is a value null? */
 export const IS_NULL = (v) => v === null;
 /** Is a value not null? */
 export const NOT_NULL = (v) => v !== null;
 /** Function that always returns null. */
-export const NULL = () => null;
+export const GET_NULL = () => null;
+/** Is a value nullish? */
+export const IS_NULLISH = (v) => v === null || v === undefined;
+/** Is a value nullish? */
+export const NOT_NULLISH = (v) => v !== null && v !== undefined;
+export function getRequired(v) {
+    if (v === undefined || v === null)
+        throw new RequiredError("Required value is missing");
+    return v;
+}

package/util/object.d.ts

@@ -87,3 +87,11 @@ export declare function deleteEntry<T>(obj: MutableObject<T>, key: string, value
  * @param entries Set of keys or entries to remove.
  */
 export declare function deleteEntries<T>(obj: MutableObject<T>, keys: ImmutableArray<string>): void;
+/** Type that represents an empty object. */
+export declare type EmptyObject = {
+    readonly [K in never]: never;
+};
+/** An empty object. */
+export declare const EMPTY_OBJECT: EmptyObject;
+/** Function that returns an an empty object. */
+export declare const GET_EMPTY_OBJECT: () => EmptyObject;

package/util/object.js

@@ -98,3 +98,7 @@ export function deleteEntries(obj, keys) {
     for (const key of keys)
         delete obj[key];
 }
+/** An empty object. */
+export const EMPTY_OBJECT = {};
+/** Function that returns an an empty object. */
+export const GET_EMPTY_OBJECT = () => EMPTY_OBJECT;

package/util/undefined.d.ts

@@ -4,6 +4,4 @@ export declare const IS_UNDEFINED: (v: unknown) => v is undefined;
 export declare const IS_DEFINED: <T>(v: T | undefined) => v is T;
 export declare const NOT_UNDEFINED: <T>(v: T | undefined) => v is T;
 /** Function that always returns undefined. */
-export declare const UNDEFINED: () => undefined;
-/** Function that always returns void. */
-export declare const VOID: () => void;
+export declare const GET_UNDEFINED: () => undefined;

package/util/undefined.js

@@ -4,6 +4,4 @@ export const IS_UNDEFINED = (v) => v === undefined;
 export const IS_DEFINED = (v) => v !== undefined;
 export const NOT_UNDEFINED = IS_DEFINED;
 /** Function that always returns undefined. */
-export const UNDEFINED = () => undefined;
-/** Function that always returns void. */
-export const VOID = UNDEFINED;
+export const GET_UNDEFINED = () => undefined;

package/util/url.d.ts

@@ -1,10 +1,9 @@
+/** Things that can be converted to a URL instance. */
+export declare type PossibleURL = string | URL;
+export declare type PossibleOptionalURL = PossibleURL | null;
+/** Convert a possible URL to a URL or return `null` if conversion fails. */
+export declare function toURL(url: PossibleURL, base?: PossibleOptionalURL): URL | null;
+/** Convert a possible URL to a URL but throw `AssertionError` if conversion fails. */
+export declare function getURL(input: PossibleURL, base?: PossibleOptionalURL): URL;
 /** Just get important part of a URL, e.g. `http://shax.com/test?uid=129483` → `shax.com/test` */
-export declare const formatUrl: (url: string | URL) => string;
-/**
- * Convert a string to a URL instance or return `null` if we can't.
- * - Automatically prepend `https://` if there's no `:` anywhere.
- *
- * @param url Base
- * @param
- */
-export declare function toURL(url: string | URL, base?: URL | string | undefined): URL | null;
+export declare const formatUrl: (url: PossibleURL) => string;

package/util/url.js

@@ -1,25 +1,26 @@
-import { getRequired } from "./data.js";
-/** Just get important part of a URL, e.g. `http://shax.com/test?uid=129483` → `shax.com/test` */
-export const formatUrl = (url) => {
-    const { host, pathname } = getRequired(toURL(url));
-    return `${host}${pathname.length > 1 ? pathname : ""}`;
-};
-/**
- * Convert a string to a URL instance or return `null` if we can't.
- * - Automatically prepend `https://` if there's no `:` anywhere.
- *
- * @param url Base
- * @param
- */
-export function toURL(url, base = typeof window === "object" ? window.location.href : undefined) {
+import { AssertionError } from "../error/index.js";
+/** Convert a possible URL to a URL or return `null` if conversion fails. */
+export function toURL(url, base = typeof window === "object" ? window.location.href : null) {
     if (url instanceof URL)
         return url;
     if (!url)
         return null;
     try {
-        return new URL(url, base);
+        return new URL(url, base || undefined);
     }
     catch (e) {
         return null;
     }
 }
+/** Convert a possible URL to a URL but throw `AssertionError` if conversion fails. */
+export function getURL(input, base) {
+    const url = toURL(input, base);
+    if (!url)
+        throw new AssertionError("Invalid URL", input);
+    return url;
+}
+/** Just get important part of a URL, e.g. `http://shax.com/test?uid=129483` → `shax.com/test` */
+export const formatUrl = (url) => {
+    const { host, pathname } = getURL(url);
+    return `${host}${pathname.length > 1 ? pathname : ""}`;
+};