shelving 1.82.0 → 1.83.0

package/constraint/Constraints.js

@@ -1,4 +1,4 @@
-import { withItems, withoutItems } from "../util/array.js";
+import { withArrayItems, withoutArrayItems } from "../util/array.js";
 import { Constraint } from "./Constraint.js";
 /** Type of Rule that is powered by several sub-constraints (e.g. `Filters` and `Sorts` and `Query` itself extend this). */
 export class Constraints extends Constraint {
@@ -20,12 +20,12 @@ export class Constraints extends Constraint {
     }
     /** Clone this set of constraints but add additional constraints. */
     with(...constraints) {
-        const _constraints = withItems(this._constraints, ...constraints);
+        const _constraints = withArrayItems(this._constraints, ...constraints);
         return _constraints !== this._constraints ? { __proto__: Object.getPrototypeOf(this), ...this, _constraints: _constraints } : this;
     }
     /** Clone this set of constraints but remove specific constraints. */
     without(...constraints) {
-        const _constraints = withoutItems(this._constraints, ...constraints);
+        const _constraints = withoutArrayItems(this._constraints, ...constraints);
         return _constraints !== this._constraints ? { __proto__: Object.getPrototypeOf(this), ...this, _constraints: _constraints } : this;
     }
     /** Iterate over the constraints. */

package/constraint/FilterConstraint.d.ts

@@ -1,4 +1,4 @@
-import type { Data, Key } from "../util/data.js";
+import type { Data, DataKey } from "../util/data.js";
 import type { Nullish } from "../util/null.js";
 import { ImmutableArray } from "../util/array.js";
 import { Matchable } from "../util/match.js";
@@ -6,14 +6,14 @@ import type { Constraint } from "./Constraint.js";
 /** Possible operator references. */
 export declare type FilterOperator = "IS" | "NOT" | "IN" | "OUT" | "CONTAINS" | "LT" | "LTE" | "GT" | "GTE";
 /** Format that allows filters to be specified as a string, e.g. `!name` means `name is not` and `age>` means `age is more than` and `tags[]` means `tags array contains` */
-export declare type FilterKey<T extends Data> = Key<T> | `${Key<T>}` | `!${Key<T>}` | `${Key<T>}[]` | `${Key<T>}<` | `${Key<T>}<=` | `${Key<T>}>` | `${Key<T>}>=`;
+export declare type FilterKey<T extends Data> = DataKey<T> | `${DataKey<T>}` | `!${DataKey<T>}` | `${DataKey<T>}[]` | `${DataKey<T>}<` | `${DataKey<T>}<=` | `${DataKey<T>}>` | `${DataKey<T>}>=`;
 /** Format that allows multiple filters to be specified as a plain object. */
 export declare type FilterProps<T extends Data> = {
-    [K in Key<T> as `${K}` | `!${K}`]?: T[K] | ImmutableArray<T[K]>;
+    [K in DataKey<T> as `${K}` | `!${K}`]?: T[K] | ImmutableArray<T[K]>;
 } & {
-    [K in Key<T> as `${K}[]`]?: Required<T>[K] extends ImmutableArray<infer X> ? X : never;
+    [K in DataKey<T> as `${K}[]`]?: Required<T>[K] extends ImmutableArray<infer X> ? X : never;
 } & {
-    [K in Key<T> as `${K}<` | `${K}<=` | `${K}>` | `${K}>=`]?: T[K];
+    [K in DataKey<T> as `${K}<` | `${K}<=` | `${K}>` | `${K}>=`]?: T[K];
 };
 /** List of filters in a flexible format. */
 export declare type FilterList<T extends Data> = Nullish<FilterProps<T> | FilterConstraint<T>> | Iterable<FilterList<T>>;

package/constraint/SortConstraint.d.ts

@@ -1,10 +1,10 @@
 import type { ImmutableArray } from "../util/array.js";
-import type { Data, Key } from "../util/data.js";
+import type { Data, DataKey } from "../util/data.js";
 import type { Nullish } from "../util/null.js";
 import { Rankable } from "../util/sort.js";
 import type { Constraint } from "./Constraint.js";
 /** Format that allows sorts to be set as a plain string, e.g. `name` sorts by name in ascending order and `!date` sorts by date in descending order. */
-export declare type SortKey<T extends Data> = Key<T> | `${Key<T>}` | `!${Key<T>}`;
+export declare type SortKey<T extends Data> = DataKey<T> | `${DataKey<T>}` | `!${DataKey<T>}`;
 /** One or more sort keys. */
 export declare type SortKeys<T extends Data> = SortKey<T> | ImmutableArray<SortKey<T>>;
 /** Possible operator references. */

package/db/Change.d.ts

@@ -1,4 +1,4 @@
-import type { Data, Datas, Key } from "../util/data.js";
+import type { Data, Datas, DataKey } from "../util/data.js";
 import type { ImmutableArray } from "../util/array.js";
 import type { Provider, AsyncProvider } from "../provider/Provider.js";
 import { Updates } from "../update/DataUpdate.js";
@@ -6,42 +6,42 @@ import { Nullish } from "../util/null.js";
 import { DeepIterable } from "../util/iterate.js";
 import type { ItemConstraints, ItemData } from "./Item.js";
 /** Change on a collection. */
-export interface Change<T extends Datas, K extends Key<T> = Key<T>> {
+export interface Change<T extends Datas, K extends DataKey<T> = DataKey<T>> {
     readonly action: string;
     readonly collection: K;
 }
 /** Add on an item. */
-export interface AddChange<T extends Datas, K extends Key<T> = Key<T>> extends Change<T, K> {
+export interface AddChange<T extends Datas, K extends DataKey<T> = DataKey<T>> extends Change<T, K> {
     readonly action: "ADD";
     readonly data: T[K];
 }
 /** Set on an item. */
-export interface SetChange<T extends Datas, K extends Key<T> = Key<T>> extends Change<T, K> {
+export interface SetChange<T extends Datas, K extends DataKey<T> = DataKey<T>> extends Change<T, K> {
     readonly action: "SET";
     readonly id: string;
     readonly data: T[K];
 }
 /** Update change on an item. */
-export interface UpdateChange<T extends Datas, K extends Key<T> = Key<T>> extends Change<T, K> {
+export interface UpdateChange<T extends Datas, K extends DataKey<T> = DataKey<T>> extends Change<T, K> {
     readonly action: "UPDATE";
     readonly id: string;
     readonly updates: Updates<T[K]>;
 }
 /** Delete change on an item. */
-export interface DeleteChange<T extends Datas, K extends Key<T> = Key<T>> extends Change<T, K> {
+export interface DeleteChange<T extends Datas, K extends DataKey<T> = DataKey<T>> extends Change<T, K> {
     readonly action: "DELETE";
     readonly id: string;
 }
 /** Set, update, or delete change on an item. */
-export declare type ItemChange<T extends Datas, K extends Key<T> = Key<T>> = SetChange<T, K> | UpdateChange<T, K> | DeleteChange<T, K>;
+export declare type ItemChange<T extends Datas, K extends DataKey<T> = DataKey<T>> = SetChange<T, K> | UpdateChange<T, K> | DeleteChange<T, K>;
 /** Array of item changes. */
-export declare type ItemChanges<T extends Datas, K extends Key<T> = Key<T>> = ImmutableArray<ItemChange<T, K>>;
+export declare type ItemChanges<T extends Datas, K extends DataKey<T> = DataKey<T>> = ImmutableArray<ItemChange<T, K>>;
 /** Write change on an item. */
-export declare type WriteChange<T extends Datas, K extends Key<T> = Key<T>> = ItemChange<T, K> | AddChange<T, K>;
+export declare type WriteChange<T extends Datas, K extends DataKey<T> = DataKey<T>> = ItemChange<T, K> | AddChange<T, K>;
 /** Array of write changes. */
-export declare type WriteChanges<T extends Datas, K extends Key<T> = Key<T>> = ImmutableArray<WriteChange<T, K>>;
+export declare type WriteChanges<T extends Datas, K extends DataKey<T> = DataKey<T>> = ImmutableArray<WriteChange<T, K>>;
 /** Apply a set of changes to a synchronous provider. */
-export declare function changeProvider<T extends Datas, K extends Key<T>>(provider: Provider<T>, ...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): ItemChanges<T, K>;
+export declare function changeProvider<T extends Datas, K extends DataKey<T>>(provider: Provider<T>, ...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): ItemChanges<T, K>;
 /** Apply a set of changes to an asynchronous provider. */
-export declare function changeAsyncProvider<T extends Datas, K extends Key<T>>(provider: AsyncProvider<T>, ...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): Promise<ItemChanges<T, K>>;
+export declare function changeAsyncProvider<T extends Datas, K extends DataKey<T>>(provider: AsyncProvider<T>, ...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): Promise<ItemChanges<T, K>>;
 export declare function _getItemConstraint<T extends Data>(id: string): ItemConstraints<ItemData<T>>;

package/db/Collection.d.ts

@@ -1,4 +1,4 @@
-import type { Datas, Key } from "../util/data.js";
+import type { Datas, DataKey } from "../util/data.js";
 import type { Nullish } from "../util/null.js";
 import type { FilterList } from "../constraint/FilterConstraint.js";
 import type { SortList } from "../constraint/SortConstraint.js";
@@ -9,7 +9,7 @@ import { ItemData, AsyncItem, Item, ItemValue } from "./Item.js";
 import { AsyncQuery, Query } from "./Query.js";
 import { AddChange, ItemChanges, WriteChange, UpdateChange, DeleteChange, SetChange } from "./Change.js";
 /** Reference to a collection in a synchronous or asynchronous provider. */
-declare abstract class BaseCollection<T extends Datas = Datas, K extends Key<T> = Key<T>> {
+declare abstract class BaseCollection<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> {
     abstract readonly db: Database<T> | AsyncDatabase<T>;
     abstract readonly collection: K;
     /** Create a query on this item's collection. */
@@ -39,7 +39,7 @@ declare abstract class BaseCollection<T extends Datas = Datas, K extends Key<T>
     toString(): K;
 }
 /** Reference to a collection in a synchronous provider. */
-export declare class Collection<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseCollection<T, K> {
+export declare class Collection<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseCollection<T, K> {
     readonly db: Database<T>;
     readonly collection: K;
     constructor(db: Database<T>, collection: K);
@@ -53,7 +53,7 @@ export declare class Collection<T extends Datas = Datas, K extends Key<T> = Key<
     delete(id: string): void;
 }
 /** Reference to a collection in an asynchronous provider. */
-export declare class AsyncCollection<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseCollection<T, K> {
+export declare class AsyncCollection<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseCollection<T, K> {
     readonly db: AsyncDatabase<T>;
     readonly collection: K;
     constructor(db: AsyncDatabase<T>, collection: K);

package/db/Database.d.ts

@@ -1,4 +1,4 @@
-import type { Key, Datas } from "../util/data.js";
+import type { DataKey, Datas } from "../util/data.js";
 import type { Nullish } from "../util/null.js";
 import type { DeepIterable } from "../util/iterate.js";
 import type { AsyncProvider, Provider } from "../provider/Provider.js";
@@ -14,58 +14,58 @@ import { AddChange, DeleteChange, ItemChanges, SetChange, UpdateChange, WriteCha
 declare abstract class BaseDatabase<T extends Datas> {
     abstract readonly provider: Provider<T> | AsyncProvider<T>;
     /** Create a query on a collection in this database. */
-    abstract collection<K extends Key<T>>(collection: K): Collection<T, K> | AsyncCollection<T, K>;
+    abstract collection<K extends DataKey<T>>(collection: K): Collection<T, K> | AsyncCollection<T, K>;
     /** Create a query on a collection in this database. */
-    abstract query<K extends Key<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T, K> | AsyncQuery<T, K>;
+    abstract query<K extends DataKey<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T, K> | AsyncQuery<T, K>;
     /** Reference an item in a collection in this database. */
-    abstract item<K extends Key<T>>(collection: K, id: string): Item<T, K> | AsyncItem<T, K>;
+    abstract item<K extends DataKey<T>>(collection: K, id: string): Item<T, K> | AsyncItem<T, K>;
     /** Run a set of changes in this database. */
     abstract change(...changes: DeepIterable<Nullish<WriteChange<T>>>[]): ItemChanges<T> | Promise<ItemChanges<T>>;
     /** Get a document from a collection in this database. */
-    abstract get<K extends Key<T>>(collection: K, id: string): ItemValue<T[K]> | Promise<ItemValue<T[K]>>;
+    abstract get<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]> | Promise<ItemValue<T[K]>>;
     /** Add a document to a collection in this database. */
-    abstract add<K extends Key<T>>(collection: K, data: T[K]): string | Promise<string>;
+    abstract add<K extends DataKey<T>>(collection: K, data: T[K]): string | Promise<string>;
     /** Set a document in a collection in this database. */
-    abstract set<K extends Key<T>>(collection: K, id: string, data: T[K]): void | Promise<void>;
+    abstract set<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void | Promise<void>;
     /** Update a document in a collection in this database. */
-    abstract update<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): void | Promise<void>;
+    abstract update<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void | Promise<void>;
     /** Delete a document from a collection in this database. */
-    abstract delete<K extends Key<T>>(collection: K, id: string): void | Promise<void>;
+    abstract delete<K extends DataKey<T>>(collection: K, id: string): void | Promise<void>;
     /** Get an add change for a collection in this database. */
-    getAdd<K extends Key<T>>(collection: K, data: T[K]): AddChange<T, K>;
+    getAdd<K extends DataKey<T>>(collection: K, data: T[K]): AddChange<T, K>;
     /** Get a set change for a collection in this database. */
-    getSet<K extends Key<T>>(collection: K, id: string, data: T[K]): SetChange<T, K>;
+    getSet<K extends DataKey<T>>(collection: K, id: string, data: T[K]): SetChange<T, K>;
     /** Get an update change for a collection in this database. */
-    getUpdate<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): UpdateChange<T, K>;
+    getUpdate<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): UpdateChange<T, K>;
     /** Get a delete change for a collection in this database. */
-    getDelete<K extends Key<T>>(collection: K, id: string): DeleteChange<T, K>;
+    getDelete<K extends DataKey<T>>(collection: K, id: string): DeleteChange<T, K>;
 }
 /** Database with a synchronous provider. */
 export declare class Database<T extends Datas = Datas> extends BaseDatabase<T> {
     readonly provider: Provider<T>;
     constructor(provider: Provider<T>);
-    collection<K extends Key<T>>(collection: K): Collection<T, K>;
-    query<K extends Key<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T, K>;
-    item<K extends Key<T>>(collection: K, id: string): Item<T, K>;
+    collection<K extends DataKey<T>>(collection: K): Collection<T, K>;
+    query<K extends DataKey<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T, K>;
+    item<K extends DataKey<T>>(collection: K, id: string): Item<T, K>;
     change(...changes: DeepIterable<Nullish<WriteChange<T>>>[]): ItemChanges<T>;
-    get<K extends Key<T>>(collection: K, id: string): ItemValue<T[K]>;
-    add<K extends Key<T>>(collection: K, data: T[K]): string;
-    set<K extends Key<T>>(collection: K, id: string, data: T[K]): void;
-    update<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
-    delete<K extends Key<T>>(collection: K, id: string): void;
+    get<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]>;
+    add<K extends DataKey<T>>(collection: K, data: T[K]): string;
+    set<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
+    update<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
+    delete<K extends DataKey<T>>(collection: K, id: string): void;
 }
 /** Database with a synchronous provider. */
 export declare class AsyncDatabase<T extends Datas = Datas> extends BaseDatabase<T> {
     readonly provider: AsyncProvider<T>;
     constructor(provider: AsyncProvider<T>);
-    collection<K extends Key<T>>(collection: K): AsyncCollection<T, K>;
-    query<K extends Key<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): AsyncQuery<T, K>;
-    item<K extends Key<T>>(collection: K, id: string): AsyncItem<T, K>;
+    collection<K extends DataKey<T>>(collection: K): AsyncCollection<T, K>;
+    query<K extends DataKey<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): AsyncQuery<T, K>;
+    item<K extends DataKey<T>>(collection: K, id: string): AsyncItem<T, K>;
     change(...changes: DeepIterable<Nullish<WriteChange<T>>>[]): Promise<ItemChanges<T>>;
-    get<K extends Key<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
-    add<K extends Key<T>>(collection: K, data: T[K]): Promise<string>;
-    set<K extends Key<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    update<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
-    delete<K extends Key<T>>(collection: K, id: string): Promise<void>;
+    get<K extends DataKey<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
+    add<K extends DataKey<T>>(collection: K, data: T[K]): Promise<string>;
+    set<K extends DataKey<T>>(collection: K, id: string, data: T[K]): Promise<void>;
+    update<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
+    delete<K extends DataKey<T>>(collection: K, id: string): Promise<void>;
 }
 export {};

package/db/Item.d.ts

@@ -1,7 +1,7 @@
 import type { ImmutableArray } from "../util/array.js";
 import type { Stop, Handler, Dispatch } from "../util/function.js";
 import type { QueryConstraints } from "../constraint/QueryConstraints.js";
-import { Data, Datas, Key } from "../util/data.js";
+import { Data, Datas, DataKey } from "../util/data.js";
 import { DataUpdate, Updates } from "../update/DataUpdate.js";
 import type { DeleteChange, SetChange, UpdateChange } from "./Change.js";
 import type { AsyncQuery, Query } from "./Query.js";
@@ -17,7 +17,7 @@ export declare type ItemArray<T extends Data = Data> = ImmutableArray<ItemData<T
 /** A set of query constraints for item data. */
 export declare type ItemConstraints<T extends Data = Data> = QueryConstraints<ItemData<T>>;
 /** Reference to an item in a synchronous or asynchronous database. */
-declare abstract class BaseItem<T extends Datas = Datas, K extends Key<T> = Key<T>> implements AsyncIterable<ItemValue<T[K]>> {
+declare abstract class BaseItem<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> implements AsyncIterable<ItemValue<T[K]>> {
     abstract readonly db: Database<T> | AsyncDatabase<T>;
     abstract readonly collection: K;
     abstract readonly id: string;
@@ -59,7 +59,7 @@ declare abstract class BaseItem<T extends Datas = Datas, K extends Key<T> = Key<
     [Symbol.asyncIterator](): AsyncIterator<ItemValue<T[K]>>;
 }
 /** Reference to an item in a synchronous database. */
-export declare class Item<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseItem<T, K> {
+export declare class Item<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseItem<T, K> {
     readonly db: Database<T>;
     readonly collection: K;
     readonly id: string;
@@ -73,7 +73,7 @@ export declare class Item<T extends Datas = Datas, K extends Key<T> = Key<T>> ex
     delete(): void;
 }
 /** Reference to an item in an asynchronous database. */
-export declare class AsyncItem<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseItem<T, K> {
+export declare class AsyncItem<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseItem<T, K> {
     readonly db: AsyncDatabase<T>;
     readonly collection: K;
     readonly id: string;

package/db/Query.d.ts

@@ -1,4 +1,4 @@
-import type { Key, Datas } from "../util/data.js";
+import type { DataKey, Datas } from "../util/data.js";
 import type { Dispatch, Handler, Stop } from "../util/function.js";
 import type { Updates } from "../update/DataUpdate.js";
 import type { FilterList } from "../constraint/FilterConstraint.js";
@@ -7,7 +7,7 @@ import { QueryConstraints } from "../constraint/QueryConstraints.js";
 import type { ItemArray, ItemValue, ItemData } from "./Item.js";
 import type { AsyncDatabase, Database } from "./Database.js";
 /** Reference to a set of items in a sync or async provider. */
-declare abstract class BaseQuery<T extends Datas = Datas, K extends Key<T> = Key<T>> extends QueryConstraints<ItemData<T[K]>> implements AsyncIterable<ItemArray<T[K]>> {
+declare abstract class BaseQuery<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends QueryConstraints<ItemData<T[K]>> implements AsyncIterable<ItemArray<T[K]>> {
     abstract readonly db: Database<T> | AsyncDatabase<T>;
     abstract readonly collection: K;
     /**
@@ -70,7 +70,7 @@ declare abstract class BaseQuery<T extends Datas = Datas, K extends Key<T> = Key
     [Symbol.asyncIterator](): AsyncIterator<ItemArray<T[K]>>;
 }
 /** Reference to a set of items in a provider. */
-export declare class Query<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseQuery<T, K> {
+export declare class Query<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseQuery<T, K> {
     readonly db: Database<T>;
     readonly collection: K;
     constructor(db: Database<T>, collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null);
@@ -86,7 +86,7 @@ export declare class Query<T extends Datas = Datas, K extends Key<T> = Key<T>> e
     delete(): number;
 }
 /** Reference to a set of items in a provider. */
-export declare class AsyncQuery<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseQuery<T, K> {
+export declare class AsyncQuery<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseQuery<T, K> {
     readonly db: AsyncDatabase<T>;
     readonly collection: K;
     constructor(db: AsyncDatabase<T>, collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null);

package/feedback/Feedback.d.ts

@@ -1,4 +1,4 @@
-import { ImmutableObject } from "../util/object.js";
+import type { ImmutableDictionary } from "../util/dictionary.js";
 /**
  * The `Feedback` class represents a feedback message that should be shown to the user.
  * - Basic `Feedback` is neither good nor bad, `SuccessFeedback` indicates good news, and `ErrorFeedback` indicates bad news.
@@ -24,4 +24,4 @@ export declare const isFeedback: <T extends Feedback<unknown>>(v: unknown) => v
  * Get an object of sub-messages in `{ key: message }` format from a feedback's value.
  * - Takes the `.value` property from a `Feedback` instance and looks for keyed `Feedback` instances in either `{ key: Feedback }`. `Feedback[]`, or `Map<key, Feedback>` formats.
  */
-export declare const getFeedbackMessages: ({ value }: Feedback) => ImmutableObject<string>;
+export declare const getFeedbackMessages: ({ value }: Feedback) => ImmutableDictionary<string>;

package/feedback/Feedback.js

@@ -4,9 +4,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { isObject } from "../util/object.js";
 import { getEntries } from "../util/entry.js";
 import { setPrototype } from "../util/class.js";
+import { isObject } from "../util/object.js";
+import { getString } from "../util/string.js";
 /**
  * The `Feedback` class represents a feedback message that should be shown to the user.
  * - Basic `Feedback` is neither good nor bad, `SuccessFeedback` indicates good news, and `ErrorFeedback` indicates bad news.
@@ -38,5 +39,5 @@ function* _yieldFeedbackMessages(value) {
     if (isObject(value))
         for (const [k, v] of getEntries(value))
             if (isFeedback(v))
-                yield [k, v.message];
+                yield [getString(k), v.message];
 }

package/firestore/client/FirestoreClientProvider.js

@@ -1,6 +1,6 @@
 import { orderBy as firestoreOrderBy, where as firestoreWhere, limit as firestoreLimit, increment as firestoreIncrement, arrayUnion as firestoreArrayUnion, arrayRemove as firestoreArrayRemove, deleteField as firestoreDeleteField, collection as firestoreCollection, doc as firestoreDocument, query as firestoreQuery, onSnapshot, addDoc, setDoc, updateDoc, deleteDoc, getDoc, getDocs, } from "firebase/firestore";
 import { LazyDeferredSequence } from "../../sequence/LazyDeferredSequence.js";
-import { ArrayUpdate, DataUpdate, Increment, ObjectUpdate, Delete, Update } from "../../update/index.js";
+import { ArrayUpdate, DataUpdate, Increment, DictionaryUpdate, Delete, Update } from "../../update/index.js";
 // Constants.
 // const ID = "__name__"; // DH: `__name__` is the entire path of the document. `__id__` is just ID.
 const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
@@ -47,7 +47,7 @@ function _getItemValue(snapshot) {
 /** Convert `Update` instances into corresponding Firestore `FieldValue` instances. */
 function* _getFieldValues(updates, prefix = "") {
     for (const [key, update] of updates) {
-        if (update instanceof DataUpdate || update instanceof ObjectUpdate) {
+        if (update instanceof DataUpdate || update instanceof DictionaryUpdate) {
             yield* _getFieldValues(update, `${prefix}${key}.`);
         }
         else if (update instanceof ArrayUpdate) {

package/firestore/lite/FirestoreLiteProvider.js

@@ -1,6 +1,6 @@
 import { orderBy as firestoreOrderBy, where as firestoreWhere, limit as firestoreLimit, increment as firestoreIncrement, arrayUnion as firestoreArrayUnion, arrayRemove as firestoreArrayRemove, deleteField as firestoreDeleteField, collection as firestoreCollection, doc as firestoreDocument, query as firestoreQuery, setDoc, addDoc, updateDoc, deleteDoc, getDoc, getDocs, } from "firebase/firestore/lite";
 import { UnsupportedError } from "../../error/UnsupportedError.js";
-import { ArrayUpdate, DataUpdate, Increment, ObjectUpdate, Delete, Update } from "../../update/index.js";
+import { ArrayUpdate, DataUpdate, Increment, DictionaryUpdate, Delete, Update } from "../../update/index.js";
 // Constants.
 // const ID = "__name__"; // DH: `__name__` is the entire path of the document. `__id__` is just ID.
 const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
@@ -47,7 +47,7 @@ function _getItemValue(snapshot) {
 /** Convert `Update` instances into corresponding Firestore `FieldValue` instances. */
 function* _getFieldValues(updates, prefix = "") {
     for (const [key, update] of updates) {
-        if (update instanceof DataUpdate || update instanceof ObjectUpdate) {
+        if (update instanceof DataUpdate || update instanceof DictionaryUpdate) {
             yield* _getFieldValues(update, `${prefix}${key}.`);
         }
         else if (update instanceof ArrayUpdate) {

package/firestore/server/FirestoreServerProvider.js

@@ -1,6 +1,6 @@
 import { Firestore, FieldValue as FirestoreFieldValue } from "@google-cloud/firestore";
 import { LazyDeferredSequence } from "../../sequence/LazyDeferredSequence.js";
-import { ArrayUpdate, DataUpdate, Increment, ObjectUpdate, Delete, Update } from "../../update/index.js";
+import { ArrayUpdate, DataUpdate, Increment, DictionaryUpdate, Delete, Update } from "../../update/index.js";
 // Constants.
 // const ID = "__name__"; // DH: `__name__` is the entire path of the document. `__id__` is just ID.
 const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
@@ -47,7 +47,7 @@ function _getItemValue(snapshot) {
 /** Convert `Update` instances into corresponding Firestore `FieldValue` instances. */
 function* _getFieldValues(updates, prefix = "") {
     for (const [key, update] of updates) {
-        if (update instanceof DataUpdate || update instanceof ObjectUpdate) {
+        if (update instanceof DataUpdate || update instanceof DictionaryUpdate) {
             yield* _getFieldValues(update, `${prefix}${key}.`);
         }
         else if (update instanceof ArrayUpdate) {

package/package.json

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

package/provider/CacheProvider.d.ts

@@ -1,4 +1,4 @@
-import type { Datas, Key } from "../util/data.js";
+import type { Datas, DataKey } from "../util/data.js";
 import type { ItemArray, ItemValue, ItemConstraints } from "../db/Item.js";
 import type { Updates } from "../update/DataUpdate.js";
 import type { AsyncProvider } from "./Provider.js";
@@ -9,15 +9,15 @@ export declare class CacheProvider<T extends Datas> implements AsyncThroughProvi
     readonly source: AsyncProvider<T>;
     readonly memory: MemoryProvider<T>;
     constructor(source: AsyncProvider<T>, cache?: MemoryProvider<T>);
-    getItem<K extends Key<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
-    getItemSequence<K extends Key<T>>(collection: K, id: string): AsyncIterableIterator<ItemValue<T[K]>>;
-    addItem<K extends Key<T>>(collection: K, data: T[K]): Promise<string>;
-    setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
-    deleteItem<K extends Key<T>>(collection: K, id: string): Promise<void>;
-    getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
-    getQuerySequence<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterableIterator<ItemArray<T[K]>>;
-    setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): Promise<number>;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
-    deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
+    getItem<K extends DataKey<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
+    getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterableIterator<ItemValue<T[K]>>;
+    addItem<K extends DataKey<T>>(collection: K, data: T[K]): Promise<string>;
+    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): Promise<void>;
+    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
+    deleteItem<K extends DataKey<T>>(collection: K, id: string): Promise<void>;
+    getQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
+    getQuerySequence<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterableIterator<ItemArray<T[K]>>;
+    setQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): Promise<number>;
+    updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
+    deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
 }

package/provider/DebugProvider.d.ts

@@ -1,4 +1,4 @@
-import type { Datas, Key } from "../util/data.js";
+import type { Datas, DataKey } from "../util/data.js";
 import type { ItemArray, ItemConstraints, ItemValue } from "../db/Item.js";
 import type { Updates } from "../update/DataUpdate.js";
 import { Provider, AsyncProvider } from "./Provider.js";
@@ -6,35 +6,35 @@ import type { ThroughProvider, AsyncThroughProvider } from "./ThroughProvider.js
 /** Provider that logs operations to a source provider to the console. */
 declare abstract class AbstractDebugProvider<T extends Datas> {
     abstract readonly source: Provider<T> | AsyncProvider<T>;
-    getItemSequence<K extends Key<T>>(collection: K, id: string): AsyncIterableIterator<ItemValue<T[K]>>;
-    getQuerySequence<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterableIterator<ItemArray<T[K]>>;
+    getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterableIterator<ItemValue<T[K]>>;
+    getQuerySequence<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterableIterator<ItemArray<T[K]>>;
 }
 /** Provider that logs operations to a synchronous source provider to the console. */
 export declare class DebugProvider<T extends Datas> extends AbstractDebugProvider<T> implements ThroughProvider<T> {
     readonly source: Provider<T>;
     constructor(source: Provider<T>);
-    getItem<K extends Key<T>>(collection: K, id: string): ItemValue<T[K]>;
-    addItem<K extends Key<T>>(collection: K, data: T[K]): string;
-    setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): void;
-    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
-    deleteItem<K extends Key<T>>(collection: K, id: string): void;
-    getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
-    setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number;
-    deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
+    getItem<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]>;
+    addItem<K extends DataKey<T>>(collection: K, data: T[K]): string;
+    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
+    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
+    deleteItem<K extends DataKey<T>>(collection: K, id: string): void;
+    getQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
+    setQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number;
+    updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number;
+    deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
 }
 /** Provider that logs operations to a synchronous source provider to the console. */
 export declare class AsyncDebugProvider<T extends Datas> extends AbstractDebugProvider<T> implements AsyncThroughProvider<T> {
     readonly source: AsyncProvider<T>;
     constructor(source: AsyncProvider<T>);
-    getItem<K extends Key<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
-    addItem<K extends Key<T>>(collection: K, data: T[K]): Promise<string>;
-    setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
-    deleteItem<K extends Key<T>>(collection: K, id: string): Promise<void>;
-    getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
-    setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): Promise<number>;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
-    deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
+    getItem<K extends DataKey<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
+    addItem<K extends DataKey<T>>(collection: K, data: T[K]): Promise<string>;
+    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): Promise<void>;
+    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
+    deleteItem<K extends DataKey<T>>(collection: K, id: string): Promise<void>;
+    getQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
+    setQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): Promise<number>;
+    updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
+    deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
 }
 export {};

package/provider/MemoryProvider.d.ts

@@ -1,6 +1,6 @@
-import type { Data, Datas, Key } from "../util/data.js";
+import type { Data, Datas, DataKey } from "../util/data.js";
 import type { ItemArray, ItemValue, ItemData, ItemConstraints } from "../db/Item.js";
-import type { Updates } from "../update/DataUpdate.js";
+import { Updates } from "../update/DataUpdate.js";
 import { DeferredSequence } from "../sequence/DeferredSequence.js";
 import type { Provider } from "./Provider.js";
 /**
@@ -12,20 +12,20 @@ export declare class MemoryProvider<T extends Datas> implements Provider<T> {
     /** List of tables in `{ collection: Table }` format. */
     private _tables;
     /** Get a table for a collection. */
-    getTable<K extends Key<T>>(collection: K): MemoryTable<T[K]>;
-    getDocumentTime<K extends Key<T>>(collection: K, id: string): number | null;
-    getItem<K extends Key<T>>(collection: K, id: string): ItemValue<T[K]>;
-    getItemSequence<K extends Key<T>>(collection: K, id: string): AsyncIterable<ItemValue<T[K]>>;
-    addItem<K extends Key<T>>(collection: K, data: T[K]): string;
-    setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): void;
-    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
-    deleteItem<K extends Key<T>>(collection: K, id: string): void;
-    getQueryTime<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): number | null;
-    getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
-    getQuerySequence<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterable<ItemArray<T[K]>>;
-    setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number;
-    deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
+    getTable<K extends DataKey<T>>(collection: K): MemoryTable<T[K]>;
+    getDocumentTime<K extends DataKey<T>>(collection: K, id: string): number | null;
+    getItem<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]>;
+    getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<ItemValue<T[K]>>;
+    addItem<K extends DataKey<T>>(collection: K, data: T[K]): string;
+    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
+    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
+    deleteItem<K extends DataKey<T>>(collection: K, id: string): void;
+    getQueryTime<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): number | null;
+    getQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
+    getQuerySequence<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterable<ItemArray<T[K]>>;
+    setQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number;
+    updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number;
+    deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
 }
 /**
  * An individual table of data.

package/provider/MemoryProvider.js

@@ -1,9 +1,9 @@
+import { updateData } from "../update/DataUpdate.js";
 import { QueryConstraints } from "../constraint/QueryConstraints.js";
 import { getRandomKey } from "../util/random.js";
 import { isArrayEqual } from "../util/equal.js";
 import { RequiredError } from "../error/RequiredError.js";
 import { getArray } from "../util/array.js";
-import { transformData } from "../util/transform.js";
 import { DeferredSequence } from "../sequence/DeferredSequence.js";
 /**
  * Fast in-memory store for data.
@@ -135,7 +135,7 @@ export class MemoryTable {
         const item = this._data.get(id);
         if (!item)
             throw new RequiredError(`Document "${id}" does not exist`);
-        this._data.set(id, { ...transformData(item, updates), id });
+        this._data.set(id, { ...updateData(item, updates), id });
         this._times.set(id, Date.now());
         this._changed.resolve();
     }
@@ -231,7 +231,7 @@ export class MemoryTable {
         let count = 0;
         for (const item of _getWriteConstraints(constraints).transform(this._data.values())) {
             const id = item.id;
-            this._data.set(id, { ...transformData(item, updates), id });
+            this._data.set(id, { ...updateData(item, updates), id });
             this._times.set(id, now);
             count++;
         }