@ringcentral/juno 2.40.1 → 2.41.0

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

@@ -1,26 +1,29 @@
 import { __read } from "tslib";
-import * as u from '@virtuoso.dev/urx';
+import * as u from './urx';
 import { domIOSystem } from './domIOSystem';
 import { listStateSystem } from './listStateSystem';
-import { loggerSystem, LogLevel } from './loggerSystem';
 import { sizeSystem } from './sizeSystem';
-import { stateFlagsSystem, UP } from './stateFlagsSystem';
+import { UP, stateFlagsSystem } from './stateFlagsSystem';
+import { loggerSystem, LogLevel } from './loggerSystem';
+import { simpleMemoize } from './utils/simpleMemoize';
+import { recalcSystem } from './recalcSystem';
+import { find } from './AATree';
+var isMobileSafari = 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.
  */
 export var upwardScrollFixSystem = u.system(function (_a) {
-    var _b = __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 = __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 = __read(_a, 4), prevItems = _c[1], prevTotalCount = _c[2], prevTotalHeight = _c[3];
-        var _d = __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 = __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) {
@@ -33,28 +36,15 @@ export var upwardScrollFixSystem = u.system(function (_a) {
     }, [0, [], 0, 0]), u.filter(function (_a) {
         var _b = __read(_a, 1), amount = _b[0];
         return amount !== 0;
-    }), u.withLatestFrom(scrollTop, scrollDirection, scrollingInProgress, log, isAtBottom, atBottomState), u.filter(function (_a) {
-        var _b = __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 === UP); // && (isAtBottom ? amount > 0 : true)
+    }), u.withLatestFrom(scrollTop, scrollDirection, scrollingInProgress, isAtBottom, log, recalcInProgress), u.filter(function (_a) {
+        var _b = __read(_a, 7), scrollTop = _b[1], scrollDirection = _b[2], scrollingInProgress = _b[3], recalcInProgress = _b[6];
+        return !recalcInProgress && !scrollingInProgress && scrollTop !== 0 && scrollDirection === UP;
     }), u.map(function (_a) {
-        var _b = __read(_a, 5), _c = __read(_b[0], 1), amount = _c[0], log = _b[4];
+        var _b = __read(_a, 6), _c = __read(_b[0], 1), amount = _c[0], log = _b[5];
         log('Upward scrolling compensation', { amount: amount }, LogLevel.DEBUG);
         return amount;
     })));
-    u.connect(u.pipe(deviationOffset, u.withLatestFrom(deviation), u.map(function (_a) {
-        var _b = __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 = __read(_a, 2), is = _b[0], deviation = _b[1];
-        return !is && deviation !== 0;
-    }), u.map(function (_a) {
-        var _b = __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);
@@ -63,13 +53,66 @@ export var 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 = __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 = __read(_a, 3), is = _b[0], deviation = _b[1], recalc = _b[2];
+        return !is && !recalc && deviation !== 0;
+    }), u.map(function (_a) {
+        var _b = __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 = __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 = __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 = 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, stateFlagsSystem, listStateSystem, sizeSystem, loggerSystem));
+}, u.tup(domIOSystem, stateFlagsSystem, listStateSystem, sizeSystem, loggerSystem, recalcSystem));

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

@@ -0,0 +1,90 @@
+/**
+ * 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';
+import { curry2to1 } from './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();
+ *```
+ */
+export function subscribe(emitter, subscription) {
+    return emitter(SUBSCRIBE, subscription);
+}
+/**
+ * Publishes the value into the passed [[Publisher]].
+ *
+ * ```ts
+ * const foo = stream<number>();
+ * publish(foo, 42);
+ * ```
+ */
+export function publish(publisher, value) {
+    publisher(PUBLISH, value);
+}
+/**
+ * Clears all subscriptions from the [[Emitter]].
+ * ```ts
+ * const foo = stream<number>();
+ * subscribe(foo, (value) => console.log(value));
+ * reset(foo);
+ * publish(foo, 42);
+ * ```
+ */
+export function reset(emitter) {
+    emitter(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));
+ * ```
+ */
+export function getValue(depot) {
+    return depot(VALUE);
+}
+/**
+ * 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 function connect(emitter, publisher) {
+    return subscribe(emitter, curry2to1(publisher, PUBLISH));
+}
+/**
+ * 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 function handleNext(emitter, subscription) {
+    var unsub = emitter(SUBSCRIBE, function (value) {
+        unsub();
+        subscription(value);
+    });
+    return unsub;
+}

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

@@ -0,0 +1,4 @@
+export var PUBLISH = 0;
+export var SUBSCRIBE = 1;
+export var RESET = 2;
+export var VALUE = 4;

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

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

package/es6/components/Virtuoso/react-virtuoso/urx/pipe.js

@@ -0,0 +1,266 @@
+import { __read, __spread } from "tslib";
+/**
+ *
+ * Stream values can be transformed and controlled by {@link pipe | **piping**} through **operators**.
+ * urx includes several operators like [[map]], [[filter]], [[scan]], and [[throttleTime]].
+ * The [[withLatestFrom]] operator allows the combination of values from other streams.
+ *
+ * ```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
+ * ```
+ *
+ * ### Implementing Custom Operators
+ * To implement your own operators, implement the [[Operator]] interface.
+ * @packageDocumentation
+ */
+import { compose, thrush } from './utils';
+import { subscribe, reset } from './actions';
+import { SUBSCRIBE, RESET } from './constants';
+/** @internal */
+function combineOperators() {
+    var operators = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        operators[_i] = arguments[_i];
+    }
+    return function (subscriber) {
+        return operators.reduceRight(thrush, subscriber);
+    };
+}
+export function pipe(source) {
+    var operators = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        operators[_i - 1] = arguments[_i];
+    }
+    // prettier-ignore
+    var project = combineOperators.apply(void 0, __spread(operators));
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return (function (action, subscription) {
+        switch (action) {
+            case SUBSCRIBE:
+                return subscribe(source, project(subscription));
+            case RESET:
+                reset(source);
+                return;
+        }
+    });
+}
+/**
+ * The default [[Comparator]] for [[distinctUntilChanged]] and [[duc]].
+ */
+export function defaultComparator(previous, next) {
+    return previous === next;
+}
+/**
+ * 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 function distinctUntilChanged(comparator) {
+    if (comparator === void 0) { comparator = defaultComparator; }
+    var current;
+    return function (done) { return function (next) {
+        if (!comparator(current, next)) {
+            current = next;
+            done(next);
+        }
+    }; };
+}
+/**
+ * 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 function filter(predicate) {
+    return function (done) { return function (value) {
+        predicate(value) && done(value);
+    }; };
+}
+/**
+ * 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 function map(project) {
+    return function (done) { return compose(done, project); };
+}
+/**
+ * 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 function mapTo(value) {
+    return function (done) { return function () { return done(value); }; };
+}
+/**
+ * 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 function scan(scanner, initial) {
+    return function (done) { return function (value) { return done((initial = scanner(initial, value))); }; };
+}
+/**
+ * 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 function skip(times) {
+    return function (done) { return function (value) {
+        times > 0 ? times-- : done(value);
+    }; };
+}
+/**
+ * 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 function throttleTime(interval) {
+    var currentValue = null;
+    var timeout;
+    return function (done) { return function (value) {
+        currentValue = value;
+        if (timeout) {
+            return;
+        }
+        timeout = setTimeout(function () {
+            timeout = undefined;
+            done(currentValue);
+        }, interval);
+    }; };
+}
+/**
+ * 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 function debounceTime(interval) {
+    var currentValue;
+    var timeout;
+    return function (done) { return function (value) {
+        currentValue = value;
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+        timeout = setTimeout(function () {
+            done(currentValue);
+        }, interval);
+    }; };
+}
+export function withLatestFrom() {
+    var sources = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        sources[_i] = arguments[_i];
+    }
+    var values = new Array(sources.length);
+    var called = 0;
+    var pendingCall = null;
+    var allCalled = Math.pow(2, sources.length) - 1;
+    sources.forEach(function (source, index) {
+        var bit = Math.pow(2, index);
+        subscribe(source, function (value) {
+            var prevCalled = called;
+            called = called | bit;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            values[index] = value;
+            if (prevCalled !== allCalled && called === allCalled && pendingCall) {
+                pendingCall();
+                pendingCall = null;
+            }
+        });
+    });
+    return function (done) { return function (value) {
+        var call = function () { return done([value].concat(values)); };
+        if (called === allCalled) {
+            call();
+        }
+        else {
+            pendingCall = call;
+        }
+    }; };
+}