shelving 1.22.2 → 1.23.0

package/db/Database.d.ts

@@ -2,6 +2,7 @@ import { Entry, Observable, Observer, Result, Unsubscriber, ResultsMap, Validata
 import { Transform, Transforms } from "../transform/index.js";
 import type { Provider } from "../provider/Provider.js";
 import { Filters, Sorts, Query } from "../query/index.js";
+import { Write } from "./Write.js";
 /**
  * Combines a database model and a provider.
  *
@@ -141,37 +142,22 @@ export declare class DataDocument<T extends Data = Data> implements Observable<R
      * @return Function that ends the subscription.
      */
     subscribe(next: Observer<Result<T>> | Dispatcher<[Result<T>]>): Unsubscriber;
-    /**
-     * Set the complete data of this document.
-     *
-     * @param data Complete data to set the document to.
-     *
-     * @return Nothing (possibly promised).
-     */
+    /** Set the complete data of this document. */
     set(data: T): void | PromiseLike<void>;
-    /**
-     * Update this document with partial data.
-     * - If the document exists, merge the partial data into it.
-     * - If the document doesn't exist, throw an error.
-     *
-     * @param transforms `Transform` instance or set of transforms to apply to the existing document.
-     * - Not all transforms may be supported by all providers.
-     *
-     * @return Nothing (possibly promised).
-     * @throws Error If the document does not exist (ideally a `RequiredError` but may be provider-specific).
-     */
+    /** Update this document. */
     update(transforms: Transform<T> | Transforms<T>): void | PromiseLike<void>;
-    /**
-     * Delete this document.
-     * - Will not throw an error if the document doesn't exist.
-     *
-     * @return Nothing (possibly promised).
-     */
+    /** Delete this document. */
     delete(): void | PromiseLike<void>;
-    /**
-     * Combine `set()`, `update()`, `delete()` into a single method.
-     */
+    /** Set, update, or delete this document. */
     write(value: Result<T> | Transform<T>): void | PromiseLike<void>;
+    /** Represent a write that sets the complete data of this document in a database. */
+    setter(data: T): Write<T>;
+    /** Represent a write that updates this document in a database. */
+    updater(transforms: Transform<T> | Transforms<T>): Write<T>;
+    /** Represent a write that deletes this document in a database. */
+    deleter(): Write<T>;
+    /** Represent a write that sets, updates, or deletes this document in a database. */
+    writer(value: Result<T> | Transform<T>): Write<T>;
     /** Validate data for this query reference. */
     validate(unsafeData: Data): T;
     toString(): string;

package/db/Database.js

@@ -1,8 +1,9 @@
-import { callAsync, getFirstItem, throwAsync, validate, toMap, countItems, DeriveObserver, } from "../util/index.js";
+import { callAsync, getFirstItem, throwAsync, validate, toMap, countItems, TransformObserver, } from "../util/index.js";
 import { DataTransform, Transform } from "../transform/index.js";
 import { Feedback, InvalidFeedback } from "../feedback/index.js";
 import { Filters, Query, EqualFilter } from "../query/index.js";
 import { DocumentRequiredError, DocumentValidationError, QueryValidationError } from "./errors.js";
+import { Write } from "./Write.js";
 /**
  * Combines a database model and a provider.
  *
@@ -93,7 +94,7 @@ export class DataQuery extends Query {
      * @return Function that ends the subscription.
      */
     subscribeMap(next) {
-        return this.provider.subscribeQuery(this, new DeriveObserver(toMap, typeof next === "function" ? { next } : next));
+        return this.provider.subscribeQuery(this, new TransformObserver(toMap, typeof next === "function" ? { next } : next));
     }
     /**
      * Set all matching documents to the same exact value.
@@ -208,45 +209,38 @@ export class DataDocument {
     subscribe(next) {
         return this.provider.subscribe(this, typeof next === "function" ? { next } : next);
     }
-    /**
-     * Set the complete data of this document.
-     *
-     * @param data Complete data to set the document to.
-     *
-     * @return Nothing (possibly promised).
-     */
+    /** Set the complete data of this document. */
     set(data) {
         return this.write(data);
     }
-    /**
-     * Update this document with partial data.
-     * - If the document exists, merge the partial data into it.
-     * - If the document doesn't exist, throw an error.
-     *
-     * @param transforms `Transform` instance or set of transforms to apply to the existing document.
-     * - Not all transforms may be supported by all providers.
-     *
-     * @return Nothing (possibly promised).
-     * @throws Error If the document does not exist (ideally a `RequiredError` but may be provider-specific).
-     */
+    /** Update this document. */
     update(transforms) {
         return this.write(transforms instanceof Transform ? transforms : new DataTransform(transforms));
     }
-    /**
-     * Delete this document.
-     * - Will not throw an error if the document doesn't exist.
-     *
-     * @return Nothing (possibly promised).
-     */
+    /** Delete this document. */
     delete() {
         return this.write(undefined);
     }
-    /**
-     * Combine `set()`, `update()`, `delete()` into a single method.
-     */
+    /** Set, update, or delete this document. */
     write(value) {
         return this.provider.write(this, value);
     }
+    /** Represent a write that sets the complete data of this document in a database. */
+    setter(data) {
+        return this.writer(data);
+    }
+    /** Represent a write that updates this document in a database. */
+    updater(transforms) {
+        return this.writer(transforms instanceof Transform ? transforms : new DataTransform(transforms));
+    }
+    /** Represent a write that deletes this document in a database. */
+    deleter() {
+        return this.writer(undefined);
+    }
+    /** Represent a write that sets, updates, or deletes this document in a database. */
+    writer(value) {
+        return new Write(this, value);
+    }
     /** Validate data for this query reference. */
     validate(unsafeData) {
         try {

package/db/Pagination.js

@@ -71,7 +71,7 @@ export class Pagination extends State {
      * @return The change in the number of results.
      */
     merge(more) {
-        this.next(toMap(this.ref.sorts.derive(yieldMerged(more, this.value))));
+        this.next(toMap(this.ref.sorts.transform(yieldMerged(more, this.value))));
     }
     /** Iterate over the entries of the values currently in the pagination. */
     [Symbol.iterator]() {

package/db/Write.d.ts

@@ -0,0 +1,28 @@
+import { Transform } from "../transform/index.js";
+import { ImmutableArray, Data, Transformable } from "../util/index.js";
+import type { Database, DataDocument } from "./Database.js";
+/** Change transformable. */
+export declare type DatabaseTransformable = Transformable<Database, void | PromiseLike<void>>;
+/** Represent a write made to a single document in a database. */
+export declare class Write<T extends Data> implements Transformable<Database, void | PromiseLike<void>> {
+    readonly collection: string;
+    readonly id: string;
+    readonly value: Data | Transform<Data> | undefined;
+    constructor({ collection, id }: DataDocument<T>, value: T | Transform<T> | undefined);
+    transform(db: Database): Promise<void>;
+}
+/**
+ * Represent a list of writes made to a set of documents in a database.
+ * - Sets of writes are predictable and repeatable, so unpredictable operations like `create()` and query operations are not supported.
+ * - Every write must be applied to a specific database document in a specific collection and are applied in the specified order.
+ */
+export declare class Writes implements Transformable<Database, void | PromiseLike<void>> {
+    readonly writes: ImmutableArray<Write<Data>>;
+    constructor(...writes: Write<Data>[]);
+    transform(db: Database): Promise<void>;
+}
+/** Set of hydrations for all change classes. */
+export declare const DATABASE_HYDRATIONS: {
+    changes: typeof Writes;
+    change: typeof Write;
+};

package/db/Write.js

@@ -0,0 +1,32 @@
+import { transform } from "../util/index.js";
+/** Represent a write made to a single document in a database. */
+export class Write {
+    constructor({ collection, id }, value) {
+        this.collection = collection;
+        this.id = id;
+        this.value = value;
+    }
+    async transform(db) {
+        await db.doc(this.collection, this.id).write(this.value);
+    }
+}
+/**
+ * Represent a list of writes made to a set of documents in a database.
+ * - Sets of writes are predictable and repeatable, so unpredictable operations like `create()` and query operations are not supported.
+ * - Every write must be applied to a specific database document in a specific collection and are applied in the specified order.
+ */
+export class Writes {
+    constructor(...writes) {
+        this.writes = writes;
+    }
+    async transform(db) {
+        for (const writes of this.writes)
+            await transform(db, writes);
+    }
+}
+/** Set of hydrations for all change classes. */
+export const DATABASE_HYDRATIONS = {
+    changes: Writes,
+    change: Write,
+};
+DATABASE_HYDRATIONS;

package/db/index.d.ts

@@ -1,4 +1,4 @@
 export * from "./Database.js";
-export * from "./Change.js";
 export * from "./Pagination.js";
+export * from "./Write.js";
 export * from "./errors.js";

package/db/index.js

@@ -1,4 +1,4 @@
 export * from "./Database.js";
-export * from "./Change.js";
 export * from "./Pagination.js";
+export * from "./Write.js";
 export * from "./errors.js";

package/package.json

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

package/provider/BatchProvider.js

@@ -1,4 +1,4 @@
-import { isAsync, toMap, DeriveObserver, awaitNext, } from "../util/index.js";
+import { isAsync, toMap, TransformObserver, awaitNext, } from "../util/index.js";
 import { LazyState } from "../stream/index.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /** How long to wait after all subscriptions have ended to close the source subscription. */
@@ -80,7 +80,7 @@ export class BatchProvider extends ThroughProvider {
         const sub = ((_a = this._subs)[key] || (_a[key] = new LazyState(STOP_DELAY).from(o => {
             var _a;
             // Convert the iterable to a map because it might be read multiple times.
-            const stop = super.subscribeQuery(ref, new DeriveObserver(toMap, o));
+            const stop = super.subscribeQuery(ref, new TransformObserver(toMap, o));
             // The first value from the subscription can be reused for any concurrent get requests.
             (_a = this._gets)[key] || (_a[key] = this._awaitDocuments(ref, awaitNext(sub)));
             return () => {

package/provider/CacheProvider.js

@@ -1,5 +1,5 @@
 import { Transform } from "../transform/index.js";
-import { DeriveObserver } from "../util/index.js";
+import { TransformObserver } from "../util/index.js";
 import { MemoryProvider } from "./MemoryProvider.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /** Keep a copy of received data in a local cache. */
@@ -33,7 +33,7 @@ export class CacheProvider extends ThroughProvider {
     }
     // Override to cache any got results.
     subscribe(ref, observer) {
-        return super.subscribe(ref, new DeriveObserver(result => this._cacheResult(ref, result), observer));
+        return super.subscribe(ref, new TransformObserver(result => this._cacheResult(ref, result), observer));
     }
     async add(ref, data) {
         const id = await super.add(ref, data);
@@ -72,7 +72,7 @@ export class CacheProvider extends ThroughProvider {
     }
     // Override to cache any got results.
     subscribeQuery(ref, observer) {
-        return super.subscribeQuery(ref, new DeriveObserver(results => this._cacheResults(ref, results), observer));
+        return super.subscribeQuery(ref, new TransformObserver(results => this._cacheResults(ref, results), observer));
     }
     async writeQuery(ref, value) {
         await super.writeQuery(ref, value);

package/provider/MemoryProvider.js

@@ -46,19 +46,19 @@ export class MemoryProvider extends Provider {
             const existing = table.data.get(id);
             if (!existing)
                 throw new DocumentRequiredError(ref);
-            table.write(id, value.derive(existing));
+            table.write(id, value.transform(existing));
         }
         else {
             table.write(id, value);
         }
     }
     getQuery(ref) {
-        return ref.derive(this._table(ref).data);
+        return ref.transform(this._table(ref).data);
     }
     subscribeQuery(ref, observer) {
         const table = this._table(ref);
         // Call `next()` immediately with the initial results.
-        let lastResults = new Map(ref.derive(table.data));
+        let lastResults = new Map(ref.transform(table.data));
         dispatchNext(observer, lastResults);
         // Possibly call `next()` when the collection changes if any changes affect the subscription.
         return table.on(changes => {
@@ -68,7 +68,7 @@ export class MemoryProvider extends Provider {
                 // 2) the next document matches the query so might be added to the next results.
                 // Re-running the entire query is not the most efficient way to do this, but itis the most simple!
                 if (lastResults.has(id) || (next && ref.match([id, next]))) {
-                    const nextResults = new Map(ref.derive(table.data));
+                    const nextResults = new Map(ref.transform(table.data));
                     if (!isMapEqual(lastResults, nextResults)) {
                         lastResults = nextResults;
                         dispatchNext(observer, lastResults);
@@ -82,8 +82,8 @@ export class MemoryProvider extends Provider {
         const table = this._table(ref);
         // If there's a limit set: run the full query.
         // If there's no limit set: only need to run the filtering (more efficient because sort order doesn't matter).
-        for (const [id, existing] of ref.limit ? ref.derive(table.data) : ref.filters.derive(table.data))
-            table.write(id, value instanceof Transform ? value.derive(existing) : value);
+        for (const [id, existing] of ref.limit ? ref.transform(table.data) : ref.filters.transform(table.data))
+            table.write(id, value instanceof Transform ? value.transform(existing) : value);
     }
     /** Reset this provider and clear all data. */
     reset() {

package/query/Filter.d.ts

@@ -17,7 +17,7 @@ export declare abstract class Filter<T extends Data> extends Rule<T> implements
     readonly value: unknown;
     constructor(key: QueryKey<T>, value: unknown);
     match([id, data]: Entry<T>): boolean;
-    derive(results: Results<T>): Results<T>;
+    transform(results: Results<T>): Results<T>;
     toString(): string;
 }
 /** Filter a set of values with an `IS` clause. */

package/query/Filter.js

@@ -10,7 +10,7 @@ export class Filter extends Rule {
     match([id, data]) {
         return match(getQueryProp(id, data, this.key), this.matcher, this.value);
     }
-    derive(results) {
+    transform(results) {
         return filterItems(results, this);
     }
     toString() {

package/query/Filters.d.ts

@@ -13,5 +13,5 @@ export declare class Filters<T extends Data> extends Rules<T, Filter<T>> impleme
     gt<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
     gte<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
     match(entry: Entry<T>): boolean;
-    derive(iterable: Results<T>): Results<T>;
+    transform(iterable: Results<T>): Results<T>;
 }

package/query/Filters.js

@@ -33,7 +33,7 @@ export class Filters extends Rules {
                 return false;
         return true;
     }
-    derive(iterable) {
+    transform(iterable) {
         return this._rules.length ? filterItems(iterable, this) : iterable;
     }
 }

package/query/Query.d.ts

@@ -25,6 +25,6 @@ export declare class Query<T extends Data> extends Rule<T> implements Queryable<
     max(limit: number | null): this;
     after(id: string, data: T): this;
     before(id: string, data: T): this;
-    derive(results: Results<T>): Results<T>;
+    transform(results: Results<T>): Results<T>;
     toString(): string;
 }

package/query/Query.js

@@ -79,8 +79,8 @@ export class Query extends Rule {
         return { __proto__: Object.getPrototypeOf(this), ...this, filters: new Filters(...filters) };
     }
     // Implement `Rule`
-    derive(results) {
-        const sorted = this.sorts.derive(this.filters.derive(results));
+    transform(results) {
+        const sorted = this.sorts.transform(this.filters.transform(results));
         return typeof this.limit === "number" ? limitItems(sorted, this.limit) : sorted;
     }
     // Implement toString()

package/query/Rule.d.ts

@@ -1,6 +1,6 @@
-import { Data, Derivable, Results } from "../util/index.js";
+import { Data, Transformable, Results } from "../util/index.js";
 /** Something that can be used to query against a result set or an array of entries. */
-export declare abstract class Rule<T extends Data> implements Derivable<Results<T>, Results<T>> {
-    abstract derive(results: Results<T>): Results<T>;
+export declare abstract class Rule<T extends Data> implements Transformable<Results<T>, Results<T>> {
+    abstract transform(results: Results<T>): Results<T>;
     abstract toString(): string;
 }

package/query/Sort.d.ts

@@ -10,7 +10,7 @@ export declare abstract class Sort<T extends Data> extends Rule<T> implements Ra
     readonly key: QueryKey<T>;
     constructor(key: QueryKey<T>);
     rank([leftId, leftData]: Entry<T>, [rightId, rightData]: Entry<T>): number;
-    derive(iterable: Results<T>): Results<T>;
+    transform(iterable: Results<T>): Results<T>;
     toString(): string;
 }
 /** Sort a list of values in ascending order. */

package/query/Sort.js

@@ -9,7 +9,7 @@ export class Sort extends Rule {
     rank([leftId, leftData], [rightId, rightData]) {
         return rank(getQueryProp(leftId, leftData, this.key), this.ranker, getQueryProp(rightId, rightData, this.key));
     }
-    derive(iterable) {
+    transform(iterable) {
         return sortItems(iterable, this);
     }
     toString() {

package/query/Sorts.d.ts

@@ -7,5 +7,5 @@ export declare class Sorts<T extends Data> extends Rules<T, Sort<T>> implements
     asc(key: QueryKey<T>): this;
     desc(key: QueryKey<T>): this;
     rank(left: Entry<T>, right: Entry<T>): number;
-    derive(iterable: Results<T>): Results<T>;
+    transform(iterable: Results<T>): Results<T>;
 }

package/query/Sorts.js

@@ -17,7 +17,7 @@ export class Sorts extends Rules {
         }
         return 0;
     }
-    derive(iterable) {
+    transform(iterable) {
         return this._rules.length ? sortItems(iterable, this) : iterable;
     }
 }

package/react/useQuery.js

@@ -1,5 +1,5 @@
 import { useState } from "react";
-import { CacheProvider, throwAsync, NOERROR, findSourceProvider, NOVALUE, DeriveObserver, toMap, } from "../index.js";
+import { CacheProvider, throwAsync, NOERROR, findSourceProvider, NOVALUE, TransformObserver, toMap, } from "../index.js";
 import { usePureEffect } from "./usePureEffect.js";
 import { usePureMemo } from "./usePureMemo.js";
 import { usePureState } from "./usePureState.js";
@@ -37,7 +37,7 @@ function getCachedResults(ref) {
 function subscribeEffect(ref, maxAge, next, error) {
     if (ref) {
         const provider = findSourceProvider(ref.provider, CacheProvider);
-        const observer = new DeriveObserver(toMap, { next, error });
+        const observer = new TransformObserver(toMap, { next, error });
         const stopCache = provider.cache.subscribeQuery(ref, observer);
         if (maxAge === true) {
             // If `maxAge` is true subscribe to the source for as long as this component is attached.

package/stream/DataState.d.ts

@@ -1,9 +1,9 @@
-import { Key, Data, Derivers } from "../util/index.js";
+import { Key, Data, Transformers } from "../util/index.js";
 import { State } from "./State.js";
 /** State that stores an array and has additional methods to help with that. */
 export declare class DataState<T extends Data> extends State<T> {
     /** Set a prop in this object to a new value. */
     set<K extends Key<T>>(key: K, value: T[K]): void;
     /** Update several props in this object. */
-    update(updates: Derivers<T>): void;
+    update(updates: Transformers<T>): void;
 }

package/stream/DataState.js

@@ -1,4 +1,4 @@
-import { withProp, deriveData } from "../util/index.js";
+import { withProp, transformData } from "../util/index.js";
 import { State } from "./State.js";
 /** State that stores an array and has additional methods to help with that. */
 export class DataState extends State {
@@ -8,6 +8,6 @@ export class DataState extends State {
     }
     /** Update several props in this object. */
     update(updates) {
-        this.next(deriveData(this.value, updates));
+        this.next(transformData(this.value, updates));
     }
 }

package/stream/State.d.ts

@@ -1,4 +1,4 @@
-import { Deriver, LOADING, ObserverType, NOERROR, Observer } from "../util/index.js";
+import { Transformer, LOADING, ObserverType, NOERROR, Observer } from "../util/index.js";
 import { Stream } from "./Stream.js";
 /** Any state (useful for `extends AnySubscribable` clauses). */
 export declare type AnyState = State<any>;
@@ -14,8 +14,8 @@ export declare type AnyState = State<any>;
  * */
 export interface State<T> {
     to(): State<T>;
-    derive<TT>(deriver: Deriver<T, TT>): State<TT>;
-    deriveAsync<TT>(deriver: Deriver<T, Promise<TT>>): State<TT>;
+    derive<TT>(deriver: Transformer<T, TT>): State<TT>;
+    deriveAsync<TT>(deriver: Transformer<T, Promise<TT>>): State<TT>;
 }
 export declare class State<T> extends Stream<T> {
     static [Symbol.species]: typeof State;
@@ -33,7 +33,7 @@ export declare class State<T> extends Stream<T> {
     /** Is there a current value, or is it still loading. */
     get loading(): boolean;
     /** Apply a deriver to this state. */
-    apply(deriver: Deriver<T, T>): void;
+    apply(deriver: Transformer<T, T>): void;
     error(reason: Error | unknown): void;
     _on(observer: Observer<T>): void;
     protected _dispatch(value: T): void;

package/stream/State.js

@@ -1,5 +1,5 @@
 var _a;
-import { LOADING, NOERROR, dispatchNext, dispatchError, dispatchComplete, derive, getRequired, awaitNext, } from "../util/index.js";
+import { LOADING, NOERROR, dispatchNext, dispatchError, dispatchComplete, transform, getRequired, awaitNext, } from "../util/index.js";
 import { Stream } from "./Stream.js";
 export class State extends Stream {
     constructor() {
@@ -36,7 +36,7 @@ export class State extends Stream {
     }
     /** Apply a deriver to this state. */
     apply(deriver) {
-        this.next(derive(this.value, deriver));
+        this.next(transform(this.value, deriver));
     }
     // Override to save the reason at `this.reason` and clean up.
     error(reason) {

package/stream/Stream.d.ts

@@ -1,4 +1,4 @@
-import { Deriver, ObserverType, Subscribable, Unsubscriber, Observer, Observable, Constructor, Dispatcher } from "../util/index.js";
+import { Transformer, ObserverType, Subscribable, Unsubscriber, Observer, Observable, Constructor, Dispatcher } from "../util/index.js";
 /** Any stream (useful for `extends AnyStream` clauses). */
 export declare type AnyStream = Stream<any>;
 /**
@@ -44,12 +44,12 @@ export declare class Stream<T> implements Observer<T>, Observable<T> {
     /** Create a new stream from this stream. */
     to<O extends AnyStream>(target: O): O;
     to(): Stream<T>;
-    /** Derive a new stream from this stream using a deriver. */
-    derive<O extends AnyStream>(deriver: Deriver<T, ObserverType<O>>, target: O): O;
-    derive<TT>(deriver: Deriver<T, TT>): Stream<T>;
-    /** Derive a new stream from this stream using an async deriver. */
-    deriveAsync<O extends AnyStream>(deriver: Deriver<T, Promise<ObserverType<O>>>, target: O): O;
-    deriveAsync<TT>(deriver: Deriver<T, Promise<TT>>): Stream<T>;
+    /** Derive a new stream from this stream using a transformer. */
+    derive<O extends AnyStream>(transformer: Transformer<T, ObserverType<O>>, target: O): O;
+    derive<TT>(transformer: Transformer<T, TT>): Stream<T>;
+    /** Derive a new stream from this stream using an async transformer. */
+    deriveAsync<O extends AnyStream>(transformer: Transformer<T, Promise<ObserverType<O>>>, target: O): O;
+    deriveAsync<TT>(transformer: Transformer<T, Promise<TT>>): Stream<T>;
     /**
      * Subscribe to this stream and return an unsubscriber function.
      * - Allows either an `Observer` object or  separate `next()`, `error()` and `complete()` functions.

package/stream/Stream.js

@@ -1,5 +1,5 @@
 var _a;
-import { AsyncObserver, DeriveObserver, dispatchNext, dispatchError, dispatchComplete, subscribe, dispatch, } from "../util/index.js";
+import { AsyncObserver, TransformObserver, dispatchNext, dispatchError, dispatchComplete, subscribe, dispatch, } from "../util/index.js";
 import { ConditionError } from "../error/index.js";
 /**
  * Simple stream.
@@ -89,12 +89,12 @@ export class Stream {
         target.during(this, target);
         return target;
     }
-    derive(deriver, target = new this.constructor[Symbol.species]()) {
-        target.during(this, new DeriveObserver(deriver, target));
+    derive(transformer, target = new this.constructor[Symbol.species]()) {
+        target.during(this, new TransformObserver(transformer, target));
         return target;
     }
-    deriveAsync(deriver, target = new this.constructor[Symbol.species]()) {
-        target.during(this, new DeriveObserver(deriver, new AsyncObserver(target)));
+    deriveAsync(transformer, target = new this.constructor[Symbol.species]()) {
+        target.during(this, new TransformObserver(transformer, new AsyncObserver(target)));
         return target;
     }
     /**

package/transform/AddEntriesTransform.d.ts

@@ -4,7 +4,7 @@ import { Transform } from "./Transform.js";
 export declare class AddEntriesTransform<T> extends Transform<ImmutableObject<T>> implements Iterable<Entry<T>> {
     readonly props: ImmutableObject<T>;
     constructor(props: ImmutableObject<T>);
-    derive(existing?: unknown): ImmutableObject<T>;
+    transform(existing?: unknown): ImmutableObject<T>;
     /** Iterate over the entries. */
     [Symbol.iterator](): Iterator<Entry<T>, void>;
 }

package/transform/AddEntriesTransform.js

@@ -6,7 +6,7 @@ export class AddEntriesTransform extends Transform {
         super();
         this.props = props;
     }
-    derive(existing) {
+    transform(existing) {
         return isObject(existing) ? withEntries(existing, this.props) : {};
     }
     /** Iterate over the entries. */

package/transform/AddItemsTransform.d.ts

@@ -4,7 +4,7 @@ import { Transform } from "./Transform.js";
 export declare class AddItemsTransform<T> extends Transform<ImmutableArray<T>> implements Iterable<T> {
     readonly items: ImmutableArray<T>;
     constructor(...items: ImmutableArray<T>);
-    derive(existing?: unknown): ImmutableArray<T>;
+    transform(existing?: unknown): ImmutableArray<T>;
     /** Iterate over the items. */
     [Symbol.iterator](): Iterator<T, void>;
 }

package/transform/AddItemsTransform.js

@@ -6,7 +6,7 @@ export class AddItemsTransform extends Transform {
         super();
         this.items = items;
     }
-    derive(existing) {
+    transform(existing) {
         return isArray(existing) ? withItems(existing, this.items) : this.items;
     }
     /** Iterate over the items. */

package/transform/DataTransform.d.ts

@@ -14,7 +14,7 @@ export declare type Transforms<T extends Data> = {
 export declare class DataTransform<T extends Data> extends Transform<T> implements Iterable<Prop<Transforms<T>>> {
     readonly transforms: Transforms<T>;
     constructor(transforms: Transforms<T>);
-    derive(existing: T): T;
+    transform(existing: T): T;
     /** Return a new object with the specified additional transform. */
     prop<K extends Key<T>>(key: K, transform: T[K] | Transform<T[K]>): this;
     /** Return a new object with the specified additional transforms. */