@thi.ng/rstream 7.2.45 → 8.0.0

package/raf.d.ts

@@ -1,15 +1,26 @@
 import type { CommonOpts } from "./api.js";
+export interface FromRAFOpts extends CommonOpts {
+    /**
+     * Browser only. If true (default: false), passes the timestamps received
+     * via `requestAnimationFrame()` as stream values. If false, a simple
+     * counter [0..∞) will be emitted.
+     *
+     * @defaultValue false
+     */
+    timestamp: boolean;
+}
 /**
- * Yields {@link Stream} of a monotonically increasing counter,
- * triggered by a `requestAnimationFrame()` loop (only available in
- * browser environments).
+ * Yields {@link Stream} of a monotonically increasing counter (or timestamps),
+ * triggered by a `requestAnimationFrame()` loop (only available in browser
+ * environments).
  *
  * @remarks
- * In NodeJS, this function falls back to {@link fromInterval}, yielding
- * a similar (approx. 60Hz) stream.
+ * In NodeJS, this function falls back to {@link fromInterval}, yielding a
+ * similar (approx. 60Hz) stream (the {@link FromRAFOpts.timestamp} option will
+ * be ignored).
  *
- * All subscribers to this stream will be processed during that same
- * loop iteration.
+ * All subscribers to this stream will be processed during that same RAF loop
+ * iteration.
  */
-export declare const fromRAF: (opts?: Partial<CommonOpts>) => import("./stream.js").Stream<number>;
+export declare const fromRAF: (opts?: Partial<FromRAFOpts>) => import("./stream.js").Stream<number>;
 //# sourceMappingURL=raf.d.ts.map

package/raf.js

@@ -3,24 +3,25 @@ import { __optsWithID } from "./idgen.js";
 import { fromInterval } from "./interval.js";
 import { stream } from "./stream.js";
 /**
- * Yields {@link Stream} of a monotonically increasing counter,
- * triggered by a `requestAnimationFrame()` loop (only available in
- * browser environments).
+ * Yields {@link Stream} of a monotonically increasing counter (or timestamps),
+ * triggered by a `requestAnimationFrame()` loop (only available in browser
+ * environments).
  *
  * @remarks
- * In NodeJS, this function falls back to {@link fromInterval}, yielding
- * a similar (approx. 60Hz) stream.
+ * In NodeJS, this function falls back to {@link fromInterval}, yielding a
+ * similar (approx. 60Hz) stream (the {@link FromRAFOpts.timestamp} option will
+ * be ignored).
  *
- * All subscribers to this stream will be processed during that same
- * loop iteration.
+ * All subscribers to this stream will be processed during that same RAF loop
+ * iteration.
  */
-export const fromRAF = (opts) => isNode()
+export const fromRAF = (opts = {}) => isNode()
     ? fromInterval(16, opts)
     : stream((stream) => {
         let i = 0;
         let isActive = true;
-        const loop = () => {
-            isActive && stream.next(i++);
+        const loop = (time) => {
+            isActive && stream.next(opts.timestamp ? time : i++);
             isActive && (id = requestAnimationFrame(loop));
         };
         let id = requestAnimationFrame(loop);

package/sidechain-partition.d.ts

@@ -1,19 +1,20 @@
 import type { Predicate } from "@thi.ng/api";
-import { CommonOpts, ISubscribable } from "./api.js";
+import { type CommonOpts, type ISubscribable, type ISubscription } from "./api.js";
 import { ASidechain } from "./asidechain.js";
-import type { Subscription } from "./subscription.js";
 export interface SidechainPartitionOpts<T> extends CommonOpts {
     pred: Predicate<T>;
 }
 /**
- * Returns a {@link Subscription} which buffers values from `src` until
- * side chain fires, then emits buffer (unless empty) and repeats
- * process until either input is done.
+ * Returns a subscription which buffers values from `src` until side chain
+ * delivers its next value, then emits buffer (unless empty) and repeats process
+ * until either input is done.
  *
  * @remarks
- * By default, the values read from the side chain are ignored (i.e.
- * only their timing is used), however the `pred`icate option can be
- * used to only trigger for specific values / conditions.
+ * By default, the values read from the side chain are ignored (i.e. only their
+ * timing is used), however the `pred`icate option can be used to only trigger
+ * for specific values / conditions.
+ *
+ * Also see: {@link sidechainToggle}, {@link sidechainTrigger}, {@link syncRAF}.
  *
  * @example
  * ```t
@@ -26,23 +27,45 @@ export interface SidechainPartitionOpts<T> extends CommonOpts {
  *
  * // queue event processing to only execute during the
  * // requestAnimationFrame cycle (RAF)
- * events.subscribe(sidechainPartition(fromRAF())).subscribe(trace())
+ * sidechainPartition(events, fromRAF()).subscribe(trace())
  * ```
  *
+ * @param src -
  * @param side -
  * @param opts -
  */
-export declare const sidechainPartition: <A, B>(side: ISubscribable<B>, opts?: Partial<SidechainPartitionOpts<B>> | undefined) => Subscription<A, A[]>;
+export declare const sidechainPartition: <T, S>(src: ISubscribable<T>, side: ISubscribable<S>, opts?: Partial<SidechainPartitionOpts<S>> | undefined) => ISubscription<T, T[]>;
 /**
- * Syntax sugar for one of most common {@link sidechainPartition} use cases, to
- * synchronize downstream processing w/ `requestAnimationFrame()`. The returned
- * subscription debounces any high frequency intra-frame input values and (if
- * any present), passes only most recent one downstream *during* next RAF event
- * processing.
+ * **Deprecated** syntax sugar for one of most common {@link sidechainPartition}
+ * use cases, to synchronize downstream processing w/ `requestAnimationFrame()`.
+ * Please use {@link syncRAF} instead.
+ *
+ * @remarks
+ * The returned subscription debounces any high frequency intra-frame input
+ * values and (if any present), passes only most recent one downstream during
+ * next RAF event processing.
+ *
+ * This example uses thi.ng/atom as state container. Also see {@link fromAtom}
+ * and {@link syncRAF}.
+ *
+ * @example
+ * ```ts
+ * const atom = defAtom("alice");
+ *
+ * // any change to the atom will only be applied during next RAF update
+ * sideChainPartitionRAF(fromAtom(atom)).subscribe({
+ *   next({ name }) { document.body.innerText = name; }
+ * });
+ *
+ * // trigger update
+ * atom.reset("bob");
+ * ```
  *
  * @param src -
+ *
+ * @deprecated
  */
-export declare const sidechainPartitionRAF: <T>(src: ISubscribable<T>) => import("./api.js").ISubscription<T[], T>;
+export declare const sidechainPartitionRAF: <T>(src: ISubscribable<T>) => ISubscription<T[], T>;
 export declare class SidechainPartition<T, S> extends ASidechain<T, S, T[]> {
     buf: T[];
     constructor(side: ISubscribable<S>, opts?: Partial<SidechainPartitionOpts<S>>);

package/sidechain-partition.js

@@ -1,18 +1,20 @@
 import { peek } from "@thi.ng/arrays/peek";
 import { map } from "@thi.ng/transducers/map";
-import { State } from "./api.js";
+import { State, } from "./api.js";
 import { ASidechain } from "./asidechain.js";
 import { __optsWithID } from "./idgen.js";
 import { fromRAF } from "./raf.js";
 /**
- * Returns a {@link Subscription} which buffers values from `src` until
- * side chain fires, then emits buffer (unless empty) and repeats
- * process until either input is done.
+ * Returns a subscription which buffers values from `src` until side chain
+ * delivers its next value, then emits buffer (unless empty) and repeats process
+ * until either input is done.
  *
  * @remarks
- * By default, the values read from the side chain are ignored (i.e.
- * only their timing is used), however the `pred`icate option can be
- * used to only trigger for specific values / conditions.
+ * By default, the values read from the side chain are ignored (i.e. only their
+ * timing is used), however the `pred`icate option can be used to only trigger
+ * for specific values / conditions.
+ *
+ * Also see: {@link sidechainToggle}, {@link sidechainTrigger}, {@link syncRAF}.
  *
  * @example
  * ```t
@@ -25,45 +27,64 @@ import { fromRAF } from "./raf.js";
  *
  * // queue event processing to only execute during the
  * // requestAnimationFrame cycle (RAF)
- * events.subscribe(sidechainPartition(fromRAF())).subscribe(trace())
+ * sidechainPartition(events, fromRAF()).subscribe(trace())
  * ```
  *
+ * @param src -
  * @param side -
  * @param opts -
  */
-export const sidechainPartition = (side, opts) => new SidechainPartition(side, opts);
+export const sidechainPartition = (src, side, opts) => src.subscribe(new SidechainPartition(side, opts));
 /**
- * Syntax sugar for one of most common {@link sidechainPartition} use cases, to
- * synchronize downstream processing w/ `requestAnimationFrame()`. The returned
- * subscription debounces any high frequency intra-frame input values and (if
- * any present), passes only most recent one downstream *during* next RAF event
- * processing.
+ * **Deprecated** syntax sugar for one of most common {@link sidechainPartition}
+ * use cases, to synchronize downstream processing w/ `requestAnimationFrame()`.
+ * Please use {@link syncRAF} instead.
+ *
+ * @remarks
+ * The returned subscription debounces any high frequency intra-frame input
+ * values and (if any present), passes only most recent one downstream during
+ * next RAF event processing.
+ *
+ * This example uses thi.ng/atom as state container. Also see {@link fromAtom}
+ * and {@link syncRAF}.
+ *
+ * @example
+ * ```ts
+ * const atom = defAtom("alice");
+ *
+ * // any change to the atom will only be applied during next RAF update
+ * sideChainPartitionRAF(fromAtom(atom)).subscribe({
+ *   next({ name }) { document.body.innerText = name; }
+ * });
+ *
+ * // trigger update
+ * atom.reset("bob");
+ * ```
  *
  * @param src -
+ *
+ * @deprecated
  */
-export const sidechainPartitionRAF = (src) => src
-    .subscribe(sidechainPartition(fromRAF()))
-    .transform(map(peek));
+export const sidechainPartitionRAF = (src) => sidechainPartition(src, fromRAF()).transform(map(peek));
 export class SidechainPartition extends ASidechain {
     constructor(side, opts) {
         opts = __optsWithID("sidepart", opts);
         super(opts);
-        this.buf = [];
         const pred = opts.pred || (() => true);
-        const $this = this;
+        this.buf = [];
         this.sideSub = side.subscribe({
-            next(x) {
-                if ($this.buf.length && pred(x)) {
-                    $this.dispatch($this.buf);
-                    $this.buf = [];
+            next: (x) => {
+                if (this.buf.length && pred(x)) {
+                    this.dispatch(this.buf);
+                    this.buf = [];
                 }
             },
-            done() {
-                if ($this.buf.length) {
-                    $this.dispatch($this.buf);
+            done: () => {
+                if (this.buf.length) {
+                    this.dispatch(this.buf);
                 }
-                $this.done();
-                delete $this.buf;
+                this.done();
+                delete this.buf;
             },
         });
     }

package/sidechain-toggle.d.ts

@@ -1,28 +1,25 @@
 import type { Predicate } from "@thi.ng/api";
-import { CommonOpts, ISubscribable } from "./api.js";
+import { type CommonOpts, type ISubscribable, type ISubscription } from "./api.js";
 import { ASidechain } from "./asidechain.js";
-import type { Subscription } from "./subscription.js";
 export interface SidechainToggleOpts<T> extends CommonOpts {
     pred: Predicate<T>;
     initial: boolean;
 }
 /**
- * Returns {@link Subscription} which filters values from input based on
- * values received from side chain.
+ * Returns a subscription which filters values from `src` based on control
+ * values received from `side` chain.
  *
  * @remarks
- * By default, the value read from the side chain is ignored (i.e. only
- * their timing is used), however the `pred`icate option can be used to
- * only trigger for specific values/conditions. Every time the predicate
- * fn returns true, the filter will be toggled on/off. Whilst switched
- * off, no input values will be forwarded.
+ * By default, the values read from the side chain are ignored (i.e. only their
+ * timing is used), however the `pred`icate option can be used to only trigger
+ * for specific values/conditions. Every time the predicate fn returns true, the
+ * filter will be toggled on/off. Whilst switched off, no input values will be
+ * forwarded downstream.
  *
  * @example
  * ```ts
- * // use slower interval stream to toggle main stream on/off
- * fromInterval(500)
- *   .subscribe(sidechainToggle(fromInterval(1000)))
- *   .subscribe(trace());
+ * // use slower interval stream to toggle faster main stream on/off
+ * sidechainToggle(fromInterval(500), fromInterval(1000)).subscribe(trace());
  * // 0
  * // 3
  * // 4
@@ -31,10 +28,11 @@ export interface SidechainToggleOpts<T> extends CommonOpts {
  * ...
  * ```
  *
+ * @param src -
  * @param side -
  * @param opts -
  */
-export declare const sidechainToggle: <A, B>(side: ISubscribable<B>, opts?: Partial<SidechainToggleOpts<B>> | undefined) => Subscription<A, A>;
+export declare const sidechainToggle: <T, S>(src: ISubscribable<T>, side: ISubscribable<S>, opts?: Partial<SidechainToggleOpts<S>> | undefined) => ISubscription<T, T>;
 export declare class SidechainToggle<T, S> extends ASidechain<T, S, T> {
     isActive: boolean;
     constructor(side: ISubscribable<S>, opts?: Partial<SidechainToggleOpts<S>>);

package/sidechain-toggle.js

@@ -1,23 +1,21 @@
-import { State } from "./api.js";
+import { State, } from "./api.js";
 import { ASidechain } from "./asidechain.js";
 import { __optsWithID } from "./idgen.js";
 /**
- * Returns {@link Subscription} which filters values from input based on
- * values received from side chain.
+ * Returns a subscription which filters values from `src` based on control
+ * values received from `side` chain.
  *
  * @remarks
- * By default, the value read from the side chain is ignored (i.e. only
- * their timing is used), however the `pred`icate option can be used to
- * only trigger for specific values/conditions. Every time the predicate
- * fn returns true, the filter will be toggled on/off. Whilst switched
- * off, no input values will be forwarded.
+ * By default, the values read from the side chain are ignored (i.e. only their
+ * timing is used), however the `pred`icate option can be used to only trigger
+ * for specific values/conditions. Every time the predicate fn returns true, the
+ * filter will be toggled on/off. Whilst switched off, no input values will be
+ * forwarded downstream.
  *
  * @example
  * ```ts
- * // use slower interval stream to toggle main stream on/off
- * fromInterval(500)
- *   .subscribe(sidechainToggle(fromInterval(1000)))
- *   .subscribe(trace());
+ * // use slower interval stream to toggle faster main stream on/off
+ * sidechainToggle(fromInterval(500), fromInterval(1000)).subscribe(trace());
  * // 0
  * // 3
  * // 4
@@ -26,26 +24,24 @@ import { __optsWithID } from "./idgen.js";
  * ...
  * ```
  *
+ * @param src -
  * @param side -
  * @param opts -
  */
-export const sidechainToggle = (side, opts) => new SidechainToggle(side, opts);
+export const sidechainToggle = (src, side, opts) => src.subscribe(new SidechainToggle(side, opts));
 export class SidechainToggle extends ASidechain {
     constructor(side, opts) {
         opts = __optsWithID("sidetoggle", opts);
         super(opts);
         this.isActive = !!opts.initial;
         const pred = opts.pred || (() => true);
-        const $this = this;
         this.sideSub = side.subscribe({
-            next(x) {
+            next: (x) => {
                 if (pred(x)) {
-                    $this.isActive = !$this.isActive;
+                    this.isActive = !this.isActive;
                 }
             },
-            done() {
-                $this.done();
-            },
+            done: () => this.done(),
         });
     }
     next(x) {

package/sidechain-trigger.d.ts

@@ -0,0 +1,54 @@
+import type { Predicate } from "@thi.ng/api";
+import { SEMAPHORE } from "@thi.ng/api/api";
+import { type CommonOpts, type ISubscribable, type ISubscription } from "./api.js";
+import { ASidechain } from "./asidechain.js";
+export interface SidechainTriggerOpts<T> extends CommonOpts {
+    pred: Predicate<T>;
+}
+/**
+ * Returns a subscription which buffers the most recent value received from
+ * `src` and only forwards it downstream whenever a new control value is
+ * received from the `side` chain.
+ *
+ * @remarks
+ * By default, the values read from the side chain are ignored (i.e. only their
+ * timing is used), however the `pred`icate option can be used to only trigger
+ * for specific values/conditions. Every time the predicate fn returns true AND
+ * if `src` already has delivered at least one value, it will be forwarded
+ * downstream.
+ *
+ * @example
+ * ```ts
+ * const src = reactive("payload");
+ *
+ * const side = stream();
+ *
+ * sidechainTrigger(src, side).subscribe(trace("data:"));
+ *
+ * side.next(1);
+ * // data: payload
+ *
+ * side.next(1);
+ * // data: payload
+ *
+ * // only newest value will be buffered
+ * src.next("update #1");
+ * src.next("update #2");
+ *
+ * // ...until side chain triggers again
+ * side.next(1);
+ * // data: update #2
+ * ...
+ * ```
+ *
+ * @param src
+ * @param side
+ * @param opts
+ */
+export declare const sidechainTrigger: <T, S>(src: ISubscribable<T>, side: ISubscribable<S>, opts?: Partial<SidechainTriggerOpts<S>> | undefined) => ISubscription<T, T>;
+export declare class SidechainTrigger<T, S> extends ASidechain<T, S, T> {
+    buf: T | typeof SEMAPHORE;
+    constructor(side: ISubscribable<S>, opts?: Partial<SidechainTriggerOpts<S>>);
+    next(x: T): void;
+}
+//# sourceMappingURL=sidechain-trigger.d.ts.map

package/sidechain-trigger.js

@@ -0,0 +1,66 @@
+import { SEMAPHORE } from "@thi.ng/api/api";
+import { State, } from "./api.js";
+import { ASidechain } from "./asidechain.js";
+import { __optsWithID } from "./idgen.js";
+/**
+ * Returns a subscription which buffers the most recent value received from
+ * `src` and only forwards it downstream whenever a new control value is
+ * received from the `side` chain.
+ *
+ * @remarks
+ * By default, the values read from the side chain are ignored (i.e. only their
+ * timing is used), however the `pred`icate option can be used to only trigger
+ * for specific values/conditions. Every time the predicate fn returns true AND
+ * if `src` already has delivered at least one value, it will be forwarded
+ * downstream.
+ *
+ * @example
+ * ```ts
+ * const src = reactive("payload");
+ *
+ * const side = stream();
+ *
+ * sidechainTrigger(src, side).subscribe(trace("data:"));
+ *
+ * side.next(1);
+ * // data: payload
+ *
+ * side.next(1);
+ * // data: payload
+ *
+ * // only newest value will be buffered
+ * src.next("update #1");
+ * src.next("update #2");
+ *
+ * // ...until side chain triggers again
+ * side.next(1);
+ * // data: update #2
+ * ...
+ * ```
+ *
+ * @param src
+ * @param side
+ * @param opts
+ */
+export const sidechainTrigger = (src, side, opts) => src.subscribe(new SidechainTrigger(side, opts));
+export class SidechainTrigger extends ASidechain {
+    constructor(side, opts) {
+        opts = __optsWithID("sidetrigger", opts);
+        super(opts);
+        this.buf = SEMAPHORE;
+        const pred = opts.pred || (() => true);
+        this.sideSub = side.subscribe({
+            next: (x) => {
+                if (this.buf !== SEMAPHORE && pred(x)) {
+                    this.dispatch(this.buf);
+                }
+            },
+            done: () => this.done(),
+        });
+    }
+    next(x) {
+        if (this.state < State.DONE) {
+            this.buf = x;
+        }
+    }
+}

package/stream.d.ts

@@ -1,4 +1,4 @@
-import { CommonOpts, IStream, ISubscriber, ISubscription, StreamCancel, StreamSource, TransformableOpts, WithErrorHandlerOpts } from "./api.js";
+import { type CommonOpts, type IStream, type ISubscriber, type ISubscription, type StreamCancel, type StreamSource, type TransformableOpts, type WithErrorHandlerOpts } from "./api.js";
 import { Subscription } from "./subscription.js";
 /**
  * Creates a new {@link Stream} instance, optionally with given `StreamSource`

package/subscription.d.ts

@@ -1,7 +1,6 @@
 import type { Fn } from "@thi.ng/api";
-import type { Reducer, Transducer } from "@thi.ng/transducers";
-import { Reduced } from "@thi.ng/transducers/reduced";
-import { CloseMode, CommonOpts, ISubscriber, ISubscription, State, SubscriptionOpts, TransformableOpts, WithErrorHandlerOpts, WithTransform } from "./api.js";
+import type { Reduced, Reducer, Transducer } from "@thi.ng/transducers";
+import { CloseMode, State, type CommonOpts, type ISubscriber, type ISubscription, type SubscriptionOpts, type TransformableOpts, type WithErrorHandlerOpts, type WithTransform } from "./api.js";
 /**
  * Creates a new {@link Subscription} instance, the fundamental datatype and
  * building block provided by this package.

package/sync-raf.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+import { type CommonOpts, type ISubscribable } from "./api.js";
+import { Subscription } from "./subscription.js";
+/**
+ * Similar to (in in effect the same as the **now deprecated**)
+ * {@link sidechainPartitionRAF}, however more performant & lightweight.
+ * Synchronizes downstream processing w/ `requestAnimationFrame()`. The returned
+ * subscription delays & debounces any high frequency intra-frame input values
+ * and passes only most recent one downstream during next RAF event processing.
+ *
+ * This example uses thi.ng/atom as state container. Also see {@link fromAtom}.
+ *
+ * See {@link sidechainTrigger} from a similar & more general construct.
+ *
+ * @example
+ * ```ts
+ * const atom = defAtom("alice");
+ *
+ * // any changes to the atom will only be received by this subscription
+ * // during next RAF update cycle
+ * syncRAF(fromAtom(atom)).subscribe({
+ *   next({ name }) { document.body.innerText = name; }
+ * });
+ *
+ * // trigger update
+ * atom.reset("bob");
+ * ```
+ *
+ * @param src -
+ * @param opts -
+ */
+export declare const syncRAF: <T>(src: ISubscribable<T>, opts?: Partial<CommonOpts>) => import("./api.js").ISubscription<T, T>;
+/**
+ * See {@link syncRAF} for details.
+ */
+export declare class SyncRAF<T> extends Subscription<T, T> {
+    queued?: T;
+    raf?: number | NodeJS.Timeout;
+    constructor(opts?: Partial<CommonOpts>);
+    next(x: T): void;
+    done(): void;
+    error(e: any): boolean;
+    protected _clean(): void;
+}
+//# sourceMappingURL=sync-raf.d.ts.map

package/sync-raf.js

@@ -0,0 +1,72 @@
+import { isNode } from "@thi.ng/checks/is-node";
+import { State } from "./api.js";
+import { __optsWithID } from "./idgen.js";
+import { Subscription } from "./subscription.js";
+/**
+ * Similar to (in in effect the same as the **now deprecated**)
+ * {@link sidechainPartitionRAF}, however more performant & lightweight.
+ * Synchronizes downstream processing w/ `requestAnimationFrame()`. The returned
+ * subscription delays & debounces any high frequency intra-frame input values
+ * and passes only most recent one downstream during next RAF event processing.
+ *
+ * This example uses thi.ng/atom as state container. Also see {@link fromAtom}.
+ *
+ * See {@link sidechainTrigger} from a similar & more general construct.
+ *
+ * @example
+ * ```ts
+ * const atom = defAtom("alice");
+ *
+ * // any changes to the atom will only be received by this subscription
+ * // during next RAF update cycle
+ * syncRAF(fromAtom(atom)).subscribe({
+ *   next({ name }) { document.body.innerText = name; }
+ * });
+ *
+ * // trigger update
+ * atom.reset("bob");
+ * ```
+ *
+ * @param src -
+ * @param opts -
+ */
+export const syncRAF = (src, opts) => src.subscribe(new SyncRAF(__optsWithID(`syncraf-${src.id}`, opts)));
+/**
+ * See {@link syncRAF} for details.
+ */
+export class SyncRAF extends Subscription {
+    constructor(opts) {
+        super(undefined, opts);
+    }
+    next(x) {
+        if (this.state >= State.DONE)
+            return;
+        this.queued = x;
+        if (!this.raf) {
+            const update = () => {
+                if (this.state < State.DONE)
+                    super.next(this.queued);
+                this._clean();
+            };
+            this.raf = isNode()
+                ? setTimeout(update, 16)
+                : requestAnimationFrame(update);
+        }
+    }
+    done() {
+        this._clean();
+        super.done();
+    }
+    error(e) {
+        this._clean();
+        return super.error(e);
+    }
+    _clean() {
+        if (this.raf) {
+            isNode()
+                ? clearTimeout(this.raf)
+                : cancelAnimationFrame(this.raf);
+        }
+        this.raf = this.queued = undefined;
+    }
+}

package/sync.d.ts

@@ -1,5 +1,5 @@
 import type { Always, Derefed, IObjectOf } from "@thi.ng/api";
-import { PartitionSync } from "@thi.ng/transducers/partition-sync";
+import { type PartitionSync } from "@thi.ng/transducers/partition-sync";
 import type { ISubscribable, ISubscription, TransformableOpts } from "./api.js";
 import { Subscription } from "./subscription.js";
 export type SyncTuple<T extends IObjectOf<ISubscribable<any>>> = {

package/timeout.d.ts

@@ -1,4 +1,4 @@
-import { CommonOpts } from "./api.js";
+import { type CommonOpts } from "./api.js";
 import { Subscription } from "./subscription.js";
 export interface TimeoutOpts extends CommonOpts {
     /**