@ringcentral/juno 2.40.1 → 2.41.0

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

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("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
+ */
+var utils_1 = require("./utils");
+var actions_1 = require("./actions");
+var constants_1 = require("./constants");
+/** @internal */
+function combineOperators() {
+    var operators = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        operators[_i] = arguments[_i];
+    }
+    return function (subscriber) {
+        return operators.reduceRight(utils_1.thrush, subscriber);
+    };
+}
+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, tslib_1.__spread(operators));
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return (function (action, subscription) {
+        switch (action) {
+            case constants_1.SUBSCRIBE:
+                return actions_1.subscribe(source, project(subscription));
+            case constants_1.RESET:
+                actions_1.reset(source);
+                return;
+        }
+    });
+}
+exports.pipe = pipe;
+/**
+ * The default [[Comparator]] for [[distinctUntilChanged]] and [[duc]].
+ */
+function defaultComparator(previous, next) {
+    return previous === next;
+}
+exports.defaultComparator = defaultComparator;
+/**
+ * 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)
+ * ```
+ */
+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);
+        }
+    }; };
+}
+exports.distinctUntilChanged = distinctUntilChanged;
+/**
+ * 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)
+ * ```
+ */
+function filter(predicate) {
+    return function (done) { return function (value) {
+        predicate(value) && done(value);
+    }; };
+}
+exports.filter = filter;
+/**
+ * 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)
+ * ```
+ */
+function map(project) {
+    return function (done) { return utils_1.compose(done, project); };
+}
+exports.map = map;
+/**
+ * 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)
+ * ```
+ */
+function mapTo(value) {
+    return function (done) { return function () { return done(value); }; };
+}
+exports.mapTo = mapTo;
+/**
+ * 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)
+ * ```
+ */
+function scan(scanner, initial) {
+    return function (done) { return function (value) { return done((initial = scanner(initial, value))); }; };
+}
+exports.scan = scan;
+/**
+ * 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)
+ * ```
+ */
+function skip(times) {
+    return function (done) { return function (value) {
+        times > 0 ? times-- : done(value);
+    }; };
+}
+exports.skip = skip;
+/**
+ * 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
+ *  })
+ * ```
+ */
+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);
+    }; };
+}
+exports.throttleTime = throttleTime;
+/**
+ * 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
+ *  })
+ * ```
+ */
+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);
+    }; };
+}
+exports.debounceTime = debounceTime;
+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);
+        actions_1.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;
+        }
+    }; };
+}
+exports.withLatestFrom = withLatestFrom;

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

@@ -0,0 +1,143 @@
+/**
+ * Streams are the basic building blocks of a reactive system. Think of them as the system permanent "data tubes".
+ *
+ * A stream acts as both an [[Emitter]] and [[Publisher]]. Each stream can have multiple {@link Subscription | Subscriptions}.
+ *
+ * urx streams are either **stateless** or **stateful**.
+ * Stateless streams emit data to existing subscriptions when published, without keeping track of it.
+ * Stateful streams remember the last published value and immediately publish it to new subscriptions.
+ *
+ * ```ts
+ * import { stream, statefulStream, publish, subscribe } from "@virtuoso.dev/urx";
+ *
+ * // foo is a stateless stream
+ * const foo = stream<number>();
+ *
+ * publish(foo, 42);
+ * // this subsription will not be called...
+ * subscribe(foo, (value) => console.log(value));
+ * // it will only catch published values after it
+ * publish(foo, 43);
+ *
+ * // stateful streams always start with an initial value
+ * const bar = statefulStream(42);
+ *
+ * // subscribing to a stateful stream
+ * // immediately calls the subscription with the current value
+ * subscribe(bar, (value) => console.log(value));
+ *
+ * // subsequent publishing works just like stateless streams
+ * publish(bar, 43);
+ * ```
+ * @packageDocumentation
+ */
+import { Emitter, StatefulStream, Stream } from './actions';
+/**
+ * Constructs a new stateless stream.
+ * ```ts
+ * const foo = stream<number>();
+ * ```
+ * @typeParam T the type of values to publish in the stream.
+ * @returns a [[Stream]]
+ */
+export declare function stream<T>(): Stream<T>;
+/**
+ * Constructs a new stateful stream.
+ * ```ts
+ * const foo = statefulStream(42);
+ * ```
+ * @param initial the initial value in the stream.
+ * @typeParam T the type of values to publish in the stream. If omitted, the function infers it from the initial value.
+ * @returns a [[StatefulStream]]
+ */
+export declare function statefulStream<T>(initial: T): StatefulStream<T>;
+/**
+ * Event handlers are special emitters which can have **at most one active subscription**.
+ * Subscribing to an event handler unsubscribes the previous subscription, if present.
+ * ```ts
+ * const foo = stream<number>();
+ * const fooEvent = eventHandler(foo);
+ *
+ * // will be called once with 42
+ * subscribe(fooEvent, (value) => console.log(`Sub 1 ${value}`));
+ * publish(foo, 42);
+ *
+ * // unsubscribes sub 1
+ * subscribe(fooEvent, (value) => console.log(`Sub 2 ${value}`));
+ * publish(foo, 43);
+ * ```
+ * @param emitter the source emitter.
+ * @returns the single-subscription emitter.
+ */
+export declare function eventHandler<T>(emitter: Emitter<T>): Emitter<T>;
+/**
+ * Creates and connects a "junction" stream to the specified emitter. Often used with [[pipe]], to avoid the multiple evaluation of operator sets.
+ *
+ * ```ts
+ * const foo = stream<number>();
+ *
+ * const fooX2 = pipe(
+ *   foo,
+ *   map((value) => {
+ *     console.log(`multiplying ${value}`);
+ *     return value * 2;
+ *   })
+ * );
+ *
+ * subscribe(fooX2, (value) => console.log(value));
+ * subscribe(fooX2, (value) => console.log(value));
+ *
+ * publish(foo, 42); // executes the map operator twice for each subscription.
+ *
+ * const sharedFooX2 = streamFromEmitter(pipe(
+ *   foo,
+ *   map((value) => {
+ *     console.log(`shared multiplying ${value}`);
+ *     return value * 2;
+ *   })
+ * ));
+ *
+ * subscribe(sharedFooX2, (value) => console.log(value));
+ * subscribe(sharedFooX2, (value) => console.log(value));
+ *
+ * publish(foo, 42);
+ *```
+ * @returns the resulting stream.
+ */
+export declare function streamFromEmitter<T>(emitter: Emitter<T>): Stream<T>;
+/**
+ * Creates and connects a "junction" stateful stream to the specified emitter. Often used with [[pipe]], to avoid the multiple evaluation of operator sets.
+ *
+ * ```ts
+ * const foo = stream<number>();
+ *
+ * const fooX2 = pipe(
+ *   foo,
+ *   map((value) => {
+ *     console.log(`multiplying ${value}`);
+ *     return value * 2;
+ *   })
+ * );
+ *
+ * subscribe(fooX2, (value) => console.log(value));
+ * subscribe(fooX2, (value) => console.log(value));
+ *
+ * publish(foo, 42); // executes the map operator twice for each subscription.
+ *
+ * const sharedFooX2 = statefulStreamFromEmitter(pipe(
+ *   foo,
+ *   map((value) => {
+ *     console.log(`shared multiplying ${value}`);
+ *     return value * 2;
+ *   })
+ * ), 42);
+ *
+ * subscribe(sharedFooX2, (value) => console.log(value));
+ * subscribe(sharedFooX2, (value) => console.log(value));
+ *
+ * publish(foo, 42);
+ *```
+ * @param initial the initial value in the stream.
+ * @returns the resulting stateful stream.
+ */
+export declare function statefulStreamFromEmitter<T>(emitter: Emitter<T>, initial: T): StatefulStream<T>;

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

@@ -0,0 +1,227 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/**
+ * Streams are the basic building blocks of a reactive system. Think of them as the system permanent "data tubes".
+ *
+ * A stream acts as both an [[Emitter]] and [[Publisher]]. Each stream can have multiple {@link Subscription | Subscriptions}.
+ *
+ * urx streams are either **stateless** or **stateful**.
+ * Stateless streams emit data to existing subscriptions when published, without keeping track of it.
+ * Stateful streams remember the last published value and immediately publish it to new subscriptions.
+ *
+ * ```ts
+ * import { stream, statefulStream, publish, subscribe } from "@virtuoso.dev/urx";
+ *
+ * // foo is a stateless stream
+ * const foo = stream<number>();
+ *
+ * publish(foo, 42);
+ * // this subsription will not be called...
+ * subscribe(foo, (value) => console.log(value));
+ * // it will only catch published values after it
+ * publish(foo, 43);
+ *
+ * // stateful streams always start with an initial value
+ * const bar = statefulStream(42);
+ *
+ * // subscribing to a stateful stream
+ * // immediately calls the subscription with the current value
+ * subscribe(bar, (value) => console.log(value));
+ *
+ * // subsequent publishing works just like stateless streams
+ * publish(bar, 43);
+ * ```
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var actions_1 = require("./actions");
+var constants_1 = require("./constants");
+var utils_1 = require("./utils");
+/**
+ * Constructs a new stateless stream.
+ * ```ts
+ * const foo = stream<number>();
+ * ```
+ * @typeParam T the type of values to publish in the stream.
+ * @returns a [[Stream]]
+ */
+function stream() {
+    var subscriptions = [];
+    return (function (action, arg) {
+        switch (action) {
+            case constants_1.RESET:
+                subscriptions.splice(0, subscriptions.length);
+                return;
+            case constants_1.SUBSCRIBE:
+                subscriptions.push(arg);
+                return function () {
+                    var indexOf = subscriptions.indexOf(arg);
+                    if (indexOf > -1) {
+                        subscriptions.splice(indexOf, 1);
+                    }
+                };
+            case constants_1.PUBLISH:
+                subscriptions.slice().forEach(function (subscription) {
+                    subscription(arg);
+                });
+                return;
+            default:
+                throw new Error("unrecognized action " + action);
+        }
+    });
+}
+exports.stream = stream;
+/**
+ * Constructs a new stateful stream.
+ * ```ts
+ * const foo = statefulStream(42);
+ * ```
+ * @param initial the initial value in the stream.
+ * @typeParam T the type of values to publish in the stream. If omitted, the function infers it from the initial value.
+ * @returns a [[StatefulStream]]
+ */
+function statefulStream(initial) {
+    var value = initial;
+    var innerSubject = stream();
+    return (function (action, arg) {
+        switch (action) {
+            case constants_1.SUBSCRIBE:
+                var subscription = arg;
+                subscription(value);
+                break;
+            case constants_1.PUBLISH:
+                value = arg;
+                break;
+            case constants_1.VALUE:
+                return value;
+        }
+        return innerSubject(action, arg);
+    });
+}
+exports.statefulStream = statefulStream;
+/**
+ * Event handlers are special emitters which can have **at most one active subscription**.
+ * Subscribing to an event handler unsubscribes the previous subscription, if present.
+ * ```ts
+ * const foo = stream<number>();
+ * const fooEvent = eventHandler(foo);
+ *
+ * // will be called once with 42
+ * subscribe(fooEvent, (value) => console.log(`Sub 1 ${value}`));
+ * publish(foo, 42);
+ *
+ * // unsubscribes sub 1
+ * subscribe(fooEvent, (value) => console.log(`Sub 2 ${value}`));
+ * publish(foo, 43);
+ * ```
+ * @param emitter the source emitter.
+ * @returns the single-subscription emitter.
+ */
+function eventHandler(emitter) {
+    var unsub;
+    var currentSubscription;
+    var cleanup = function () { return unsub && unsub(); };
+    return function (action, subscription) {
+        switch (action) {
+            case constants_1.SUBSCRIBE:
+                if (subscription) {
+                    if (currentSubscription === subscription) {
+                        return;
+                    }
+                    cleanup();
+                    currentSubscription = subscription;
+                    unsub = actions_1.subscribe(emitter, subscription);
+                    return unsub;
+                }
+                else {
+                    cleanup();
+                    return utils_1.noop;
+                }
+            case constants_1.RESET:
+                cleanup();
+                currentSubscription = null;
+                return;
+            default:
+                throw new Error("unrecognized action " + action);
+        }
+    };
+}
+exports.eventHandler = eventHandler;
+/**
+ * Creates and connects a "junction" stream to the specified emitter. Often used with [[pipe]], to avoid the multiple evaluation of operator sets.
+ *
+ * ```ts
+ * const foo = stream<number>();
+ *
+ * const fooX2 = pipe(
+ *   foo,
+ *   map((value) => {
+ *     console.log(`multiplying ${value}`);
+ *     return value * 2;
+ *   })
+ * );
+ *
+ * subscribe(fooX2, (value) => console.log(value));
+ * subscribe(fooX2, (value) => console.log(value));
+ *
+ * publish(foo, 42); // executes the map operator twice for each subscription.
+ *
+ * const sharedFooX2 = streamFromEmitter(pipe(
+ *   foo,
+ *   map((value) => {
+ *     console.log(`shared multiplying ${value}`);
+ *     return value * 2;
+ *   })
+ * ));
+ *
+ * subscribe(sharedFooX2, (value) => console.log(value));
+ * subscribe(sharedFooX2, (value) => console.log(value));
+ *
+ * publish(foo, 42);
+ *```
+ * @returns the resulting stream.
+ */
+function streamFromEmitter(emitter) {
+    return utils_1.tap(stream(), function (stream) { return actions_1.connect(emitter, stream); });
+}
+exports.streamFromEmitter = streamFromEmitter;
+/**
+ * Creates and connects a "junction" stateful stream to the specified emitter. Often used with [[pipe]], to avoid the multiple evaluation of operator sets.
+ *
+ * ```ts
+ * const foo = stream<number>();
+ *
+ * const fooX2 = pipe(
+ *   foo,
+ *   map((value) => {
+ *     console.log(`multiplying ${value}`);
+ *     return value * 2;
+ *   })
+ * );
+ *
+ * subscribe(fooX2, (value) => console.log(value));
+ * subscribe(fooX2, (value) => console.log(value));
+ *
+ * publish(foo, 42); // executes the map operator twice for each subscription.
+ *
+ * const sharedFooX2 = statefulStreamFromEmitter(pipe(
+ *   foo,
+ *   map((value) => {
+ *     console.log(`shared multiplying ${value}`);
+ *     return value * 2;
+ *   })
+ * ), 42);
+ *
+ * subscribe(sharedFooX2, (value) => console.log(value));
+ * subscribe(sharedFooX2, (value) => console.log(value));
+ *
+ * publish(foo, 42);
+ *```
+ * @param initial the initial value in the stream.
+ * @returns the resulting stateful stream.
+ */
+function statefulStreamFromEmitter(emitter, initial) {
+    return utils_1.tap(statefulStream(initial), function (stream) { return actions_1.connect(emitter, stream); });
+}
+exports.statefulStreamFromEmitter = statefulStreamFromEmitter;