@ringcentral/juno 2.40.1 → 2.41.0

package/components/Virtuoso/react-virtuoso/upwardScrollFixSystem.js

@@ -1,28 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-var u = tslib_1.__importStar(require("@virtuoso.dev/urx"));
+var u = tslib_1.__importStar(require("./urx"));
 var domIOSystem_1 = require("./domIOSystem");
 var listStateSystem_1 = require("./listStateSystem");
-var loggerSystem_1 = require("./loggerSystem");
 var sizeSystem_1 = require("./sizeSystem");
 var stateFlagsSystem_1 = require("./stateFlagsSystem");
+var loggerSystem_1 = require("./loggerSystem");
+var simpleMemoize_1 = require("./utils/simpleMemoize");
+var recalcSystem_1 = require("./recalcSystem");
+var AATree_1 = require("./AATree");
+var isMobileSafari = simpleMemoize_1.simpleMemoize(function () {
+    return /iP(ad|od|hone)/i.test(navigator.userAgent) && /WebKit/i.test(navigator.userAgent);
+});
 /**
  * Fixes upward scrolling by calculating and compensation from changed item heights, using scrollBy.
  */
 exports.upwardScrollFixSystem = u.system(function (_a) {
-    var _b = tslib_1.__read(_a, 5), _c = _b[0], scrollBy = _c.scrollBy, scrollTop = _c.scrollTop, deviation = _c.deviation, scrollingInProgress = _c.scrollingInProgress, _d = _b[1], isScrolling = _d.isScrolling, isAtBottom = _d.isAtBottom, atBottomState = _d.atBottomState, scrollDirection = _d.scrollDirection, lastJumpDueToItemResize = _d.lastJumpDueToItemResize, listState = _b[2].listState, _e = _b[3], beforeUnshiftWith = _e.beforeUnshiftWith, shiftWithOffset = _e.shiftWithOffset, sizes = _e.sizes, log = _b[4].log;
+    var _b = tslib_1.__read(_a, 6), _c = _b[0], scrollBy = _c.scrollBy, scrollTop = _c.scrollTop, deviation = _c.deviation, scrollingInProgress = _c.scrollingInProgress, _d = _b[1], isScrolling = _d.isScrolling, isAtBottom = _d.isAtBottom, scrollDirection = _d.scrollDirection, lastJumpDueToItemResize = _d.lastJumpDueToItemResize, listState = _b[2].listState, _e = _b[3], beforeUnshiftWith = _e.beforeUnshiftWith, shiftWithOffset = _e.shiftWithOffset, sizes = _e.sizes, gap = _e.gap, log = _b[4].log, recalcInProgress = _b[5].recalcInProgress;
     var deviationOffset = u.streamFromEmitter(u.pipe(listState, u.withLatestFrom(lastJumpDueToItemResize), u.scan(function (_a, _b) {
         var _c = tslib_1.__read(_a, 4), prevItems = _c[1], prevTotalCount = _c[2], prevTotalHeight = _c[3];
-        var _d = tslib_1.__read(_b, 2), 
-        // @ts-ignore
-        _e = _d[0], items = _e.items, totalCount = _e.totalCount, bottom = _e.bottom, offsetBottom = _e.offsetBottom, lastJumpDueToItemResize = _d[1];
+        var _d = tslib_1.__read(_b, 2), _e = _d[0], items = _e.items, totalCount = _e.totalCount, bottom = _e.bottom, offsetBottom = _e.offsetBottom, lastJumpDueToItemResize = _d[1];
         var totalHeight = bottom + offsetBottom;
         var newDev = 0;
         if (prevTotalCount === totalCount) {
             if (prevItems.length > 0 && items.length > 0) {
-                var atStart = items[0].originalIndex === 0 &&
-                    prevItems[0].originalIndex === 0;
+                var atStart = items[0].originalIndex === 0 && prevItems[0].originalIndex === 0;
                 if (!atStart) {
                     newDev = totalHeight - prevTotalHeight;
                     if (newDev !== 0) {
@@ -35,28 +38,15 @@ exports.upwardScrollFixSystem = u.system(function (_a) {
     }, [0, [], 0, 0]), u.filter(function (_a) {
         var _b = tslib_1.__read(_a, 1), amount = _b[0];
         return amount !== 0;
-    }), u.withLatestFrom(scrollTop, scrollDirection, scrollingInProgress, log, isAtBottom, atBottomState), u.filter(function (_a) {
-        var _b = tslib_1.__read(_a, 4), scrollTop = _b[1], scrollDirection = _b[2], scrollingInProgress = _b[3];
-        // console.log({ amount, scrollTop, scrollDirection, scrollingInProgress, isAtBottom, atBottomState })
-        return (!scrollingInProgress && scrollTop !== 0 && scrollDirection === stateFlagsSystem_1.UP); // && (isAtBottom ? amount > 0 : true)
+    }), u.withLatestFrom(scrollTop, scrollDirection, scrollingInProgress, isAtBottom, log, recalcInProgress), u.filter(function (_a) {
+        var _b = tslib_1.__read(_a, 7), scrollTop = _b[1], scrollDirection = _b[2], scrollingInProgress = _b[3], recalcInProgress = _b[6];
+        return !recalcInProgress && !scrollingInProgress && scrollTop !== 0 && scrollDirection === stateFlagsSystem_1.UP;
     }), u.map(function (_a) {
-        var _b = tslib_1.__read(_a, 5), _c = tslib_1.__read(_b[0], 1), amount = _c[0], log = _b[4];
+        var _b = tslib_1.__read(_a, 6), _c = tslib_1.__read(_b[0], 1), amount = _c[0], log = _b[5];
         log('Upward scrolling compensation', { amount: amount }, loggerSystem_1.LogLevel.DEBUG);
         return amount;
     })));
-    u.connect(u.pipe(deviationOffset, u.withLatestFrom(deviation), u.map(function (_a) {
-        var _b = tslib_1.__read(_a, 2), amount = _b[0], deviation = _b[1];
-        return deviation - amount;
-    })), deviation);
-    // when the browser stops scrolling,
-    // restore the position and reset the glitching
-    u.subscribe(u.pipe(u.combineLatest(u.statefulStreamFromEmitter(isScrolling, false), deviation), u.filter(function (_a) {
-        var _b = tslib_1.__read(_a, 2), is = _b[0], deviation = _b[1];
-        return !is && deviation !== 0;
-    }), u.map(function (_a) {
-        var _b = tslib_1.__read(_a, 2), deviation = _b[1];
-        return deviation;
-    }), u.throttleTime(1)), function (offset) {
+    function scrollByWith(offset) {
         if (offset > 0) {
             u.publish(scrollBy, { top: -offset, behavior: 'auto' });
             u.publish(deviation, 0);
@@ -65,13 +55,66 @@ exports.upwardScrollFixSystem = u.system(function (_a) {
             u.publish(deviation, 0);
             u.publish(scrollBy, { top: -offset, behavior: 'auto' });
         }
+    }
+    u.subscribe(u.pipe(deviationOffset, u.withLatestFrom(deviation, isScrolling)), function (_a) {
+        var _b = tslib_1.__read(_a, 3), offset = _b[0], deviationAmount = _b[1], isScrolling = _b[2];
+        if (isScrolling && isMobileSafari()) {
+            u.publish(deviation, deviationAmount - offset);
+        }
+        else {
+            scrollByWith(-offset);
+        }
     });
+    // this hack is only necessary for mobile safari which does not support scrollBy while scrolling is in progress.
+    // when the browser stops scrolling, restore the position and reset the glitching
+    u.subscribe(u.pipe(u.combineLatest(u.statefulStreamFromEmitter(isScrolling, false), deviation, recalcInProgress), u.filter(function (_a) {
+        var _b = tslib_1.__read(_a, 3), is = _b[0], deviation = _b[1], recalc = _b[2];
+        return !is && !recalc && deviation !== 0;
+    }), u.map(function (_a) {
+        var _b = tslib_1.__read(_a, 2), _ = _b[0], deviation = _b[1];
+        return deviation;
+    }), u.throttleTime(1)), scrollByWith);
     u.connect(u.pipe(shiftWithOffset, u.map(function (offset) {
         return { top: -offset };
     })), scrollBy);
-    u.connect(u.pipe(beforeUnshiftWith, u.withLatestFrom(sizes), u.map(function (_a) {
-        var _b = tslib_1.__read(_a, 2), offset = _b[0], lastSize = _b[1].lastSize;
-        return offset * lastSize;
-    })), deviationOffset);
+    u.subscribe(u.pipe(beforeUnshiftWith, u.withLatestFrom(sizes, gap), u.map(function (_a) {
+        var _b = tslib_1.__read(_a, 3), offset = _b[0], _c = _b[1], defaultItemSize = _c.lastSize, groupIndices = _c.groupIndices, sizeTree = _c.sizeTree, gap = _b[2];
+        function getItemOffset(itemCount) {
+            return itemCount * (defaultItemSize + gap);
+        }
+        if (groupIndices.length === 0) {
+            return getItemOffset(offset);
+        }
+        else {
+            var amount = 0;
+            var defaultGroupSize = AATree_1.find(sizeTree, 0);
+            var recognizedOffsetItems = 0;
+            var groupIndex = 0;
+            while (recognizedOffsetItems < offset) {
+                // increase once for the group itself
+                recognizedOffsetItems++;
+                amount += defaultGroupSize;
+                var groupItemCount = groupIndices.length === groupIndex + 1 ? Infinity : groupIndices[groupIndex + 1] - groupIndices[groupIndex] - 1;
+                // if the group is larger than the offset, we have an expanded group. remove the group size, and replace with 1 item.
+                if (recognizedOffsetItems + groupItemCount > offset) {
+                    amount -= defaultGroupSize;
+                    groupItemCount = offset - recognizedOffsetItems + 1;
+                }
+                recognizedOffsetItems += groupItemCount;
+                amount += getItemOffset(groupItemCount);
+                groupIndex++;
+            }
+            return amount;
+        }
+    })), function (offset) {
+        u.publish(deviation, offset);
+        requestAnimationFrame(function () {
+            u.publish(scrollBy, { top: offset });
+            requestAnimationFrame(function () {
+                u.publish(deviation, 0);
+                u.publish(recalcInProgress, false);
+            });
+        });
+    });
     return { deviation: deviation };
-}, u.tup(domIOSystem_1.domIOSystem, stateFlagsSystem_1.stateFlagsSystem, listStateSystem_1.listStateSystem, sizeSystem_1.sizeSystem, loggerSystem_1.loggerSystem));
+}, u.tup(domIOSystem_1.domIOSystem, stateFlagsSystem_1.stateFlagsSystem, listStateSystem_1.listStateSystem, sizeSystem_1.sizeSystem, loggerSystem_1.loggerSystem, recalcSystem_1.recalcSystem));

package/components/Virtuoso/react-virtuoso/urx/actions.d.ts

@@ -0,0 +1,127 @@
+/**
+ * urx Actions operate on streams - `publish` publishes data in a stream, and `subscribe` attaches a subscription to a stream.
+ * @packageDocumentation
+ */
+import { PUBLISH, RESET, SUBSCRIBE, VALUE } from './constants';
+/**
+ * A Publisher is the **input end** of a Stream. The [[publish]] action publishes values in publishers.
+ * @typeParam T the type of values to be published.
+ */
+export interface Publisher<T> {
+    /** @internal */
+    (action: PUBLISH, value: T): void;
+}
+/**
+ * An Emitter is the **output end** of a Stream. The [[subscribe]] action binds {@link Subscription | subscriptions} to emitters.
+ * @typeParam T the type of values that will be emitted.
+ */
+export interface Emitter<T> {
+    /** @internal */
+    (action: SUBSCRIBE, subscription: Subscription<T>): Unsubscribe;
+    /** @internal */
+    (action: RESET): void;
+}
+export interface Cell<T> {
+    /** @internal */
+    (action: VALUE): T;
+}
+/**
+ * Subscriptions are bound to Emitters with the [[subscribe]] action, and get called with the new values.
+ * @typeParam T the Emitter value type.
+ */
+export interface Subscription<T> {
+    (value: T): any;
+}
+/**
+ * Subscribe-like actions return unsubscribe handles of the Unsubscribe type, which, when called, unbind the subscription.
+ */
+export interface Unsubscribe {
+    (): void;
+}
+export declare type StreamArgs<T> = [PUBLISH] | [SUBSCRIBE, Subscription<T>] | [RESET];
+/**
+ * Streams present both the input and the output ends of a stream.
+ * A single stream instance can be both subscribed to and published in.
+ */
+export interface Stream<T> extends Publisher<T>, Emitter<T> {
+    /** @internal */
+    (action: SUBSCRIBE | PUBLISH | RESET): any;
+}
+/**
+ * Just like {@link Stream | streams}, stateful streams present both input and output ends of a stream.
+ * A single stream instance can be both subscribed to and published in.
+ * Stateful Streams can also act like depots, preserving the last passed value and immediately publishing it to new subscriptions.
+ * [[getValue]] can be used to extract value from stateful streams.
+ */
+export interface StatefulStream<T> extends Publisher<T>, Emitter<T> {
+    /** @internal */
+    (action: SUBSCRIBE | PUBLISH | RESET | VALUE): any;
+}
+/**
+ * Subscribes the specified [[Subscription]] to the updates from the Emitter.
+ * The emitter calls the subscription with the new data each time new data is published into it.
+ *
+ * ```ts
+ * const foo = stream<number>();
+ * subscribe(foo, (value) => console.log(value));
+ * ```
+ *
+ * @returns an [[Unsubscribe]] handle  - calling it will unbind the subscription from the emitter.
+ *```ts
+ * const foo = stream<number>();
+ * const unsub = subscribe(foo, (value) => console.log(value));
+ * unsub();
+ *```
+ */
+export declare function subscribe<T>(emitter: Emitter<T>, subscription: Subscription<T>): Unsubscribe;
+/**
+ * Publishes the value into the passed [[Publisher]].
+ *
+ * ```ts
+ * const foo = stream<number>();
+ * publish(foo, 42);
+ * ```
+ */
+export declare function publish<T>(publisher: Publisher<T>, value: T): void;
+/**
+ * Clears all subscriptions from the [[Emitter]].
+ * ```ts
+ * const foo = stream<number>();
+ * subscribe(foo, (value) => console.log(value));
+ * reset(foo);
+ * publish(foo, 42);
+ * ```
+ */
+export declare function reset(emitter: Emitter<any>): void;
+/**
+ * Extracts the current value from a stateful stream. Use it only as an escape hatch, as it violates the concept of reactive programming.
+ * ```ts
+ * const foo = statefulStream(42);
+ * console.log(getValue(foo));
+ * ```
+ */
+export declare function getValue<T>(depot: StatefulStream<T>): T;
+/**
+ * Connects two streams - any value emitted from the emitter will be published in the publisher.
+ * ```ts
+ * const foo = stream<number>();
+ * const bar = stream<number>();
+ * subscribe(bar, (value) => console.log(`Bar emitted ${value}`));
+ *
+ * connect(foo, bar);
+ * publish(foo);
+ * ```
+ * @returns an [[Unsubscribe]] handle which will disconnect the two streams.
+ */
+export declare function connect<T>(emitter: Emitter<T>, publisher: Publisher<any>): Unsubscribe;
+/**
+ * Executes the passed subscription at most once, for the next emit from the emitter.
+ * ```ts
+ * const foo = stream<number>()
+ * handleNext(foo, value => console.log(value)) // called once, with 42
+ * publish(foo, 42)
+ * publish(foo, 43)
+ * ```
+ * @returns an [[Unsubscribe]] handle to unbind the subscription if necessary.
+ */
+export declare function handleNext<T>(emitter: Emitter<T>, subscription: Subscription<T>): Unsubscribe;

package/components/Virtuoso/react-virtuoso/urx/actions.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * urx Actions operate on streams - `publish` publishes data in a stream, and `subscribe` attaches a subscription to a stream.
+ * @packageDocumentation
+ */
+var constants_1 = require("./constants");
+var utils_1 = require("./utils");
+/**
+ * Subscribes the specified [[Subscription]] to the updates from the Emitter.
+ * The emitter calls the subscription with the new data each time new data is published into it.
+ *
+ * ```ts
+ * const foo = stream<number>();
+ * subscribe(foo, (value) => console.log(value));
+ * ```
+ *
+ * @returns an [[Unsubscribe]] handle  - calling it will unbind the subscription from the emitter.
+ *```ts
+ * const foo = stream<number>();
+ * const unsub = subscribe(foo, (value) => console.log(value));
+ * unsub();
+ *```
+ */
+function subscribe(emitter, subscription) {
+    return emitter(constants_1.SUBSCRIBE, subscription);
+}
+exports.subscribe = subscribe;
+/**
+ * Publishes the value into the passed [[Publisher]].
+ *
+ * ```ts
+ * const foo = stream<number>();
+ * publish(foo, 42);
+ * ```
+ */
+function publish(publisher, value) {
+    publisher(constants_1.PUBLISH, value);
+}
+exports.publish = publish;
+/**
+ * Clears all subscriptions from the [[Emitter]].
+ * ```ts
+ * const foo = stream<number>();
+ * subscribe(foo, (value) => console.log(value));
+ * reset(foo);
+ * publish(foo, 42);
+ * ```
+ */
+function reset(emitter) {
+    emitter(constants_1.RESET);
+}
+exports.reset = reset;
+/**
+ * Extracts the current value from a stateful stream. Use it only as an escape hatch, as it violates the concept of reactive programming.
+ * ```ts
+ * const foo = statefulStream(42);
+ * console.log(getValue(foo));
+ * ```
+ */
+function getValue(depot) {
+    return depot(constants_1.VALUE);
+}
+exports.getValue = getValue;
+/**
+ * Connects two streams - any value emitted from the emitter will be published in the publisher.
+ * ```ts
+ * const foo = stream<number>();
+ * const bar = stream<number>();
+ * subscribe(bar, (value) => console.log(`Bar emitted ${value}`));
+ *
+ * connect(foo, bar);
+ * publish(foo);
+ * ```
+ * @returns an [[Unsubscribe]] handle which will disconnect the two streams.
+ */
+function connect(emitter, publisher) {
+    return subscribe(emitter, utils_1.curry2to1(publisher, constants_1.PUBLISH));
+}
+exports.connect = connect;
+/**
+ * Executes the passed subscription at most once, for the next emit from the emitter.
+ * ```ts
+ * const foo = stream<number>()
+ * handleNext(foo, value => console.log(value)) // called once, with 42
+ * publish(foo, 42)
+ * publish(foo, 43)
+ * ```
+ * @returns an [[Unsubscribe]] handle to unbind the subscription if necessary.
+ */
+function handleNext(emitter, subscription) {
+    var unsub = emitter(constants_1.SUBSCRIBE, function (value) {
+        unsub();
+        subscription(value);
+    });
+    return unsub;
+}
+exports.handleNext = handleNext;

package/components/Virtuoso/react-virtuoso/urx/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const PUBLISH: 0;
+export declare type PUBLISH = typeof PUBLISH;
+export declare const SUBSCRIBE: 1;
+export declare type SUBSCRIBE = typeof SUBSCRIBE;
+export declare const RESET: 2;
+export declare type RESET = typeof RESET;
+export declare const VALUE: 4;
+export declare type VALUE = typeof VALUE;

package/components/Virtuoso/react-virtuoso/urx/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PUBLISH = 0;
+exports.SUBSCRIBE = 1;
+exports.RESET = 2;
+exports.VALUE = 4;

package/components/Virtuoso/react-virtuoso/urx/index.d.ts

@@ -0,0 +1,6 @@
+export * from './streams';
+export * from './transformers';
+export * from './pipe';
+export * from './actions';
+export * from './system';
+export * from './utils';

package/components/Virtuoso/react-virtuoso/urx/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./streams"), exports);
+tslib_1.__exportStar(require("./transformers"), exports);
+tslib_1.__exportStar(require("./pipe"), exports);
+tslib_1.__exportStar(require("./actions"), exports);
+tslib_1.__exportStar(require("./system"), exports);
+tslib_1.__exportStar(require("./utils"), exports);

package/components/Virtuoso/react-virtuoso/urx/package.json

@@ -0,0 +1,5 @@
+{
+  "sideEffects": false,
+  "module": "../../../../es6/components/Virtuoso/react-virtuoso/urx/index.js",
+  "typings": "./index.d.ts"
+}

package/components/Virtuoso/react-virtuoso/urx/pipe.d.ts

@@ -0,0 +1,220 @@
+import { Emitter } from './actions';
+/**
+ * Operators can transform and control the flow of values.
+ * [[pipe]] is used to transform one Emitter into another by stacking operators to its values.
+ * To build your own operator that looks like the built-in ones,
+ * create a function which returns an operator.
+ * The following custom operator multiplies the passed value:
+ *
+ * ```ts
+ * function multiplyBy(multiplier: number): Operator<number> {
+ *  return done => value => done(value * multiplier)
+ * }
+ *
+ * const foo = stream<number>()
+ * const multipliedFoo = pipe(foo, multiplyBy(3))
+ * subscribe(multipliedFoo, value => console.log(value))
+ * publish(foo, 42)
+ * ```
+ */
+export interface Operator<Input, Output = Input> {
+    (done: (value: Output) => void): (value: Input) => void;
+}
+/** @internal */
+declare type O<I, OP> = Operator<I, OP>;
+/**
+ * Creates a new emitter from the passed one by piping its values through one or more operators.
+ * Operators can perform various actions like filter values, pull values from other emitters, or compute new values.
+ *
+ * ```ts
+ * const foo = stream<number>()
+ *
+ * // create an emitter that first adds 2 to the passed value, then multiplies it by * 2
+ * const bar = pipe(foo, map(value => value + 2), map(value => value * 2))
+ * subscribe(bar, value => console.log(value))
+ * publish(foo, 2) // outputs 8
+ * ```
+ * #### Sharing Subscription Calculations
+ *
+ * `pipe` acts as a proxy for the source emitter, and re-runs the operators for each subscription to the derived emitter.
+ * Use [[streamFromEmitter]] or [[statefulStreamFromEmitter]] to avoid that.
+ */
+export declare function pipe<T>(s: Emitter<T>): Emitter<T>;
+export declare function pipe<T, O1>(s: Emitter<T>, o1: O<T, O1>): Emitter<O1>;
+export declare function pipe<T, O1, O2>(s: Emitter<T>, ...o: [O<T, O1>, O<O1, O2>]): Emitter<O2>;
+export declare function pipe<T, O1, O2, O3>(s: Emitter<T>, ...o: [O<T, O1>, O<O1, O2>, O<O2, O3>]): Emitter<O3>;
+export declare function pipe<T, O1, O2, O3, O4>(s: Emitter<T>, ...o: [O<T, O1>, O<O1, O2>, O<O2, O3>, O<O3, O4>]): Emitter<O4>;
+export declare function pipe<T, O1, O2, O3, O4, O5>(s: Emitter<T>, ...o: [O<T, O1>, O<O1, O2>, O<O2, O3>, O<O3, O4>, O<O4, O5>]): Emitter<O5>;
+export declare function pipe<T, O1, O2, O3, O4, O5, O6>(s: Emitter<T>, ...o: [O<T, O1>, O<O1, O2>, O<O2, O3>, O<O3, O4>, O<O4, O5>, O<O5, O6>]): Emitter<O6>;
+export declare function pipe<T, O1, O2, O3, O4, O5, O6, O7>(s: Emitter<T>, ...o: [O<T, O1>, O<O1, O2>, O<O2, O3>, O<O3, O4>, O<O4, O5>, O<O5, O6>, O<O6, O7>]): Emitter<O7>;
+/**
+ * A function which determines if two values are equal.
+ * Implement custom comparators when [[distinctUntilChanged]] needs to work on non-primitive objects.
+ * @returns true if values should be considered equal.
+ */
+export interface Comparator<T> {
+    (previous: T, next: T): boolean;
+}
+/**
+ * The default [[Comparator]] for [[distinctUntilChanged]] and [[duc]].
+ */
+export declare function defaultComparator<T>(previous: T, next: T): boolean;
+/**
+ * Filters out identical values. Pass an optional [[Comparator]] if you need to filter non-primitive values.
+ * ```ts
+ * const foo = stream<number>()
+ *
+ * subscribe(
+ *  pipe(foo, distinctUntilChanged()),
+ *  console.log
+ * ) // will be called only once
+ *
+ * publish(foo, 42)
+ * publish(foo, 42)
+ * ```
+ */
+export declare function distinctUntilChanged<T>(comparator?: Comparator<T>): Operator<T>;
+/**
+ * Filters out values for which the predicator does not return `true`-ish.
+ * ```ts
+ * const foo = stream<number>()
+ *
+ * subscribe(
+ *  pipe(foo, filter(value => value % 2 === 0)),
+ *  console.log
+ * ) // will be called only with even values
+ *
+ * publish(foo, 2)
+ * publish(foo, 3)
+ * publish(foo, 4)
+ * publish(foo, 5)
+ * ```
+ */
+export declare function filter<T>(predicate: (value: T) => boolean): Operator<T>;
+/**
+ * Maps values using the provided project function.
+ * ```ts
+ * const foo = stream<number>()
+ *
+ * subscribe(
+ *  pipe(foo, map(value => value * 2)),
+ *  console.log
+ * ) // 4, 6
+ *
+ * publish(foo, 2)
+ * publish(foo, 3)
+ * ```
+ */
+export declare function map<T, K>(project: (value: T) => K): Operator<T, K>;
+/**
+ * Maps values to the hard-coded value.
+ * ```ts
+ * const foo = stream<number>()
+ *
+ * subscribe(
+ *  pipe(foo, mapTo(3)),
+ *  console.log
+ * ) // 3, 3
+ *
+ * publish(foo, 1)
+ * publish(foo, 2)
+ * ```
+ */
+export declare function mapTo<T>(value: T): Operator<unknown, T>;
+/**
+ * Works like Array#reduce.
+ * Applies an accumulator function on the emitter, and outputs intermediate result. Starts with the initial value.
+ * ```ts
+ * const foo = stream<number>()
+ *
+ * subscribe(
+ *  pipe(foo, scan((acc, value) => acc + value, 2),
+ *  console.log
+ * ) // 3, 5
+ *
+ * publish(foo, 1)
+ * publish(foo, 2)
+ * ```
+ */
+export declare function scan<T, K>(scanner: (current: T, value: K) => T, initial: T): Operator<K, T>;
+/**
+ * Skips the specified amount of values from the emitter.
+ * ```ts
+ * const foo = stream<number>()
+ *
+ * subscribe(
+ *  pipe(foo, skip(2)),
+ *  console.log
+ * ) // 3, 4
+ *
+ * publish(foo, 1) // skipped
+ * publish(foo, 2) // skipped
+ * publish(foo, 3)
+ * publish(foo, 4)
+ * ```
+ */
+export declare function skip<T>(times: number): Operator<T>;
+/**
+ * Throttles flowing values at the provided interval in milliseconds.
+ * [Throttle VS Debounce in SO](https://stackoverflow.com/questions/25991367/difference-between-throttling-and-debouncing-a-function).
+ *
+ * ```ts
+ *  const foo = stream<number>()
+ *  publish(foo, 1)
+ *
+ *  setTimeout(() => publish(foo, 2), 20)
+ *  setTimeout(() => publish(foo, 3), 20)
+ *
+ *  subscribe(pipe(foo, throttleTime(50)), val => {
+ *    console.log(value); // 3
+ *  })
+ * ```
+ */
+export declare function throttleTime<T>(interval: number): Operator<T>;
+/**
+ * Debounces flowing values at the provided interval in milliseconds.
+ * [Throttle VS Debounce in SO](https://stackoverflow.com/questions/25991367/difference-between-throttling-and-debouncing-a-function).
+ *
+ * ```ts
+ *  const foo = stream<number>()
+ *  publish(foo, 1)
+ *
+ *  setTimeout(() => publish(foo, 2), 20)
+ *  setTimeout(() => publish(foo, 3), 20)
+ *
+ *  subscribe(pipe(foo, debounceTime(50)), val => {
+ *    console.log(value); // 3
+ *  })
+ * ```
+ */
+export declare function debounceTime<T>(interval: number): Operator<T>;
+/**
+ * Combines the source Emitter with the latest values from the specified Emitters into an array. Outputs only when the source Emitter emits.
+ * See [[combineLatest]] for a transformer that outputs when any of the emitters emit.
+ *
+ * ```ts
+ *  const foo = stream<number>()
+ *  const bar = stream<number>()
+ *  subscribe(
+ *    pipe(
+ *      foo,
+ *      withLatestFrom(bar)
+ *    ),
+ *    (([foo, bar]) => console.log({ foo, bar }))
+ *  )
+ *
+ *  publish(foo, 1) // nothing happens, bar has not emitted yet
+ *  publish(bar, 1) // still nothing
+ *  publish(foo, 2) // logs { foo: 2, bar: 1 }
+ *  publish(bar, 2)
+ *  publish(foo, 3) // logs { foo: 3, bar: 2 }
+ * ```
+ */
+export declare function withLatestFrom<T, R1>(...s: [Emitter<R1>]): Operator<T, [T, R1]>;
+export declare function withLatestFrom<T, R1, R2>(...s: [Emitter<R1>, Emitter<R2>]): Operator<T, [T, R1, R2]>;
+export declare function withLatestFrom<T, R1, R2, R3>(...s: [Emitter<R1>, Emitter<R2>, Emitter<R3>]): Operator<T, [T, R1, R2, R3]>;
+export declare function withLatestFrom<T, R1, R2, R3, R4>(...s: [Emitter<R1>, Emitter<R2>, Emitter<R3>, Emitter<R4>]): Operator<T, [T, R1, R2, R3, R4]>;
+export declare function withLatestFrom<T, R1, R2, R3, R4, R5>(...s: [Emitter<R1>, Emitter<R2>, Emitter<R3>, Emitter<R4>, Emitter<R5>]): Operator<T, [T, R1, R2, R3, R4, R5]>;
+export declare function withLatestFrom<T, R1, R2, R3, R4, R5, R6>(...s: [Emitter<R1>, Emitter<R2>, Emitter<R3>, Emitter<R4>, Emitter<R5>, Emitter<R6>]): Operator<T, [T, R1, R2, R3, R4, R5, R6]>;
+export declare function withLatestFrom<T, R1, R2, R3, R4, R5, R6, R7>(...s: [Emitter<R1>, Emitter<R2>, Emitter<R3>, Emitter<R4>, Emitter<R5>, Emitter<R6>, Emitter<R7>]): Operator<T, [T, R1, R2, R3, R4, R5, R6, R7]>;
+export {};