@ringcentral/juno 2.40.0 → 2.41.0

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

@@ -0,0 +1,220 @@
+/* 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
+ */
+import { subscribe, connect } from './actions';
+import { RESET, PUBLISH, SUBSCRIBE, VALUE } from './constants';
+import { tap, noop } from './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]]
+ */
+export function stream() {
+    var subscriptions = [];
+    return (function (action, arg) {
+        switch (action) {
+            case RESET:
+                subscriptions.splice(0, subscriptions.length);
+                return;
+            case SUBSCRIBE:
+                subscriptions.push(arg);
+                return function () {
+                    var indexOf = subscriptions.indexOf(arg);
+                    if (indexOf > -1) {
+                        subscriptions.splice(indexOf, 1);
+                    }
+                };
+            case PUBLISH:
+                subscriptions.slice().forEach(function (subscription) {
+                    subscription(arg);
+                });
+                return;
+            default:
+                throw new Error("unrecognized action " + action);
+        }
+    });
+}
+/**
+ * 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 function statefulStream(initial) {
+    var value = initial;
+    var innerSubject = stream();
+    return (function (action, arg) {
+        switch (action) {
+            case SUBSCRIBE:
+                var subscription = arg;
+                subscription(value);
+                break;
+            case PUBLISH:
+                value = arg;
+                break;
+            case VALUE:
+                return value;
+        }
+        return innerSubject(action, arg);
+    });
+}
+/**
+ * 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 function eventHandler(emitter) {
+    var unsub;
+    var currentSubscription;
+    var cleanup = function () { return unsub && unsub(); };
+    return function (action, subscription) {
+        switch (action) {
+            case SUBSCRIBE:
+                if (subscription) {
+                    if (currentSubscription === subscription) {
+                        return;
+                    }
+                    cleanup();
+                    currentSubscription = subscription;
+                    unsub = subscribe(emitter, subscription);
+                    return unsub;
+                }
+                else {
+                    cleanup();
+                    return noop;
+                }
+            case RESET:
+                cleanup();
+                currentSubscription = null;
+                return;
+            default:
+                throw new Error("unrecognized action " + action);
+        }
+    };
+}
+/**
+ * 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 function streamFromEmitter(emitter) {
+    return tap(stream(), function (stream) { return connect(emitter, stream); });
+}
+/**
+ * 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 function statefulStreamFromEmitter(emitter, initial) {
+    return tap(statefulStream(initial), function (stream) { return connect(emitter, stream); });
+}

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

@@ -0,0 +1,102 @@
+/**
+ * `system` defines a specification of a system - its constructor, dependencies and if it should act as a singleton in a system dependency tree.
+ * When called, system returns a [[SystemSpec]], which is then initialized along with its dependencies by passing it to [[init]].
+ *
+ * ```ts
+ * @import { subscribe, publish, system, init, tup, connect, map, pipe } from 'urx'
+ *
+ * // a simple system with two streams
+ * const sys1 = system(() => {
+ *  const a = stream<number>()
+ *  const b = stream<number>()
+ *
+ *  connect(pipe(a, map(value => value * 2)), b)
+ *  return { a, b }
+ * })
+ *
+ * // a second system which depends on the streams from the first one
+ * const sys2 = system(([ {a, b} ]) => {
+ *  const c = stream<number>()
+ *  connect(pipe(b, map(value => value * 2)), c)
+ *  // re-export the `a` stream, keep `b` internal
+ *  return { a, c }
+ * }, tup(sys1))
+ *
+ * // init will recursively initialize sys2 dependencies, in this case sys1
+ * const { a, c } = init(sys2)
+ * subscribe(c, c => console.log(`Value multiplied by 4`, c))
+ * publish(a, 2)
+ * ```
+ *
+ * #### Singletons in Dependency Tree
+ *
+ * By default, systems will be initialized only once if encountered multiple times in the dependency tree.
+ * In the below dependency system tree, systems `b` and `c` will receive the same stream instances from system `a` when system `d` is initialized.
+ * ```txt
+ *   a
+ *  / \
+ * b   c
+ *  \ /
+ *   d
+ * ```
+ * If `a` gets `{singleton: false}` as a last argument, `init` creates two separate instances - one for `b` and one for `c`.
+ *
+ * @param constructor the system constructor function. Initialize and connect the streams in its body.
+ *
+ * @param dependencies the system dependencies, which the constructor will receive as arguments.
+ * Use the [[tup]] utility **For TypeScript type inference to work correctly**.
+ * ```ts
+ * const sys3 = system(() => { ... }, tup(sys2, sys1))
+ * ```
+ * @param __namedParameters Options
+ * @param singleton determines if the system will act as a singleton in a system dependency tree. `true` by default.
+ */
+export function system(constructor, dependencies, _a) {
+    if (dependencies === void 0) { dependencies = []; }
+    var singleton = (_a === void 0 ? { singleton: true } : _a).singleton;
+    return {
+        id: id(),
+        constructor: constructor,
+        dependencies: dependencies,
+        singleton: singleton,
+    };
+}
+/** @internal */
+var id = function () { return Symbol(); };
+/**
+ * Initializes a [[SystemSpec]] by recursively initializing its dependencies.
+ *
+ * ```ts
+ * // a simple system with two streams
+ * const sys1 = system(() => {
+ *  const a = stream<number>()
+ *  const b = stream<number>()
+ *
+ *  connect(pipe(a, map(value => value * 2)), b)
+ *  return { a, b }
+ * })
+ *
+ * const { a, b } = init(sys1)
+ * subscribe(b, b => console.log(b))
+ * publish(a, 2)
+ * ```
+ *
+ * @returns the [[System]] constructed by the spec constructor.
+ * @param systemSpec the system spec to initialize.
+ */
+export function init(systemSpec) {
+    var singletons = new Map();
+    var _init = function (_a) {
+        var id = _a.id, constructor = _a.constructor, dependencies = _a.dependencies, singleton = _a.singleton;
+        if (singleton && singletons.has(id)) {
+            return singletons.get(id);
+        }
+        var system = constructor(dependencies.map(function (e) { return _init(e); }));
+        if (singleton) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            singletons.set(id, system);
+        }
+        return system;
+    };
+    return _init(systemSpec);
+}

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

@@ -0,0 +1,101 @@
+import { __read, __spread } from "tslib";
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/**
+ * Transformers change and combine streams, similar to operators.
+ * urx comes with two combinators - [[combineLatest]] and [[merge]], and one convenience filter - [[duc]].
+ *
+ * @packageDocumentation
+ */
+import { publish, reset, subscribe } from './actions';
+import { RESET, SUBSCRIBE } from './constants';
+import { defaultComparator, distinctUntilChanged, pipe } from './pipe';
+import { stream } from './streams';
+import { joinProc } from './utils';
+/**
+ * Merges one or more emitters from the same type into a new Emitter which emits values from any of the source emitters.
+ * ```ts
+ * const foo = stream<number>()
+ * const bar = stream<number>()
+ *
+ * subscribe(merge(foo, bar), (value) => console.log(value)) // 42, 43
+ *
+ * publish(foo, 42)
+ * publish(bar, 43)
+ * ```
+ */
+export function merge() {
+    var sources = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        sources[_i] = arguments[_i];
+    }
+    return function (action, subscription) {
+        switch (action) {
+            case SUBSCRIBE:
+                return joinProc.apply(void 0, __spread(sources.map(function (source) { return subscribe(source, subscription); })));
+            case RESET:
+                // do nothing, we are stateless
+                return;
+            default:
+                throw new Error("unrecognized action " + action);
+        }
+    };
+}
+/**
+ * A convenience wrapper that emits only the distinct values from the passed Emitter. Wraps [[pipe]] and [[distinctUntilChanged]].
+ *
+ * ```ts
+ * const foo = stream<number>()
+ *
+ * // this line...
+ * const a = duc(foo)
+ *
+ * // is equivalent to this
+ * const b = pipe(distinctUntilChanged(foo))
+ * ```
+ *
+ * @param source The source emitter.
+ * @param comparator optional custom comparison function for the two values.
+ *
+ * @typeParam T the type of the value emitted by the source.
+ *
+ * @returns the resulting emitter.
+ */
+export function duc(source, comparator) {
+    if (comparator === void 0) { comparator = defaultComparator; }
+    return pipe(source, distinctUntilChanged(comparator));
+}
+export function combineLatest() {
+    var emitters = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        emitters[_i] = arguments[_i];
+    }
+    var innerSubject = stream();
+    var values = new Array(emitters.length);
+    var called = 0;
+    var allCalled = Math.pow(2, emitters.length) - 1;
+    emitters.forEach(function (source, index) {
+        var bit = Math.pow(2, index);
+        subscribe(source, function (value) {
+            values[index] = value;
+            called = called | bit;
+            if (called === allCalled) {
+                publish(innerSubject, values);
+            }
+        });
+    });
+    return function (action, subscription) {
+        switch (action) {
+            case SUBSCRIBE:
+                if (called === allCalled) {
+                    subscription(values);
+                }
+                return subscribe(innerSubject, subscription);
+            case RESET:
+                return reset(innerSubject);
+            default:
+                throw new Error("unrecognized action " + action);
+        }
+    };
+}

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

@@ -0,0 +1,88 @@
+/**
+ * Utils includes
+ * - a handful of functional utilities inspired by or taken from the [Ramda library](https://ramdajs.com/);
+ * - TypeScript crutches - the [[tup]] function.
+ *
+ * Use these for your convenience - they are here so that urx is zero-dependency package.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Performs left to right composition of two functions.
+ */
+export function compose(a, b) {
+    return function (arg) { return a(b(arg)); };
+}
+/**
+ * Takes a value and applies a function to it.
+ */
+export function thrush(arg, proc) {
+    return proc(arg);
+}
+/**
+ * Takes a 2 argument function and partially applies the first argument.
+ */
+export function curry2to1(proc, arg1) {
+    return function (arg2) { return proc(arg1, arg2); };
+}
+/**
+ * Takes a 1 argument function and returns a function which when called, executes it with the provided argument.
+ */
+export function curry1to0(proc, arg) {
+    return function () { return proc(arg); };
+}
+/**
+ * Returns a function which extracts the property from from the passed object.
+ */
+export function prop(property) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return
+    return function (object) { return object[property]; };
+}
+/**
+ * Calls callback with the first argument, and returns it.
+ */
+export function tap(arg, proc) {
+    proc(arg);
+    return arg;
+}
+/**
+ *  Utility function to help typescript figure out that what we pass is a tuple and not a generic array.
+ *  Taken from (this StackOverflow tread)[https://stackoverflow.com/questions/49729550/implicitly-create-a-tuple-in-typescript/52445008#52445008]
+ */
+export function tup() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return args;
+}
+/**
+ * Calls the passed function.
+ */
+export function call(proc) {
+    proc();
+}
+/**
+ * returns a function which when called always returns the passed value
+ */
+export function always(value) {
+    return function () { return value; };
+}
+/**
+ * returns a function which calls all passed functions in the passed order.
+ * joinProc does not pass arguments or collect return values.
+ */
+export function joinProc() {
+    var procs = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        procs[_i] = arguments[_i];
+    }
+    return function () {
+        procs.map(call);
+    };
+}
+export function isDefined(arg) {
+    return arg !== undefined;
+}
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+export function noop() { }

package/es6/components/Virtuoso/react-virtuoso/utils/approximatelyEqual.js

@@ -0,0 +1,3 @@
+export function approximatelyEqual(num1, num2) {
+    return Math.abs(num1 - num2) < 1.01;
+}

package/es6/components/Virtuoso/react-virtuoso/utils/context.js

@@ -0,0 +1,3 @@
+import React from 'react';
+export var VirtuosoMockContext = React.createContext(undefined);
+export var VirtuosoGridMockContext = React.createContext(undefined);

package/es6/components/Virtuoso/react-virtuoso/utils/skipFrames.js

@@ -0,0 +1,8 @@
+export function skipFrames(frameCount, callback) {
+    if (frameCount == 0) {
+        callback();
+    }
+    else {
+        requestAnimationFrame(function () { return skipFrames(frameCount - 1, callback); });
+    }
+}

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

@@ -1,5 +1,5 @@
 import { __assign, __read } from "tslib";
-import * as u from '@virtuoso.dev/urx';
+import * as u from './urx';
 import { domIOSystem } from './domIOSystem';
 export var windowScrollerSystem = u.system(function (_a) {
     var _b = __read(_a, 1), _c = _b[0], scrollTo = _c.scrollTo, scrollContainerState = _c.scrollContainerState;

package/es6/foundation/hooks/useForkRef/useForkRef.js

@@ -1,4 +1,4 @@
-import { useForkRef as MuiUseForkRef } from '@material-ui/core/utils';
+import { useForkRef as MuiUseForkRef, setRef as MuiSetRef, } from '@material-ui/core/utils';
 /**
  * That method will give you ability fork same value `ref object` or `method`
  * Example:
@@ -17,3 +17,4 @@ import { useForkRef as MuiUseForkRef } from '@material-ui/core/utils';
  * ```
  */
 export var useForkRef = MuiUseForkRef;
+export var setRef = MuiSetRef;

package/foundation/hooks/useForkRef/useForkRef.d.ts

@@ -1,4 +1,4 @@
-import { useForkRef as MuiUseForkRef } from '@material-ui/core/utils';
+import { useForkRef as MuiUseForkRef, setRef as MuiSetRef } from '@material-ui/core/utils';
 /**
  * That method will give you ability fork same value `ref object` or `method`
  * Example:
@@ -17,3 +17,4 @@ import { useForkRef as MuiUseForkRef } from '@material-ui/core/utils';
  * ```
  */
 export declare const useForkRef: typeof MuiUseForkRef;
+export declare const setRef: typeof MuiSetRef;

package/foundation/hooks/useForkRef/useForkRef.js

@@ -19,3 +19,4 @@ var utils_1 = require("@material-ui/core/utils");
  * ```
  */
 exports.useForkRef = utils_1.useForkRef;
+exports.setRef = utils_1.setRef;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ringcentral/juno",
-  "version": "2.40.0",
+  "version": "2.41.0",
   "author": "RingCentral",
   "license": "MIT",
   "main": "./index.js",
@@ -27,7 +27,7 @@
     "focus-visible": "^5.1.0",
     "lodash": "^4.17.21",
     "react-beautiful-dnd": "^13.0.0",
-    "react-virtuoso": "^2.10.1",
+    "react-virtuoso": "^4.6.2",
     "resize-observer-polyfill": "^1.5.1",
     "typeface-lato": "^0.0.75",
     "type-fest": "^2.12.2",

package/components/Virtuoso/Virtuoso.d.ts

@@ -1 +0,0 @@
-export * from './react-virtuoso';

package/components/Virtuoso/Virtuoso.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./react-virtuoso"), exports);