shelving 1.22.1 → 1.23.2

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/useDocument.js

@@ -1,5 +1,5 @@
 import { useState } from "react";
-import { CacheProvider, throwAsync, NOERROR, findSourceProvider, NOVALUE, dispatchAsync } from "../index.js";
+import { CacheProvider, throwAsync, NOERROR, findSourceProvider, NOVALUE } from "../index.js";
 import { usePureEffect } from "./usePureEffect.js";
 import { usePureMemo } from "./usePureMemo.js";
 import { usePureState } from "./usePureState.js";
@@ -22,7 +22,7 @@ export function useAsyncDocument(ref, maxAge = 1000) {
     // If `maxAge` is `true` open a subscription for 10 seconds.
     // Done before `ref.get()` because efficient providers (i.e. `BatchProvider`) will reuse the subscription's first result as its first get request.
     if (maxAge === true)
-        setTimeout(ref.subscribe(setNext, setError), 10000);
+        setTimeout(ref.subscribe({ next: setNext, error: setError }), 10000);
     // Return a promise for the result.
     return ref.result;
 }
@@ -49,7 +49,7 @@ function subscribeEffect(ref, maxAge, next, error) {
         else {
             // If cache provider's cached document is older than maxAge then force refresh the data.
             if (provider.getCachedAge(ref) > maxAge)
-                dispatchAsync(ref.result, next, error);
+                Promise.resolve(ref.result).then(next, error);
         }
         return stopCache;
     }

package/react/useFetch.js

@@ -23,7 +23,7 @@ export function useFetch(fetcher, deps, maxAge = 86400000) {
         // Create a new state and start a fetch.
         state = new State();
         sources.set(key, state);
-        dispatchAsyncNext(fetcher(...deps), state);
+        dispatchAsyncNext(state, fetcher(...deps));
     }
     else if (state.closed) {
         // Clean up source in a few seconds if it's closed.
@@ -32,7 +32,7 @@ export function useFetch(fetcher, deps, maxAge = 86400000) {
     }
     else if (state.age > maxAge) {
         // Refetch if state has value and it's older than `maxAge`
-        dispatchAsyncNext(fetcher(...deps), state);
+        dispatchAsyncNext(state, fetcher(...deps));
     }
     useSubscribe(state);
     return state;

package/react/usePureState.d.ts

@@ -1,4 +1,4 @@
-import { Arguments, Dispatcher } from "../index.js";
+import { Arguments } from "../index.js";
 /**
  * Version of React's `useState()` that allows the use of a pure (side-effect free) function.
  * - Unlike `useState()` the initialiser will be re-run and the state will be regenerated if `args` changes.
@@ -13,6 +13,6 @@ import { Arguments, Dispatcher } from "../index.js";
  * - This means you can create the function once (outside the component) rather than creating it on every render.
  * - This improves performance (though probably only noticeable on functions that render 1,000s of times).
  */
-export declare function usePureState<T, A extends Arguments>(initial: (...args: A) => T, ...args: A): readonly [T, Dispatcher<T>];
-export declare function usePureState<T, A extends Arguments>(initial: new (...args: A) => T, ...args: A): readonly [T, Dispatcher<T>];
-export declare function usePureState<T>(initial: T, ...args: Arguments): readonly [T, Dispatcher<T>];
+export declare function usePureState<T, A extends Arguments>(initial: (...args: A) => T, ...args: A): readonly [T, (next: T) => void];
+export declare function usePureState<T, A extends Arguments>(initial: new (...args: A) => T, ...args: A): readonly [T, (next: T) => void];
+export declare function usePureState<T>(initial: T, ...args: Arguments): readonly [T, (next: T) => void];

package/react/useQuery.js

@@ -1,5 +1,5 @@
 import { useState } from "react";
-import { CacheProvider, throwAsync, NOERROR, findSourceProvider, NOVALUE, dispatchAsync, 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";
@@ -22,7 +22,7 @@ export function useAsyncQuery(ref, maxAge = 1000) {
     // If `maxAge` is `true` open a subscription for 10 seconds.
     // Done before `ref.get()` because efficient providers (i.e. `BatchProvider`) will reuse the subscription's first result as its first get request.
     if (maxAge === true)
-        setTimeout(ref.subscribeMap(setNext, setError), 10000);
+        setTimeout(ref.subscribeMap({ next: setNext, error: setError }), 10000);
     // Return a promise for the result.
     return ref.resultsMap;
 }
@@ -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.
@@ -50,7 +50,7 @@ function subscribeEffect(ref, maxAge, next, error) {
         else {
             // If cache provider's cached document is older than maxAge then force refresh the data.
             if (provider.getCachedAge(ref) > maxAge)
-                dispatchAsync(ref.resultsMap, next, error);
+                Promise.resolve(ref.resultsMap).then(next, error);
         }
         return stopCache;
     }

package/react/useSubscribe.js

@@ -14,4 +14,4 @@ export function useSubscribe(subscribable) {
     usePureEffect(subscribeEffect, useState(LOADING)[1], subscribable);
 }
 /** Effect that subscribes the component to changes in the `State` instance for the lifetime of the component. */
-const subscribeEffect = (setChange, subscribable) => subscribable ? subscribe(subscribable, { next: setChange, error: setChange }) : undefined;
+const subscribeEffect = (change, subscribable) => subscribable ? subscribe(subscribable, { next: change, error: change }) : undefined;

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/LastStream.js

@@ -4,7 +4,7 @@ import { Stream } from "./Stream.js";
 export class LastStream extends Stream {
     // Override to dispatch only to a slice of the subscribers.
     _dispatch(value) {
-        const subscriber = getLastItem(this._subscribers);
+        const subscriber = getLastItem(this._observers);
         if (subscriber)
             dispatchNext(subscriber, value);
     }

package/stream/LazyState.d.ts

@@ -8,5 +8,5 @@ export declare class LazyState<T> extends State<T> {
     private _delay;
     private _timeout?;
     constructor(delay?: number);
-    off(observer: Observer<T>): void;
+    _off(observer: Observer<T>): void;
 }

package/stream/LazyState.js

@@ -9,20 +9,20 @@ export class LazyState extends State {
         this._delay = delay;
     }
     // Override to stop the source subscription when the last subscriber unsubscribes.
-    off(observer) {
-        super.off(observer);
+    _off(observer) {
+        super._off(observer);
         if (this._delay) {
             // Maybe stop in a bit (if there are still no subscribers).
             if (this._timeout)
                 clearTimeout(this._timeout);
             this._timeout = setTimeout(() => {
-                if (!this._subscribers.size && !this.closed)
+                if (!this._observers.size && !this.closed)
                     this.complete();
             }, this._delay);
         }
         else {
             // Stop now.
-            if (!this._subscribers.size && !this.closed)
+            if (!this._observers.size && !this.closed)
                 this.complete();
         }
     }

package/stream/LazyStream.d.ts

@@ -8,5 +8,5 @@ export declare class LazyStream<T> extends Stream<T> {
     private _delay;
     private _timeout?;
     constructor(delay?: number);
-    off(observer: Observer<T>): void;
+    _off(observer: Observer<T>): void;
 }

package/stream/LazyStream.js

@@ -9,19 +9,19 @@ export class LazyStream extends Stream {
         this._delay = delay;
     }
     // Override to stop the source subscription when the last subscriber unsubscribes.
-    off(observer) {
-        super.off(observer);
+    _off(observer) {
+        super._off(observer);
         if (this._delay) {
             // Maybe stop in a bit (if there are still no subscribers).
-            if (!this._subscribers.size && !this.closed) {
+            if (!this._observers.size && !this.closed) {
                 if (this._timeout)
                     clearTimeout(this._timeout);
-                this._timeout = setTimeout(() => !this._subscribers.size && !this.closed && this.complete(), this._delay);
+                this._timeout = setTimeout(() => !this._observers.size && !this.closed && this.complete(), this._delay);
             }
         }
         else {
             // Stop now.
-            if (!this._subscribers.size && !this.closed)
+            if (!this._observers.size && !this.closed)
                 this.complete();
         }
     }

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>(transformer: Transformer<T, TT>): State<TT>;
+    deriveAsync<TT>(transformer: Transformer<T, PromiseLike<TT>>): State<TT>;
 }
 export declare class State<T> extends Stream<T> {
     static [Symbol.species]: typeof State;
@@ -33,9 +33,9 @@ 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;
+    _on(observer: Observer<T>): void;
     protected _dispatch(value: T): void;
 }
 /** Create a state with an initial value. */

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) {
@@ -45,14 +45,14 @@ export class State extends Stream {
         super.error(reason);
     }
     // Override to send the current error or value to any new subscribers.
-    on(observer) {
-        super.on(observer);
+    _on(observer) {
+        super._on(observer);
         if (this.reason !== NOERROR)
-            dispatchError(this.reason, observer);
+            dispatchError(observer, this.reason);
         else if (this.closed)
             dispatchComplete(observer);
         else if (this._value !== LOADING)
-            dispatchNext(this.value, observer);
+            dispatchNext(observer, this._value);
     }
     // Dispatcher saves any values that are dispatched.
     _dispatch(value) {

package/stream/Stream.d.ts

@@ -1,4 +1,4 @@
-import { Deriver, ObserverType, Subscribable, Dispatcher, Unsubscriber, Observer, Observable, Constructor } 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>;
 /**
@@ -11,7 +11,7 @@ export declare class Stream<T> implements Observer<T>, Observable<T> {
     /** List of sources this stream is subscribed to. */
     protected readonly _cleanups: Set<Unsubscriber>;
     /** List of subscribed observers that values are forwarded to. */
-    protected readonly _subscribers: Set<Observer<T>>;
+    protected readonly _observers: Set<Observer<T>>;
     /** Get the number of current subscribers. */
     get subscribers(): number;
     /** Is this stream open or closed (i.e. `error()` or `complete()` have been called. */
@@ -44,20 +44,20 @@ 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, PromiseLike<TT>>): Stream<T>;
     /**
      * Subscribe to this stream and return an unsubscriber function.
      * - Allows either an `Observer` object or  separate `next()`, `error()` and `complete()` functions.
      * - Implements `Observable`
      */
-    subscribe(next: Observer<T> | Dispatcher<T>, error?: Dispatcher<unknown>, complete?: Dispatcher<void>): Unsubscriber;
-    /** Add an observer to this stream. */
-    on(observer: Observer<T>): void;
-    /** Remove an observer from this stream. */
-    off(observer: Observer<T>): void;
+    subscribe(next: Observer<T> | Dispatcher<[T]>): Unsubscriber;
+    /** Add an observer. */
+    _on(observer: Observer<T>): void;
+    /** Remove an observer. */
+    _off(observer: Observer<T>): void;
 }

package/stream/Stream.js

@@ -1,5 +1,5 @@
 var _a;
-import { AsyncObserver, DeriveObserver, dispatchNext, dispatchError, dispatchComplete, createObserver, 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.
@@ -10,13 +10,13 @@ export class Stream {
         /** List of sources this stream is subscribed to. */
         this._cleanups = new Set();
         /** List of subscribed observers that values are forwarded to. */
-        this._subscribers = new Set();
+        this._observers = new Set();
         /** Is this stream open or closed (i.e. `error()` or `complete()` have been called. */
         this.closed = false;
     }
     /** Get the number of current subscribers. */
     get subscribers() {
-        return this._subscribers.size;
+        return this._observers.size;
     }
     /**
      * Send a next value.
@@ -29,8 +29,8 @@ export class Stream {
     }
     /** Call `next()` on the subscribers. */
     _dispatch(value) {
-        for (const subscriber of this._subscribers)
-            dispatchNext(value, subscriber);
+        for (const observer of this._observers)
+            dispatchNext(observer, value);
     }
     /**
      * Complete this stream with an error.
@@ -41,9 +41,9 @@ export class Stream {
         if (this.closed)
             throw new ConditionError("Stream is closed");
         this._close();
-        for (const subscriber of this._subscribers) {
-            dispatchError(reason, subscriber);
-            this.off(subscriber);
+        for (const subscriber of this._observers) {
+            this._observers.delete(subscriber);
+            dispatchError(subscriber, reason);
         }
     }
     /**
@@ -55,17 +55,17 @@ export class Stream {
         if (this.closed)
             throw new ConditionError("Stream is closed");
         this._close();
-        for (const subscriber of this._subscribers) {
+        for (const subscriber of this._observers) {
+            this._observers.delete(subscriber);
             dispatchComplete(subscriber);
-            this.off(subscriber);
         }
     }
     /** Close this stream. */
     _close() {
         this.closed = true;
         for (const cleanup of this._cleanups) {
-            dispatch(undefined, cleanup);
             this._cleanups.delete(cleanup);
+            dispatch(cleanup);
         }
     }
     /** Start a subscription that gets cleaned up when this subscriber ends. */
@@ -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;
     }
     /**
@@ -102,18 +102,18 @@ export class Stream {
      * - Allows either an `Observer` object or  separate `next()`, `error()` and `complete()` functions.
      * - Implements `Observable`
      */
-    subscribe(next, error, complete) {
-        const observer = createObserver(next, error, complete);
-        this.on(observer);
-        return this.off.bind(this, observer);
+    subscribe(next) {
+        const observer = typeof next === "function" ? { next } : next;
+        this._on(observer);
+        return this._off.bind(this, observer);
     }
-    /** Add an observer to this stream. */
-    on(observer) {
-        this._subscribers.add(observer);
+    /** Add an observer. */
+    _on(observer) {
+        this._observers.add(observer);
     }
-    /** Remove an observer from this stream. */
-    off(observer) {
-        this._subscribers.delete(observer);
+    /** Remove an observer. */
+    _off(observer) {
+        this._observers.delete(observer);
     }
 }
 _a = Symbol.species;

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. */

package/transform/DataTransform.js

@@ -1,4 +1,4 @@
-import { deriveData } from "../util/index.js";
+import { transformData } from "../util/index.js";
 import { Transform } from "./Transform.js";
 /** Set of transforms that can be appled to an object's properties. */
 export class DataTransform extends Transform {
@@ -6,8 +6,8 @@ export class DataTransform extends Transform {
         super();
         this.transforms = transforms;
     }
-    derive(existing) {
-        return deriveData(existing, this.transforms);
+    transform(existing) {
+        return transformData(existing, this.transforms);
     }
     /** Return a new object with the specified additional transform. */
     prop(key, transform) {

package/transform/IncrementTransform.d.ts

@@ -8,5 +8,5 @@ export declare class IncrementTransform extends Transform<number> {
     static DECREMENT_ONE: IncrementTransform;
     readonly amount: number;
     constructor(amount: number);
-    derive(existing?: unknown): number;
+    transform(existing?: unknown): number;
 }

package/transform/IncrementTransform.js

@@ -8,7 +8,7 @@ export class IncrementTransform extends Transform {
         super();
         this.amount = amount;
     }
-    derive(existing) {
+    transform(existing) {
         return typeof existing === "number" ? existing + this.amount : this.amount;
     }
 }

package/transform/RemoveEntriesTransform.d.ts

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

package/transform/RemoveEntriesTransform.js

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

package/transform/RemoveItemsTransform.d.ts

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

package/transform/RemoveItemsTransform.js

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

package/transform/Transform.d.ts

@@ -1,9 +1,9 @@
-import { Derivable } from "../util/index.js";
+import { Transformable } from "../util/index.js";
 /**
  * An object that transforms an existing value value into a new value with its `transform()` method.
  * - Probably has a configuration that accompanies it.
  */
-export declare abstract class Transform<T> implements Derivable<T, T> {
+export declare abstract class Transform<T> implements Transformable<T, T> {
     /** Apply this transform to a value. */
-    abstract derive(existing?: unknown): T;
+    abstract transform(existing?: unknown): T;
 }