shelving 1.65.0 → 1.67.0

package/db/Database.d.ts

@@ -1,9 +1,7 @@
 import type { Validators, ValidatorType } from "../util/validate.js";
-import type { Key, Datas } from "../util/data.js";
+import type { Key, Datas, Entity } from "../util/data.js";
 import type { Provider } from "../provider/Provider.js";
-import type { SortKeys } from "../query/Sort.js";
-import type { FilterProps } from "../query/Filter.js";
-import { Entity } from "../util/data.js";
+import type { QueryProps } from "../query/Query.js";
 import { DocumentReference, QueryReference } from "./Reference.js";
 /**
  * Combines a database model and a provider.
@@ -17,7 +15,7 @@ export declare class Database<V extends Validators<Datas> = Validators<Datas>> {
     readonly provider: Provider;
     constructor(validators: V, provider: Provider);
     /** Create a query on a collection in this model. */
-    query<K extends Key<V>>(collection: K, filters?: FilterProps<Entity<ValidatorType<V[K]>>>, sorts?: SortKeys<Entity<ValidatorType<V[K]>>>, limit?: number | null): QueryReference<ValidatorType<V[K]>>;
+    query<K extends Key<V>>(collection: K, query?: QueryProps<Entity<ValidatorType<V[K]>>>): QueryReference<ValidatorType<V[K]>>;
     /** Reference a document in a collection in this model. */
     doc<K extends Key<V>>(collection: K, id: string): DocumentReference<ValidatorType<V[K]>>;
     /**

package/db/Database.js

@@ -1,5 +1,3 @@
-import { Filters } from "../query/Filters.js";
-import { Sorts } from "../query/Sorts.js";
 import { DocumentReference, QueryReference } from "./Reference.js";
 /**
  * Combines a database model and a provider.
@@ -15,8 +13,9 @@ export class Database {
         this.provider = provider;
     }
     /** Create a query on a collection in this model. */
-    query(collection, filters, sorts, limit) {
-        return new QueryReference(this, this.validators[collection], collection, filters && Filters.on(filters), sorts && Sorts.on(sorts), limit);
+    query(collection, query) {
+        const validator = this.validators[collection];
+        return new QueryReference(this, validator, collection, query);
     }
     /** Reference a document in a collection in this model. */
     doc(collection, id) {

package/db/Reference.d.ts

@@ -1,15 +1,11 @@
 import type { Data, OptionalData, Entity, OptionalEntity, Entities } from "../util/data.js";
 import type { Dispatch } from "../util/function.js";
-import type { SortKeys } from "../query/Sort.js";
 import { ImmutableArray } from "../util/array.js";
 import type { PartialObserver } from "../observe/Observer.js";
 import type { Validator } from "../util/validate.js";
-import { Query } from "../query/Query.js";
-import { Filters } from "../query/Filters.js";
-import { Sorts } from "../query/Sorts.js";
+import { Query, QueryProps } from "../query/Query.js";
 import { DataUpdate, PropUpdates } from "../update/DataUpdate.js";
-import { FilterProps } from "../query/Filter.js";
-import { Observable, Unsubscribe } from "../observe/Observable.js";
+import type { Observable, Unsubscribe } from "../observe/Observable.js";
 import type { Database } from "./Database.js";
 /** A refence to a location in a database. */
 export interface Reference {
@@ -21,7 +17,7 @@ export declare class QueryReference<T extends Data = Data> extends Query<Entity<
     readonly db: Database;
     readonly validator: Validator<T>;
     readonly collection: string;
-    constructor(db: Database, validator: Validator<T>, collection: string, filters?: Filters<Entity<T>>, sorts?: Sorts<Entity<T>>, limit?: number | null);
+    constructor(db: Database, validator: Validator<T>, collection: string, { sort, limit, ...filters }?: QueryProps<Entity<T>>);
     /** Reference a document in this query's collection. */
     doc(id: string): DocumentReference<T>;
     /**
@@ -104,7 +100,7 @@ export declare class DocumentReference<T extends Data = Data> implements Observa
     readonly id: string;
     constructor(db: Database, validator: Validator<T>, collection: string, id: string);
     /** Create a query on this document's collection. */
-    query(filters?: FilterProps<Entity<T>>, sorts?: SortKeys<Entity<T>>, limit?: number | null): QueryReference<T>;
+    query(query?: QueryProps<Entity<T>>): QueryReference<T>;
     /** Get an 'optional' reference to this document (uses a `ModelQuery` with an `id` filter). */
     get optional(): QueryReference<T>;
     /**

package/db/Reference.js

@@ -5,12 +5,11 @@ import { Sorts } from "../query/Sorts.js";
 import { callAsync } from "../util/async.js";
 import { countItems, hasItems } from "../util/iterate.js";
 import { DataUpdate } from "../update/DataUpdate.js";
-import { Filter } from "../query/Filter.js";
 import { RequiredError } from "../error/RequiredError.js";
 /** A query reference within a specific database. */
 export class QueryReference extends Query {
-    constructor(db, validator, collection, filters, sorts, limit) {
-        super(filters, sorts, limit);
+    constructor(db, validator, collection, { sort, limit, ...filters } = {}) {
+        super(Filters.on(filters), sort && Sorts.on(sort), limit);
         this.db = db;
         this.validator = validator;
         this.collection = collection;
@@ -127,12 +126,12 @@ export class DocumentReference {
         this.id = id;
     }
     /** Create a query on this document's collection. */
-    query(filters, sorts, limit) {
-        return new QueryReference(this.db, this.validator, this.collection, filters && Filters.on(filters), sorts && Sorts.on(sorts), limit);
+    query(query) {
+        return new QueryReference(this.db, this.validator, this.collection, query);
     }
     /** Get an 'optional' reference to this document (uses a `ModelQuery` with an `id` filter). */
     get optional() {
-        return new QueryReference(this.db, this.validator, this.collection, new Filters(new Filter("id", "IS", this.id)));
+        return new QueryReference(this.db, this.validator, this.collection, { id: this.id, limit: 1 });
     }
     /**
      * Does this document exist?

package/observe/util.d.ts

@@ -15,10 +15,10 @@ export declare function connected<T, C extends ConnectableObserver<T>>(source: S
 export declare function connected<T>(source: Subscribable<T>, target: ConnectableObserver<T>): Subject<T>;
 export declare function connected<T>(source: Subscribable<T>): Subject<T>;
 /** Connect a connectable to a source subscribable but transform the value using a transform, and return the connected connectable. */
-export declare function connectedDerived<T, TT, C extends ConnectableObserver<T>>(source: Subscribable<T>, transformer: Transformer<T, TT>, target: C): C;
-export declare function connectedDerived<T, TT>(source: Subscribable<T>, transformer: Transformer<T, TT>, target: ConnectableObserver<T>): ConnectableObserver<TT>;
+export declare function connectedDerived<T, TT, C extends ConnectableObserver<TT>>(source: Subscribable<T>, transformer: Transformer<T, TT>, target: C): C;
+export declare function connectedDerived<T, TT>(source: Subscribable<T>, transformer: Transformer<T, TT>, target: ConnectableObserver<TT>): ConnectableObserver<TT>;
 export declare function connectedDerived<T, TT>(source: Subscribable<T>, transformer: Transformer<T, TT>): Subject<TT>;
 /** Connect a connectable to a source subscribable but transform the value using an async transform, and return the connected connectable. */
 export declare function connectedAsyncDerived<T, TT, C extends ConnectableObserver<TT>>(source: Subscribable<T>, transformer: Transformer<T, PromiseLike<TT>>, target: C): C;
-export declare function connectedAsyncDerived<T, TT>(source: Subscribable<T>, transformer: Transformer<T, PromiseLike<TT>>, target: ConnectableObserver<T>): ConnectableObserver<TT>;
+export declare function connectedAsyncDerived<T, TT>(source: Subscribable<T>, transformer: Transformer<T, PromiseLike<TT>>, target: ConnectableObserver<TT>): ConnectableObserver<TT>;
 export declare function connectedAsyncDerived<T, TT>(source: Subscribable<T>, transformer: Transformer<T, PromiseLike<TT>>): Subject<TT>;

package/package.json

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

package/query/Filter.js

@@ -51,6 +51,26 @@ export class Filter extends Rule {
         return filterItems(items, this);
     }
     toString() {
-        return `${this.key}:${this.operator}:${JSON.stringify(this.value)}`;
+        return `"${_formatKey(this)}":${JSON.stringify(this.value)}`;
+    }
+}
+/** Convert a `Filter` */
+function _formatKey({ key, operator }) {
+    switch (operator) {
+        case "NOT":
+        case "OUT":
+            return `!${key}`;
+        case "CONTAINS":
+            return `${key}[]`;
+        case "LT":
+            return `${key}<`;
+        case "LTE":
+            return `${key}<=`;
+        case "GT":
+            return `${key}>`;
+        case "GTE":
+            return `${key}>=`;
+        default:
+            return key;
     }
 }

package/query/Query.d.ts

@@ -5,6 +5,11 @@ import { Sortable, Sorts } from "./Sorts.js";
 import { Rule } from "./Rule.js";
 import { FilterProps } from "./Filter.js";
 import { SortKey, SortKeys } from "./Sort.js";
+/** Set of props for a query defined as an object. */
+export declare type QueryProps<T extends Data> = FilterProps<T> & {
+    readonly sort?: SortKey<T> | ImmutableArray<SortKey<T>>;
+    readonly limit?: number | null;
+};
 /** Interface that combines Filterable, Sortable, Sliceable. */
 export interface Queryable<T extends Data> extends Filterable<T>, Sortable<T> {
     /**
@@ -26,11 +31,13 @@ export interface Queryable<T extends Data> extends Filterable<T>, Sortable<T> {
     readonly limit: number | null;
     /** Return a new instance of this class with a limit set. */
     max(max: number | null): this;
+    /** Return a new instance of this class with new filters, sorts, limits set. */
+    query(query: QueryProps<T>): this;
 }
 /** Allows filtering, sorting, and limiting on a set of results. */
 export declare class Query<T extends Data> extends Rule<T> implements Queryable<T> {
     /** Create a new `Query` object from a set of `QueryProps` */
-    static on<X extends Data>(filters?: FilterProps<X>, sorts?: SortKey<X> | ImmutableArray<SortKey<X>>, limit?: number | null): Query<X>;
+    static on<X extends Data>({ sort, limit, ...filters }: QueryProps<X>): Query<X>;
     readonly filters: Filters<T>;
     readonly sorts: Sorts<T>;
     readonly limit: number | null;
@@ -44,10 +51,10 @@ export declare class Query<T extends Data> extends Rule<T> implements Queryable<
     sort(...keys: SortKeys<T>[]): this;
     get unsort(): this;
     rank(left: T, right: T): number;
-    /** Return a new instance of this class with a limit defined. */
-    max(limit: number | null): this;
     after(item: T): this;
     before(item: T): this;
+    max(limit: number | null): this;
+    query({ sort, limit, ...filters }: QueryProps<T>): this;
     transform(items: Iterable<T>): Iterable<T>;
     toString(): string;
 }

package/query/Query.js

@@ -17,32 +17,44 @@ export class Query extends Rule {
         this.limit = limit;
     }
     /** Create a new `Query` object from a set of `QueryProps` */
-    static on(filters, sorts, limit) {
-        return new Query(filters && Filters.on(filters), sorts && Sorts.on(sorts), limit);
+    static on({ sort, limit, ...filters }) {
+        return new Query(filters && Filters.on(filters), sort && Sorts.on(sort), limit);
     }
     filter(input, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.filter(input, value) }; // eslint-disable-line @typescript-eslint/no-explicit-any
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            filters: this.filters.filter(input, value), // eslint-disable-line @typescript-eslint/no-explicit-any
+        };
     }
     get unfilter() {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: EMPTY_FILTERS };
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            filters: EMPTY_FILTERS,
+        };
     }
     match(item) {
         return this.filters.match(item);
     }
     // Implement `Sortable`
     sort(...keys) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, sorts: this.sorts.sort(...keys) };
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            sorts: this.sorts.sort(...keys),
+        };
     }
     get unsort() {
-        return { __proto__: Object.getPrototypeOf(this), ...this, sorts: EMPTY_SORTS };
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            sorts: EMPTY_SORTS,
+        };
     }
     rank(left, right) {
         return this.sorts.rank(left, right);
     }
-    /** Return a new instance of this class with a limit defined. */
-    max(limit) {
-        return limit === this.limit ? this : { __proto__: Object.getPrototypeOf(this), ...this, limit };
-    }
     // Implement `Queryable`
     after(item) {
         const filters = [...this.filters];
@@ -52,7 +64,11 @@ export class Query extends Rule {
             const { key, direction } = sort;
             filters.push(new Filter(key, direction === "ASC" ? (sort === lastSort ? "GT" : "GTE") : sort === lastSort ? "LT" : "LTE", getProp(item, key)));
         }
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: new Filters(...filters) };
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            filters: new Filters(...filters),
+        };
     }
     before(item) {
         const filters = [...this.filters];
@@ -62,7 +78,27 @@ export class Query extends Rule {
             const { key, direction } = sort;
             filters.push(new Filter(key, direction === "ASC" ? (sort === lastSort ? "LT" : "LTE") : sort === lastSort ? "GT" : "GTE", getProp(item, key)));
         }
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: new Filters(...filters) };
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            filters: new Filters(...filters),
+        };
+    }
+    max(limit) {
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            limit,
+        };
+    }
+    query({ sort, limit, ...filters }) {
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            filters: this.filters.filter(filters),
+            sorts: sort ? this.sorts.sort(sort) : this.sorts,
+            limit: limit !== undefined ? limit : this.limit,
+        };
     }
     // Implement `Rule`
     transform(items) {
@@ -71,6 +107,8 @@ export class Query extends Rule {
     }
     // Implement toString()
     toString() {
-        return `filters=${this.filters}&sorts=${this.sorts}${this.limit ? `&limit=${this.limit}` : ""}`;
+        const filters = this.filters.toString();
+        const sorts = this.sorts.toString();
+        return `{${filters}${sorts ? `${filters ? "," : ""}"sort":[${sorts}]` : ""}${typeof this.limit === "number" ? `${filters || sorts ? "," : ""}"limit":${this.limit}` : ""}}`;
     }
 }

package/query/Rules.js

@@ -18,8 +18,9 @@ export class Rules extends Rule {
     get size() {
         return this._rules.length;
     }
+    // Override to join the strings from the rules together with `,` commas.
     toString() {
-        return this._rules.map(toString).join(",");
+        return this._rules.map(String).join(",");
     }
     /** Clone this set of rules but add additional rules. */
     with(...rules) {

package/query/Sort.js

@@ -19,6 +19,6 @@ export class Sort extends Rule {
         return sortItems(items, this);
     }
     toString() {
-        return `${this.direction === "DESC" ? "!" : ""}${this.key}`;
+        return `"${this.direction === "DESC" ? "!" : ""}${this.key}"`;
     }
 }

package/react/useDocument.d.ts

@@ -14,10 +14,13 @@ export declare class DocumentState<T extends Data> extends State<OptionalEntity<
     get time(): number | undefined;
     /** How old this state's value is (in milliseconds). */
     get age(): number;
+    /** Get the data of the document (throws `RequiredError` if document doesn't exist). */
     get data(): Entity<T>;
+    /** Does the document exist (i.e. its value isn't `null`)? */
+    get exists(): boolean;
     constructor(ref: DocumentReference<T>);
     /** Refresh this state from the source provider. */
-    refresh(): Promise<void>;
+    readonly refresh: () => Promise<void>;
     /** Refresh this state if data in the cache is older than `maxAge` (in milliseconds). */
     refreshStale(maxAge: number): void;
     /** Subscribe this state to the source provider. */

package/react/useDocument.js

@@ -5,7 +5,6 @@ import { State } from "../state/State.js";
 import { MatchObserver } from "../observe/MatchObserver.js";
 import { BooleanState } from "../state/BooleanState.js";
 import { ConditionError } from "../error/ConditionError.js";
-import { dispatch } from "../util/function.js";
 import { useReduce } from "./useReduce.js";
 import { useSubscribe } from "./useSubscribe.js";
 /** Hold the current state of a document. */
@@ -13,14 +12,32 @@ export class DocumentState extends State {
     constructor(ref) {
         super();
         this.busy = new BooleanState();
+        /** Refresh this state from the source provider. */
+        this.refresh = async () => {
+            if (this.closed)
+                throw new ConditionError("State is closed");
+            if (!this.busy.value) {
+                this.busy.next(true);
+                try {
+                    const result = await this.ref.value;
+                    this.next(result);
+                }
+                catch (thrown) {
+                    this.error(thrown);
+                }
+                finally {
+                    this.busy.next(false);
+                }
+            }
+        };
         this._table = findSourceProvider(ref.db.provider, CacheProvider).memory.getTable(ref);
         this.ref = ref;
         // If the result is cached use it as the initial value.
-        const isCached = this._table.getDocumentTime(ref.id) !== undefined;
+        const isCached = typeof this._table.getDocumentTime(ref.id) === "number";
         if (isCached)
             this.next(this._table.getDocument(ref.id)); // Use the existing cached value.
         else
-            dispatch(this.refresh); // Queue a request to refresh the value.
+            void this.refresh(); // Queue a request to refresh the value.
     }
     /** Time this state was last updated with a new value. */
     get time() {
@@ -31,29 +48,18 @@ export class DocumentState extends State {
         const time = this.time;
         return typeof time === "number" ? Date.now() - time : Infinity;
     }
+    /** Get the data of the document (throws `RequiredError` if document doesn't exist). */
     get data() {
         return getDocumentData(this.value, this.ref);
     }
-    /** Refresh this state from the source provider. */
-    async refresh() {
-        if (this.closed)
-            throw new ConditionError("State is closed");
-        if (!this.busy.value) {
-            try {
-                this.busy.next(true);
-                const result = await this.ref.value;
-                this.busy.next(false);
-                this.next(result);
-            }
-            catch (thrown) {
-                this.error(thrown);
-            }
-        }
+    /** Does the document exist (i.e. its value isn't `null`)? */
+    get exists() {
+        return !!this.value;
     }
     /** Refresh this state if data in the cache is older than `maxAge` (in milliseconds). */
     refreshStale(maxAge) {
         if (this.age > maxAge)
-            dispatch(this.refresh);
+            void this.refresh();
     }
     /** Subscribe this state to the source provider. */
     connectSource() {

package/react/useQuery.d.ts

@@ -26,9 +26,13 @@ export declare class QueryState<T extends Data> extends State<Entities<T>> {
     get lastValue(): OptionalEntity<T>;
     /** Get the last document matched by this query. */
     get lastData(): Entity<T>;
+    /** Does the document have at least one result. */
+    get exists(): boolean;
+    /** Get the number of items matching this query. */
+    get count(): number;
     constructor(ref: QueryReference<T>);
     /** Refresh this state from the source provider. */
-    refresh: () => Promise<void>;
+    readonly refresh: () => Promise<void>;
     /** Refresh this state if data in the cache is older than `maxAge` (in milliseconds). */
     refreshStale(maxAge: number): void;
     /** Subscribe this state to the source provider. */
@@ -39,7 +43,7 @@ export declare class QueryState<T extends Data> extends State<Entities<T>> {
      * Load more items after the last once.
      * - Promise that needs to be handled.
      */
-    loadMore: () => Promise<void>;
+    readonly loadMore: () => Promise<void>;
 }
 /**
  * Use a query in a React component.

package/react/useQuery.js

@@ -5,7 +5,6 @@ import { State } from "../state/State.js";
 import { MatchObserver } from "../observe/MatchObserver.js";
 import { ConditionError } from "../error/ConditionError.js";
 import { BooleanState } from "../state/BooleanState.js";
-import { dispatch } from "../util/function.js";
 import { useReduce } from "./useReduce.js";
 import { useSubscribe } from "./useSubscribe.js";
 /** Hold the current state of a query. */
@@ -20,16 +19,18 @@ export class QueryState extends State {
             if (this.closed)
                 throw new ConditionError("State is closed");
             if (!this.busy.value) {
+                this.busy.next(true);
                 try {
-                    this.busy.next(true);
                     const result = await this.ref.value;
                     this._hasMore = result.length < this.limit;
-                    this.busy.next(false);
                     this.next(result);
                 }
                 catch (thrown) {
                     this.error(thrown);
                 }
+                finally {
+                    this.busy.next(false);
+                }
             }
         };
         /**
@@ -40,27 +41,29 @@ export class QueryState extends State {
             if (this.closed)
                 throw new ConditionError("State is closed");
             if (!this.busy.value) {
+                this.busy.next(true);
                 try {
-                    this.busy.next(true);
                     const items = await this.ref.after(this.lastData).value;
                     this.next([...this.value, ...items]);
                     this._hasMore = items.length < this.limit;
-                    this.busy.next(false);
                 }
                 catch (thrown) {
                     this.error(thrown);
                 }
+                finally {
+                    this.busy.next(false);
+                }
             }
         };
         this._table = findSourceProvider(ref.db.provider, CacheProvider).memory.getTable(ref);
         this.ref = ref;
         this.limit = (_a = ref.limit) !== null && _a !== void 0 ? _a : Infinity;
         // If the result is cached use it as the initial value.
-        const isCached = this._table.getQueryTime(ref) !== undefined;
+        const isCached = typeof this._table.getQueryTime(ref) === "number";
         if (isCached)
             this.next(this._table.getQuery(ref)); // Use the existing cached value.
         else
-            dispatch(this.refresh); // Queue a request to refresh the value.
+            void this.refresh(); // Queue a request to refresh the value.
     }
     /** Time this state was last updated with a new value. */
     get time() {
@@ -91,10 +94,18 @@ export class QueryState extends State {
     get lastData() {
         return getQueryFirstData(this.value, this.ref);
     }
+    /** Does the document have at least one result. */
+    get exists() {
+        return !!this.value.length;
+    }
+    /** Get the number of items matching this query. */
+    get count() {
+        return this.value.length;
+    }
     /** Refresh this state if data in the cache is older than `maxAge` (in milliseconds). */
     refreshStale(maxAge) {
-        if (!this.busy.value && this.age > maxAge)
-            dispatch(this.refresh);
+        if (this.age > maxAge)
+            void this.refresh();
     }
     /** Subscribe this state to the source provider. */
     connectSource() {
@@ -117,7 +128,5 @@ const _getQueryState = (previous, ref) => !ref ? undefined : previous && isSameR
 export function useQuery(ref) {
     const state = useReduce(_getQueryState, ref);
     useSubscribe(state);
-    if (state && !state.exists)
-        dispatch(state.refresh); // Load the query if it isn't cached already.
     return state;
 }

package/react/useSubscribe.js

@@ -11,6 +11,6 @@ import { BLACKHOLE } from "../util/function.js";
  * - Memoise this value to persist the subscription for the lifetime of the component.
  */
 export function useSubscribe(subscribable) {
-    const setState = useState(subscribable instanceof State && subscribable.exists ? subscribable.value : NOVALUE)[1];
+    const setState = useState(subscribable instanceof State && !subscribable.loading ? subscribable.value : NOVALUE)[1];
     useEffect(subscribable ? () => subscribe(subscribable, { next: setState, error: setState }) : BLACKHOLE, [subscribable]);
 }

package/state/ArrayState.d.ts

@@ -4,7 +4,7 @@ import { State } from "./State.js";
 export declare class ArrayState<T> extends State<ImmutableArray<T>> implements Iterable<T> {
     constructor(initial?: ImmutableArray<T>);
     /** Get the length of the current value of this state. */
-    get length(): number;
+    get count(): number;
     /** Add an item to this array. */
     add(item: T): void;
     /** Remove an item from this array. */

package/state/ArrayState.js

@@ -6,7 +6,7 @@ export class ArrayState extends State {
         super(initial);
     }
     /** Get the length of the current value of this state. */
-    get length() {
+    get count() {
         return this.value.length;
     }
     /** Add an item to this array. */

package/state/DataState.d.ts

@@ -12,10 +12,10 @@ export declare class DataState<T extends Data> extends State<T> {
 }
 /** State that stores an optional data object and has additional methods to help with that. */
 export declare class OptionalDataState<T extends Data> extends State<OptionalData<T>> {
-    /** Get the result value of this state. */
-    get result(): OptionalData<T>;
     /** Get current data value of this state (or throw `Promise` that resolves to the next required value). */
     get data(): T;
+    /** Does the data exist or not? */
+    get exists(): boolean;
     /** 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. */

package/state/DataState.js

@@ -1,7 +1,5 @@
 import { getData, withProp } from "../util/data.js";
 import { transformData } from "../util/transform.js";
-import { awaitNext } from "../observe/util.js";
-import { NOERROR } from "../util/constants.js";
 import { State } from "./State.js";
 /** State that stores a data object and has additional methods to help with that. */
 export class DataState extends State {
@@ -20,18 +18,14 @@ export class DataState extends State {
 }
 /** State that stores an optional data object and has additional methods to help with that. */
 export class OptionalDataState 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.exists)
-            throw awaitNext(this).then(getData);
         return getData(this.value);
     }
+    /** Does the data exist or not? */
+    get exists() {
+        return !!this.value;
+    }
     /** Set a prop in this object to a new value. */
     set(key, value) {
         this.next(withProp(this.data, key, value));

package/state/ObjectState.d.ts

@@ -5,7 +5,7 @@ import { State } from "./State.js";
 export declare class ObjectState<T> extends State<ImmutableObject<T>> implements Iterable<Entry<T>> {
     constructor(initial?: ImmutableObject<T>);
     /** Get the length of the current value of this state. */
-    get length(): number;
+    get count(): number;
     /** Remove a named entry from this object. */
     delete(key: string): void;
     /** Set a named entry in this object with a different value. */

package/state/ObjectState.js

@@ -6,7 +6,7 @@ export class ObjectState extends State {
         super(initial);
     }
     /** Get the length of the current value of this state. */
-    get length() {
+    get count() {
         return Object.keys(this.value).length;
     }
     /** Remove a named entry from this object. */

package/state/State.d.ts

@@ -23,7 +23,7 @@ export declare class State<T> extends Subject<T> implements Matchable<T, void> {
     /** State is initiated with an initial state. */
     constructor(...args: [] | [T]);
     /** Is there a current value, or is it still loading. */
-    get exists(): boolean;
+    get loading(): boolean;
     next(value: T): void;
     error(reason: Error | unknown): void;
     protected _addObserver(observer: Observer<T>): void;

package/state/State.js

@@ -30,8 +30,8 @@ export class State extends Subject {
         return this._value;
     }
     /** Is there a current value, or is it still loading. */
-    get exists() {
-        return this._value !== NOVALUE;
+    get loading() {
+        return this._value === NOVALUE;
     }
     // Override to only dispatch if the value changes.
     next(value) {