shelving 1.91.2 → 1.92.0

package/constraint/Constraints.js

@@ -1,34 +0,0 @@
-import { omitArrayItems, withArrayItems } from "../util/array.js";
-import { cloneObjectWith } from "../util/object.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 {
-    /** Get the first constraint. */
-    get first() {
-        return this._constraints[0];
-    }
-    /** Get the last constraint. */
-    get last() {
-        return this._constraints[this._constraints.length - 1];
-    }
-    /** Get the number of constraints. */
-    get size() {
-        return this._constraints.length;
-    }
-    constructor(...constraints) {
-        super();
-        this._constraints = constraints;
-    }
-    /** Clone this set of constraints but add additional constraints. */
-    with(...constraints) {
-        return cloneObjectWith(this, "_constraints", withArrayItems(this._constraints, ...constraints));
-    }
-    /** Clone this set of constraints but remove specific constraints. */
-    omit(...constraints) {
-        return cloneObjectWith(this, "_constraints", omitArrayItems(this._constraints, ...constraints));
-    }
-    /** Iterate over the constraints. */
-    [Symbol.iterator]() {
-        return this._constraints.values();
-    }
-}

package/constraint/Filter.d.ts

@@ -1,34 +0,0 @@
-import type { ImmutableArray } from "../util/array.js";
-import type { Data, FlatDataKey } from "../util/data.js";
-import type { Matchable } from "../util/match.js";
-import { Constraint } from "./Constraint.js";
-/** Possible operator references. */
-export type FilterOperator = "IS" | "NOT" | "IN" | "OUT" | "CONTAINS" | "LT" | "LTE" | "GT" | "GTE";
-/** Format that allows multiple filters to be specified as a plain object. */
-export type FilterProps<T extends Data> = {
-    [K in FlatDataKey<T> as `${K}` | `!${K}`]?: T[K] | ImmutableArray<T[K]>;
-} & {
-    [K in FlatDataKey<T> as `${K}<` | `${K}<=` | `${K}>` | `${K}>=`]?: T[K];
-} & {
-    [K in FlatDataKey<T> as `${K}[]`]?: Required<T>[K] extends ImmutableArray<infer X> ? X : never;
-};
-/** 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 type FilterKey<T extends Data> = keyof FilterProps<T>;
-/**
- * Filter: filters a list of data.
- *
- * @param key The name of a property that might exist on data in the collection.
- * @param operator FilterOperator, e.g. `IS` or `CONTAINS`
- * @param value Value the specified property should be matched against.
- */
-export declare class Filter<T extends Data = Data> extends Constraint<T> implements Matchable<[T]> {
-    readonly keys: readonly [string, ...string[]];
-    readonly operator: FilterOperator;
-    readonly value: unknown;
-    get key(): string;
-    get filterKey(): string;
-    constructor(filterKey: FilterKey<T>, value: unknown);
-    match(item: T): boolean;
-    transform(items: Iterable<T>): Iterable<T>;
-    toString(): string;
-}

package/constraint/Filter.js

@@ -1,89 +0,0 @@
-import { isArray } from "../util/array.js";
-import { isArrayWith, isEqual, isEqualGreater, isEqualLess, isGreater, isInArray, isLess, notEqual, notInArray } from "../util/equal.js";
-import { filterItems } from "../util/match.js";
-import { getProp } from "../util/object.js";
-import { splitString } from "../util/string.js";
-import { Constraint } from "./Constraint.js";
-/** Map `FilterOperator` to its corresponding `Match` function. */
-const MATCHERS = {
-    IS: isEqual,
-    NOT: notEqual,
-    IN: isInArray,
-    OUT: notInArray,
-    CONTAINS: isArrayWith,
-    LT: isLess,
-    LTE: isEqualLess,
-    GT: isGreater,
-    GTE: isEqualGreater,
-};
-/**
- * Filter: filters a list of data.
- *
- * @param key The name of a property that might exist on data in the collection.
- * @param operator FilterOperator, e.g. `IS` or `CONTAINS`
- * @param value Value the specified property should be matched against.
- */
-export class Filter extends Constraint {
-    get key() {
-        return this.keys.join(".");
-    }
-    get filterKey() {
-        const { operator, key } = this;
-        return operator === "IS" || operator === "IN"
-            ? key
-            : operator === "NOT" || operator === "OUT"
-                ? `!${key}`
-                : operator === "CONTAINS"
-                    ? `${key}[]`
-                    : operator === "LT"
-                        ? `${key}<`
-                        : operator === "LTE"
-                            ? `${key}<=`
-                            : operator === "GT"
-                                ? `${key}>`
-                                : operator === "GTE"
-                                    ? `${key}>=`
-                                    : operator; // Never.
-    }
-    constructor(filterKey, value) {
-        super();
-        if (filterKey.startsWith("!")) {
-            this.keys = splitString(filterKey.slice(1), ".");
-            this.operator = isArray(value) ? "OUT" : "NOT";
-        }
-        else if (filterKey.endsWith("[]")) {
-            this.keys = splitString(filterKey.slice(0, -2), ".");
-            this.operator = "CONTAINS";
-        }
-        else if (filterKey.endsWith(">")) {
-            this.keys = splitString(filterKey.slice(0, -1), ".");
-            this.operator = "GT";
-        }
-        else if (filterKey.endsWith(">=")) {
-            this.keys = splitString(filterKey.slice(0, -2), ".");
-            this.operator = "GTE";
-        }
-        else if (filterKey.endsWith("<")) {
-            this.keys = splitString(filterKey.slice(0, -1), ".");
-            this.operator = "LT";
-        }
-        else if (filterKey.endsWith("<=")) {
-            this.keys = splitString(filterKey.slice(0, -2), ".");
-            this.operator = "LTE";
-        }
-        else {
-            this.keys = splitString(filterKey, ".");
-            this.operator = isArray(value) ? "IN" : "IS";
-        }
-        this.value = value;
-    }
-    match(item) {
-        return MATCHERS[this.operator](getProp(item, ...this.keys), this.value);
-    }
-    transform(items) {
-        return filterItems(items, this);
-    }
-    toString() {
-        return `"${this.filterKey}":${JSON.stringify(this.value)}`;
-    }
-}

package/constraint/Filters.d.ts

@@ -1,27 +0,0 @@
-import type { FilterProps } from "./Filter.js";
-import type { Data } from "../util/data.js";
-import type { Matchable } from "../util/match.js";
-import { Constraints } from "./Constraints.js";
-import { Filter } from "./Filter.js";
-/** A possible set of filters. */
-export type PossibleFilters<T extends Data> = Filters<T> | FilterProps<T>;
-/** Turn `FilterProps` into a list of `Filter` instances. */
-export declare function getFilters<T extends Data>(filters: PossibleFilters<T>): Iterable<Filter<T>>;
-/** An object that is filterable. */
-export interface Filterable<T extends Data> extends Matchable<[T]> {
-    /** Add a filter to this filterable. */
-    filter(filters: PossibleFilters<T>): this;
-    /** Return a new instance of this class with no filters specified. */
-    unfiltered: this;
-    /** Match an item against the filters specified for this object. */
-    match(item: T): boolean;
-}
-/** A set of filters. */
-export declare class Filters<T extends Data = Data> extends Constraints<T, Filter<T>> implements Filterable<T> {
-    static from<X extends Data = Data>(filters: PossibleFilters<X>): Filters<X>;
-    filter(filters: PossibleFilters<T>): this;
-    get unfiltered(): this;
-    match(item: T): boolean;
-    transform(items: Iterable<T>): Iterable<T>;
-    toString(): string;
-}

package/constraint/Filters.js

@@ -1,41 +0,0 @@
-import { clearArray } from "../util/array.js";
-import { getDataProps } from "../util/data.js";
-import { filterItems } from "../util/match.js";
-import { cloneObjectWith } from "../util/object.js";
-import { Constraints } from "./Constraints.js";
-import { Filter } from "./Filter.js";
-/** Turn `FilterProps` into a list of `Filter` instances. */
-export function* getFilters(filters) {
-    if (filters instanceof Filters)
-        yield* filters;
-    else
-        for (const [key, value] of getDataProps(filters))
-            yield new Filter(key, value);
-}
-/** A set of filters. */
-export class Filters extends Constraints {
-    static from(filters) {
-        return filters instanceof Filters ? filters : new Filters(...getFilters(filters));
-    }
-    // Implement `Filterable`
-    filter(filters) {
-        return this.with(...getFilters(filters));
-    }
-    get unfiltered() {
-        return cloneObjectWith(this, "_constraints", clearArray(this._constraints));
-    }
-    match(item) {
-        for (const rule of this._constraints)
-            if (!rule.match(item))
-                return false;
-        return true;
-    }
-    // Implement `Rule`
-    transform(items) {
-        return this._constraints.length ? filterItems(items, this) : items;
-    }
-    // Stringify as object syntax.
-    toString() {
-        return this._constraints.length ? `"filters":{${this._constraints.map(String).join(",")}}` : "";
-    }
-}

package/constraint/Sort.d.ts

@@ -1,18 +0,0 @@
-import type { Data, FlatDataKey } from "../util/data.js";
-import type { Rankable } from "../util/sort.js";
-import { 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 type SortKey<T extends Data> = FlatDataKey<T> | `${FlatDataKey<T>}` | `!${FlatDataKey<T>}`;
-/** Possible operator references. */
-export type SortDirection = "ASC" | "DESC";
-/** Sort a list of values. */
-export declare class Sort<T extends Data = Data> extends Constraint<T> implements Rankable<T> {
-    readonly keys: readonly [string, ...string[]];
-    readonly direction: SortDirection;
-    get key(): string;
-    get sortKey(): string;
-    constructor(sortKey: SortKey<T>);
-    rank(left: T, right: T): number;
-    transform(items: Iterable<T>): Iterable<T>;
-    toString(): string;
-}

package/constraint/Sort.js

@@ -1,33 +0,0 @@
-import { getProp } from "../util/object.js";
-import { rank, rankAsc, rankDesc, sortItems } from "../util/sort.js";
-import { splitString } from "../util/string.js";
-import { Constraint } from "./Constraint.js";
-/** Sort a list of values. */
-export class Sort extends Constraint {
-    get key() {
-        return this.keys.join(".");
-    }
-    get sortKey() {
-        return `"${this.direction === "DESC" ? "!" : ""}${this.key}"`;
-    }
-    constructor(sortKey) {
-        super();
-        if (sortKey.startsWith("!")) {
-            this.keys = splitString(sortKey.slice(1), ".");
-            this.direction = "DESC";
-        }
-        else {
-            this.keys = splitString(sortKey, ".");
-            this.direction = "ASC";
-        }
-    }
-    rank(left, right) {
-        return rank(getProp(left, ...this.keys), this.direction === "ASC" ? rankAsc : rankDesc, getProp(right, ...this.keys));
-    }
-    transform(items) {
-        return sortItems(items, this);
-    }
-    toString() {
-        return this.sortKey;
-    }
-}

package/constraint/Sorts.d.ts

@@ -1,26 +0,0 @@
-import type { SortKey } from "./Sort.js";
-import type { ImmutableArray } from "../util/array.js";
-import type { Data } from "../util/data.js";
-import type { Rankable } from "../util/sort.js";
-import { Constraints } from "./Constraints.js";
-import { Sort } from "./Sort.js";
-/** A possible set of sorts. */
-export type PossibleSorts<T extends Data> = Sorts<T> | SortKey<T> | Iterable<SortKey<T>> | ImmutableArray<SortKey<T>>;
-/** Turn `SortList` into array of list of `Sort` instances. */
-export declare function getSorts<T extends Data>(sorts: PossibleSorts<T>): Iterable<Sort<T>>;
-/** An object that is sortable. */
-export interface Sortable<T extends Data> extends Rankable<T> {
-    /** Add one or more sorts to this sortable. */
-    sort(sorts: PossibleSorts<T>): this;
-    /** Return a new instance of this class with no sorts specified. */
-    unsorted: this;
-}
-/** A set of sorts. */
-export declare class Sorts<T extends Data = Data> extends Constraints<T, Sort<T>> implements Sortable<T> {
-    static from<X extends Data>(sorts: PossibleSorts<X>): Sorts<X>;
-    sort(sorts: PossibleSorts<T>): this;
-    get unsorted(): this;
-    rank(left: T, right: T): number;
-    transform(items: Iterable<T>): Iterable<T>;
-    toString(): string;
-}

package/constraint/Sorts.js

@@ -1,47 +0,0 @@
-import { clearArray } from "../util/array.js";
-import { cloneObjectWith } from "../util/object.js";
-import { sortItems } from "../util/sort.js";
-import { Constraints } from "./Constraints.js";
-import { Sort } from "./Sort.js";
-/** Turn `SortList` into array of list of `Sort` instances. */
-export function* getSorts(sorts) {
-    if (sorts instanceof Sorts) {
-        yield* sorts;
-    }
-    else if (typeof sorts === "string") {
-        yield new Sort(sorts);
-    }
-    else {
-        for (const sort of sorts)
-            yield new Sort(sort);
-    }
-}
-/** A set of sorts. */
-export class Sorts extends Constraints {
-    static from(sorts) {
-        return sorts instanceof Sorts ? sorts : new Sorts(...getSorts(sorts));
-    }
-    // Implement `Sortable`
-    sort(sorts) {
-        return this.with(...getSorts(sorts));
-    }
-    get unsorted() {
-        return cloneObjectWith(this, "_constraints", clearArray(this._constraints));
-    }
-    rank(left, right) {
-        for (const rule of this._constraints) {
-            const l = rule.rank(left, right);
-            if (l !== 0)
-                return l;
-        }
-        return 0;
-    }
-    // Implement `Rule`
-    transform(items) {
-        return this._constraints.length ? sortItems(items, this) : items;
-    }
-    // Stringify as array syntax.
-    toString() {
-        return this._constraints.length ? `"sorts":[${this._constraints.map(String).join(",")}]` : "";
-    }
-}

package/constraint/Statement.d.ts

@@ -1,45 +0,0 @@
-import type { Filterable, PossibleFilters } from "./Filters.js";
-import type { PossibleSorts, Sortable } from "./Sorts.js";
-import type { Data } from "../util/data.js";
-import { Constraint } from "./Constraint.js";
-import { Filters } from "./Filters.js";
-import { Sorts } from "./Sorts.js";
-/** Interface that combines Filterable, Sortable, Sliceable. */
-export interface Queryable<T extends Data> extends Filterable<T>, Sortable<T> {
-    /**
-     * Return a new instance of this class with an after offset defined.
-     * - Offset are based on the sort orders the collection's query uses.
-     * - Every key used for sorting (e.g. `date, title` must be defined in `item`
-     *
-     * @throws AssertionError if this query currently has no sort orders.
-     * @throws AssertionError if the input `item` did not contain a sorted value.
-     */
-    after(item: T): this;
-    /** Return a new instance of this class with a before offset defined. */
-    before(item: T): this;
-    /** The maximum number of items allowed by the limit. */
-    readonly limit: number | null;
-    /** Return a new instance of this class with no limit specified. */
-    readonly unlimited: this;
-    /** Return a new instance of this class with a limit set. */
-    max(max: number | null): this;
-}
-/** Allows filtering, sorting, and limiting on a set of results. */
-export declare class Statement<T extends Data = Data> extends Constraint<T> implements Queryable<T> {
-    readonly filters: Filters<T>;
-    readonly sorts: Sorts<T>;
-    readonly limit: number | null;
-    constructor(filters?: PossibleFilters<T>, sorts?: PossibleSorts<T>, limit?: number | null);
-    filter(filters: PossibleFilters<T>): this;
-    get unfiltered(): this;
-    match(item: T): boolean;
-    sort(sorts: PossibleSorts<T>): this;
-    get unsorted(): this;
-    rank(left: T, right: T): number;
-    after(item: T): this;
-    before(item: T): this;
-    get unlimited(): this;
-    max(limit: number | null): this;
-    transform(items: Iterable<T>): Iterable<T>;
-    toString(): string;
-}

package/constraint/Statement.js

@@ -1,79 +0,0 @@
-import { limitArray } from "../util/array.js";
-import { assert } from "../util/assert.js";
-import { cloneObjectWith, getProp } from "../util/object.js";
-import { Constraint } from "./Constraint.js";
-import { Filter } from "./Filter.js";
-import { Filters } from "./Filters.js";
-import { Sorts } from "./Sorts.js";
-// Instances to save resources for the default case (empty query).
-const EMPTY_FILTERS = new Filters(); // eslint-disable-line @typescript-eslint/no-explicit-any
-const EMPTY_SORTS = new Sorts(); // eslint-disable-line @typescript-eslint/no-explicit-any
-/** Allows filtering, sorting, and limiting on a set of results. */
-export class Statement extends Constraint {
-    constructor(filters = EMPTY_FILTERS, sorts = EMPTY_SORTS, limit = null) {
-        super();
-        this.filters = Filters.from(filters);
-        this.sorts = Sorts.from(sorts);
-        this.limit = limit;
-    }
-    // Implement `Filterable`
-    filter(filters) {
-        return cloneObjectWith(this, "filters", this.filters.filter(filters));
-    }
-    get unfiltered() {
-        return cloneObjectWith(this, "filters", this.filters.unfiltered);
-    }
-    match(item) {
-        return this.filters.match(item);
-    }
-    // Implement `Sortable`
-    sort(sorts) {
-        return cloneObjectWith(this, "sorts", this.sorts.sort(sorts));
-    }
-    get unsorted() {
-        return cloneObjectWith(this, "sorts", this.sorts.unsorted);
-    }
-    rank(left, right) {
-        return this.sorts.rank(left, right);
-    }
-    // Implement `Queryable`
-    after(item) {
-        return cloneObjectWith(this, "filters", this.filters.with(..._getAfterFilters(this.sorts, item)));
-    }
-    before(item) {
-        return cloneObjectWith(this, "filters", this.filters.with(..._getBeforeFilters(this.sorts, item)));
-    }
-    get unlimited() {
-        return this.max(null);
-    }
-    max(limit) {
-        return cloneObjectWith(this, "limit", limit);
-    }
-    // Implement `Rule`
-    transform(items) {
-        const sorted = this.sorts.transform(this.filters.transform(items));
-        return typeof this.limit === "number" ? limitArray(sorted, this.limit) : sorted;
-    }
-    // Implement toString()
-    toString() {
-        return [this.filters.toString(), this.sorts.toString(), typeof this.limit === "number" ? `"limit":${this.limit}` : null].filter(Boolean).join(",");
-    }
-}
-function* _getAfterFilters(sorts, item) {
-    const lastSort = sorts.last;
-    assert(lastSort);
-    for (const sort of sorts) {
-        const { key, keys, direction } = sort;
-        const filterKey = (direction === "ASC" ? (sort === lastSort ? `${key}>` : `${key}>=`) : sort === lastSort ? `${key}<` : `${key}<=`);
-        yield new Filter(filterKey, getProp(item, ...keys));
-    }
-}
-function* _getBeforeFilters(sorts, item) {
-    const lastSort = sorts.last;
-    assert(lastSort);
-    for (const sort of sorts) {
-        const { key, keys, direction } = sort;
-        const filterKey = (direction === "ASC" ? (sort === lastSort ? `${key}<` : `${key}<=`) : sort === lastSort ? `${key}>` : `${key}>=`);
-        yield new Filter(filterKey, getProp(item, ...keys));
-    }
-}

package/constraint/index.d.ts

@@ -1,7 +0,0 @@
-export * from "./Constraint.js";
-export * from "./Constraints.js";
-export * from "./Filter.js";
-export * from "./Filters.js";
-export * from "./Sort.js";
-export * from "./Sorts.js";
-export * from "./Statement.js";

package/constraint/index.js

@@ -1,7 +0,0 @@
-export * from "./Constraint.js";
-export * from "./Constraints.js";
-export * from "./Filter.js";
-export * from "./Filters.js";
-export * from "./Sort.js";
-export * from "./Sorts.js";
-export * from "./Statement.js";

package/db/Collection.d.ts

@@ -1,64 +0,0 @@
-import type { AddChange, DeleteChange, SetChange, UpdateChange } from "./Change.js";
-import type { ItemData, ItemValue } from "./Item.js";
-import type { PossibleFilters } from "../constraint/Filters.js";
-import type { PossibleSorts } from "../constraint/Sorts.js";
-import type { AsyncProvider, Provider } from "../provider/Provider.js";
-import type { Updates } from "../update/DataUpdate.js";
-import type { Data } from "../util/data.js";
-import { AsyncItem, Item } from "./Item.js";
-import { AsyncQuery, Query } from "./Query.js";
-/** Reference to a collection in a synchronous or asynchronous provider. */
-declare abstract class BaseCollection<T extends Data = Data> {
-    abstract readonly provider: Provider | AsyncProvider;
-    abstract readonly collection: string;
-    /** Create a query on this item's collection. */
-    abstract query(filters?: PossibleFilters<ItemData<T>>, sorts?: PossibleSorts<ItemData<T>>, limit?: number | null): Query<T> | AsyncQuery<T>;
-    /** Create a query on this item's collection. */
-    abstract item(id: string): Item<T> | AsyncItem<T>;
-    /** Get an item from this collection. */
-    abstract get(id: string): ItemValue<T> | Promise<ItemValue<T>>;
-    /** Add an item to this collection. */
-    abstract add(data: T): string | Promise<string>;
-    /** Set a document in this collection. */
-    abstract set(id: string, data: T): void | Promise<void>;
-    /** Update a document in this collection. */
-    abstract update(id: string, updates: Updates<T>): void | Promise<void>;
-    /** Delete a document in this collection. */
-    abstract delete(id: string): void | Promise<void>;
-    /** Get an add change for this collection. */
-    getAdd(data: T): AddChange<T>;
-    /** Get a set change for this collection. */
-    getSet(id: string, data: T): SetChange<T>;
-    /** Get an update change for this collection. */
-    getUpdate(id: string, updates: Updates<T>): UpdateChange<T>;
-    /** Get a delete change for this collection. */
-    getDelete(id: string): DeleteChange;
-    toString(): string;
-}
-/** Reference to a collection in a synchronous provider. */
-export declare class Collection<T extends Data = Data> extends BaseCollection<T> {
-    readonly provider: Provider;
-    readonly collection: string;
-    constructor(provider: Provider, collection: string);
-    query(filters?: PossibleFilters<ItemData<T>>, sorts?: PossibleSorts<ItemData<T>>, limit?: number | null): Query<T>;
-    item(id: string): Item<T>;
-    get(id: string): ItemValue<T>;
-    add(data: T): string;
-    set(id: string, data: T): void;
-    update(id: string, updates: Updates<T>): void;
-    delete(id: string): void;
-}
-/** Reference to a collection in an asynchronous provider. */
-export declare class AsyncCollection<T extends Data = Data> extends BaseCollection<T> {
-    readonly provider: AsyncProvider;
-    readonly collection: string;
-    constructor(provider: AsyncProvider, collection: string);
-    query(filters?: PossibleFilters<ItemData<T>>, sorts?: PossibleSorts<ItemData<T>>, limit?: number | null): AsyncQuery<T>;
-    item(id: string): AsyncItem<T>;
-    get(id: string): Promise<ItemValue<T>>;
-    add(data: T): Promise<string>;
-    set(id: string, data: T): Promise<void>;
-    update(id: string, updates: Updates<T>): Promise<void>;
-    delete(id: string): Promise<void>;
-}
-export {};

package/db/Collection.js

@@ -1,83 +0,0 @@
-import { AsyncItem, Item } from "./Item.js";
-import { AsyncQuery, Query } from "./Query.js";
-/** Reference to a collection in a synchronous or asynchronous provider. */
-class BaseCollection {
-    /** Get an add change for this collection. */
-    getAdd(data) {
-        return { action: "ADD", collection: this.collection, data };
-    }
-    /** Get a set change for this collection. */
-    getSet(id, data) {
-        return { action: "SET", collection: this.collection, id, data };
-    }
-    /** Get an update change for this collection. */
-    getUpdate(id, updates) {
-        return { action: "UPDATE", collection: this.collection, id, updates };
-    }
-    /** Get a delete change for this collection. */
-    getDelete(id) {
-        return { action: "DELETE", collection: this.collection, id };
-    }
-    // Implement toString()
-    toString() {
-        return this.collection;
-    }
-}
-/** Reference to a collection in a synchronous provider. */
-export class Collection extends BaseCollection {
-    constructor(provider, collection) {
-        super();
-        this.provider = provider;
-        this.collection = collection;
-    }
-    query(filters, sorts, limit) {
-        return new Query(this.provider, this.collection, filters, sorts, limit);
-    }
-    item(id) {
-        return new Item(this.provider, this.collection, id);
-    }
-    get(id) {
-        return this.provider.getItem(this.collection, id);
-    }
-    add(data) {
-        return this.provider.addItem(this.collection, data);
-    }
-    set(id, data) {
-        return this.provider.setItem(this.collection, id, data);
-    }
-    update(id, updates) {
-        return this.provider.updateItem(this.collection, id, updates);
-    }
-    delete(id) {
-        return this.provider.deleteItem(this.collection, id);
-    }
-}
-/** Reference to a collection in an asynchronous provider. */
-export class AsyncCollection extends BaseCollection {
-    constructor(provider, collection) {
-        super();
-        this.provider = provider;
-        this.collection = collection;
-    }
-    query(filters, sorts, limit) {
-        return new AsyncQuery(this.provider, this.collection, filters, sorts, limit);
-    }
-    item(id) {
-        return new AsyncItem(this.provider, this.collection, id);
-    }
-    get(id) {
-        return this.provider.getItem(this.collection, id);
-    }
-    add(data) {
-        return this.provider.addItem(this.collection, data);
-    }
-    set(id, data) {
-        return this.provider.setItem(this.collection, id, data);
-    }
-    update(id, updates) {
-        return this.provider.updateItem(this.collection, id, updates);
-    }
-    delete(id) {
-        return this.provider.deleteItem(this.collection, id);
-    }
-}