@ringcentral/juno 2.40.1 → 2.41.0

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

@@ -1,18 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-var u = tslib_1.__importStar(require("@virtuoso.dev/urx"));
-var alignToBottomSystem_1 = require("./alignToBottomSystem");
+var u = tslib_1.__importStar(require("./urx"));
 var domIOSystem_1 = require("./domIOSystem");
 var followOutputSystem_1 = require("./followOutputSystem");
 var groupedListSystem_1 = require("./groupedListSystem");
 var initialItemCountSystem_1 = require("./initialItemCountSystem");
-var initialScrollTopSystem_1 = require("./initialScrollTopSystem");
 var initialTopMostItemIndexSystem_1 = require("./initialTopMostItemIndexSystem");
 var listStateSystem_1 = require("./listStateSystem");
-var loggerSystem_1 = require("./loggerSystem");
 var propsReadySystem_1 = require("./propsReadySystem");
-var scrollIntoViewSystem_1 = require("./scrollIntoViewSystem");
 var scrollSeekSystem_1 = require("./scrollSeekSystem");
 var scrollToIndexSystem_1 = require("./scrollToIndexSystem");
 var sizeRangeSystem_1 = require("./sizeRangeSystem");
@@ -20,18 +16,21 @@ var sizeSystem_1 = require("./sizeSystem");
 var topItemCountSystem_1 = require("./topItemCountSystem");
 var totalListHeightSystem_1 = require("./totalListHeightSystem");
 var upwardScrollFixSystem_1 = require("./upwardScrollFixSystem");
+var initialScrollTopSystem_1 = require("./initialScrollTopSystem");
+var alignToBottomSystem_1 = require("./alignToBottomSystem");
 var windowScrollerSystem_1 = require("./windowScrollerSystem");
-// workaround the growing list of systems below
-// fix this with 4.1 recursive conditional types
+var loggerSystem_1 = require("./loggerSystem");
+var scrollIntoViewSystem_1 = require("./scrollIntoViewSystem");
+var stateLoadSystem_1 = require("./stateLoadSystem");
 var featureGroup1System = u.system(function (_a) {
-    var _b = tslib_1.__read(_a, 9), sizeRange = _b[0], initialItemCount = _b[1], propsReady = _b[2], scrollSeek = _b[3], totalListHeight = _b[4], initialScrollTopSystem = _b[5], alignToBottom = _b[6], windowScroller = _b[7], scrollIntoView = _b[8];
-    return tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, sizeRange), initialItemCount), propsReady), scrollSeek), totalListHeight), initialScrollTopSystem), alignToBottom), windowScroller), scrollIntoView);
-}, u.tup(sizeRangeSystem_1.sizeRangeSystem, initialItemCountSystem_1.initialItemCountSystem, propsReadySystem_1.propsReadySystem, scrollSeekSystem_1.scrollSeekSystem, totalListHeightSystem_1.totalListHeightSystem, initialScrollTopSystem_1.initialScrollTopSystem, alignToBottomSystem_1.alignToBottomSystem, windowScrollerSystem_1.windowScrollerSystem, scrollIntoViewSystem_1.scrollIntoViewSystem));
+    var _b = tslib_1.__read(_a, 10), sizeRange = _b[0], initialItemCount = _b[1], propsReady = _b[2], scrollSeek = _b[3], totalListHeight = _b[4], initialScrollTopSystem = _b[5], alignToBottom = _b[6], windowScroller = _b[7], scrollIntoView = _b[8], logger = _b[9];
+    return tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, sizeRange), initialItemCount), propsReady), scrollSeek), totalListHeight), initialScrollTopSystem), alignToBottom), windowScroller), scrollIntoView), logger);
+}, u.tup(sizeRangeSystem_1.sizeRangeSystem, initialItemCountSystem_1.initialItemCountSystem, propsReadySystem_1.propsReadySystem, scrollSeekSystem_1.scrollSeekSystem, totalListHeightSystem_1.totalListHeightSystem, initialScrollTopSystem_1.initialScrollTopSystem, alignToBottomSystem_1.alignToBottomSystem, windowScrollerSystem_1.windowScrollerSystem, scrollIntoViewSystem_1.scrollIntoViewSystem, loggerSystem_1.loggerSystem));
 exports.listSystem = u.system(function (_a) {
-    var _b = _a, _c = tslib_1.__read(_b, 11), _d = _c[0], totalCount = _d.totalCount, sizeRanges = _d.sizeRanges, fixedItemSize = _d.fixedItemSize, defaultItemSize = _d.defaultItemSize, trackItemSizes = _d.trackItemSizes, itemSize = _d.itemSize, data = _d.data, firstItemIndex = _d.firstItemIndex, groupIndices = _d.groupIndices, statefulTotalCount = _d.statefulTotalCount, _e = _c[1], initialTopMostItemIndex = _e.initialTopMostItemIndex, scrolledToInitialItem = _e.scrolledToInitialItem, domIO = _c[2], followOutput = _c[3], _f = _c[4], scrollToIndex = _c[5].scrollToIndex, topItemCount = _c[7].topItemCount, groupCounts = _c[8].groupCounts, featureGroup1 = _c[9], log = _c[10], listState = _f.listState, topItemsIndexes = _f.topItemsIndexes, flags = tslib_1.__rest(_f, ["listState", "topItemsIndexes"]);
+    var _b = _a, _c = tslib_1.__read(_b, 11), _d = _c[0], totalCount = _d.totalCount, sizeRanges = _d.sizeRanges, fixedItemSize = _d.fixedItemSize, defaultItemSize = _d.defaultItemSize, trackItemSizes = _d.trackItemSizes, itemSize = _d.itemSize, data = _d.data, firstItemIndex = _d.firstItemIndex, groupIndices = _d.groupIndices, statefulTotalCount = _d.statefulTotalCount, gap = _d.gap, sizes = _d.sizes, _e = _c[1], initialTopMostItemIndex = _e.initialTopMostItemIndex, scrolledToInitialItem = _e.scrolledToInitialItem, domIO = _c[2], stateLoad = _c[3], followOutput = _c[4], _f = _c[5], scrollToIndex = _c[6].scrollToIndex, _ = _c[7], topItemCount = _c[8].topItemCount, groupCounts = _c[9].groupCounts, featureGroup1 = _c[10], listState = _f.listState, topItemsIndexes = _f.topItemsIndexes, flags = tslib_1.__rest(_f, ["listState", "topItemsIndexes"]);
     u.connect(flags.rangeChanged, featureGroup1.scrollSeekRangeChanged);
-    u.connect(u.pipe(featureGroup1.windowViewportRect, u.map(u.prop('visibleHeight'))), domIO.viewportHeight);
-    return tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({ 
+    u.connect(u.pipe(featureGroup1.windowViewportRect, u.map(function (value) { return value.visibleHeight; })), domIO.viewportHeight);
+    return tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({ 
         // input
         totalCount: totalCount,
         data: data,
@@ -41,12 +40,12 @@ exports.listSystem = u.system(function (_a) {
         scrolledToInitialItem: scrolledToInitialItem,
         topItemsIndexes: topItemsIndexes,
         topItemCount: topItemCount,
-        groupCounts: groupCounts, fixedItemHeight: fixedItemSize, defaultItemHeight: defaultItemSize }, followOutput), { 
+        groupCounts: groupCounts, fixedItemHeight: fixedItemSize, defaultItemHeight: defaultItemSize, gap: gap }, followOutput), { 
         // output
         statefulTotalCount: statefulTotalCount,
         listState: listState,
         scrollToIndex: scrollToIndex,
         trackItemSizes: trackItemSizes,
         itemSize: itemSize,
-        groupIndices: groupIndices }), flags), featureGroup1), domIO), log);
-}, u.tup(sizeSystem_1.sizeSystem, initialTopMostItemIndexSystem_1.initialTopMostItemIndexSystem, domIOSystem_1.domIOSystem, followOutputSystem_1.followOutputSystem, listStateSystem_1.listStateSystem, scrollToIndexSystem_1.scrollToIndexSystem, upwardScrollFixSystem_1.upwardScrollFixSystem, topItemCountSystem_1.topItemCountSystem, groupedListSystem_1.groupedListSystem, featureGroup1System, loggerSystem_1.loggerSystem));
+        groupIndices: groupIndices }), flags), featureGroup1), domIO), { sizes: sizes }), stateLoad);
+}, u.tup(sizeSystem_1.sizeSystem, initialTopMostItemIndexSystem_1.initialTopMostItemIndexSystem, domIOSystem_1.domIOSystem, stateLoadSystem_1.stateLoadSystem, followOutputSystem_1.followOutputSystem, listStateSystem_1.listStateSystem, scrollToIndexSystem_1.scrollToIndexSystem, upwardScrollFixSystem_1.upwardScrollFixSystem, topItemCountSystem_1.topItemCountSystem, groupedListSystem_1.groupedListSystem, featureGroup1System));

package/components/Virtuoso/react-virtuoso/loggerSystem.d.ts

@@ -1,4 +1,4 @@
-import * as u from '@virtuoso.dev/urx';
+import * as u from './urx';
 export declare enum LogLevel {
     DEBUG = 0,
     INFO = 1,

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

@@ -2,7 +2,7 @@
 var _a;
 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 LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
@@ -16,9 +16,7 @@ var CONSOLE_METHOD_MAP = (_a = {},
     _a[LogLevel.WARN] = 'warn',
     _a[LogLevel.ERROR] = 'error',
     _a);
-var getGlobalThis = function () {
-    return typeof globalThis === 'undefined' ? window : globalThis;
-};
+var getGlobalThis = function () { return (typeof globalThis === 'undefined' ? window : globalThis); };
 exports.loggerSystem = u.system(function () {
     var logLevel = u.statefulStream(LogLevel.ERROR);
     var log = u.statefulStream(function (label, message, level) {

package/components/Virtuoso/react-virtuoso/propsReadySystem.d.ts

@@ -1,4 +1,4 @@
-import * as u from '@virtuoso.dev/urx';
+import * as u from './urx';
 import { LogLevel } from './loggerSystem';
 export declare const propsReadySystem: u.SystemSpec<[u.SystemSpec<never[], () => {
     log: u.StatefulStream<import("./loggerSystem").Log>;

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

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-var u = tslib_1.__importStar(require("@virtuoso.dev/urx"));
-var urx_1 = require("@virtuoso.dev/urx");
+var u = tslib_1.__importStar(require("./urx"));
 var loggerSystem_1 = require("./loggerSystem");
 exports.propsReadySystem = u.system(function (_a) {
     var _b = tslib_1.__read(_a, 1), log = _b[0].log;
     var propsReady = u.statefulStream(false);
     var didMount = u.streamFromEmitter(u.pipe(propsReady, u.filter(function (ready) { return ready; }), u.distinctUntilChanged()));
     u.subscribe(propsReady, function (value) {
-        value && urx_1.getValue(log)('props updated', {}, loggerSystem_1.LogLevel.DEBUG);
+        value && u.getValue(log)('props updated', {}, loggerSystem_1.LogLevel.DEBUG);
     });
     return { propsReady: propsReady, didMount: didMount };
-}, urx_1.tup(loggerSystem_1.loggerSystem), { singleton: true });
+}, u.tup(loggerSystem_1.loggerSystem), { singleton: true });

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

@@ -0,0 +1,110 @@
+/**
+ * `@virtuoso.dev/react-urx` exports the [[systemToComponent]] function.
+ * It wraps urx systems in to UI **logic provider components**,
+ * mapping the system input and output streams to the component input / output points.
+ *
+ * ### Simple System wrapped as React Component
+ *
+ * ```tsx
+ * const sys = system(() => {
+ *   const foo = statefulStream(42)
+ *   return { foo }
+ * })
+ *
+ * const { Component: MyComponent, useEmitterValue } = systemToComponent(sys, {
+ *   required: { fooProp: 'foo' },
+ * })
+ *
+ * const Child = () => {
+ *   const foo = useEmitterValue('foo')
+ *   return <div>{foo}</div>
+ * }
+ *
+ * const App = () => {
+ *   return <Comp fooProp={42}><Child /><Comp>
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import * as u from '../urx';
+import type { Emitter, Publisher, AnySystemSpec, SR } from '../urx';
+/** @internal */
+export declare type Observable<T> = Emitter<T> | Publisher<T>;
+/**
+ * Describes the mapping between the system streams and the component properties.
+ * Each property uses the keys as the names of the properties and the values as the corresponding stream names.
+ * @typeParam SS the type of the system.
+ */
+export interface SystemPropsMap<SS extends AnySystemSpec, K = keyof SR<SS>, D = {
+    [key: string]: K;
+}> {
+    /**
+     * Specifies the required component properties.
+     */
+    required?: D;
+    /**
+     * Specifies the optional component properties.
+     */
+    optional?: D;
+    /**
+     * Specifies the component methods, if any. Streams are converted to methods with a single argument.
+     * When invoked, the method publishes the value of the argument to the specified stream.
+     */
+    methods?: D;
+    /**
+     * Specifies the component "event" properties, if any.
+     * Event properties accept callback functions which get executed when the stream emits a new value.
+     */
+    events?: D;
+}
+/** @internal */
+export declare type PropsFromPropMap<E extends AnySystemSpec, M extends SystemPropsMap<E>> = {
+    [K in Extract<keyof M['required'], string>]: M['required'][K] extends string ? SR<E>[M['required'][K]] extends Observable<infer R> ? R : never : never;
+} & {
+    [K in Extract<keyof M['optional'], string>]?: M['optional'][K] extends string ? SR<E>[M['optional'][K]] extends Observable<infer R> ? R : never : never;
+} & {
+    [K in Extract<keyof M['events'], string>]?: M['events'][K] extends string ? SR<E>[M['events'][K]] extends Observable<infer R> ? (value: R) => void : never : never;
+};
+/** @internal */
+export declare type MethodsFromPropMap<E extends AnySystemSpec, M extends SystemPropsMap<E>> = {
+    [K in Extract<keyof M['methods'], string>]: M['methods'][K] extends string ? SR<E>[M['methods'][K]] extends Observable<infer R> ? (value: R) => void : never : never;
+};
+/**
+ * Used to correctly specify type refs for system components
+ *
+ * ```tsx
+ * const s = system(() => { return { a: statefulStream(0) } })
+ * const { Component } = systemToComponent(s)
+ *
+ * const App = () => {
+ *  const ref = useRef<RefHandle<typeof Component>>()
+ *  return <Component ref={ref} />
+ * }
+ * ```
+ *
+ * @typeParam T the type of the component
+ */
+export declare type RefHandle<T> = T extends React.ForwardRefExoticComponent<React.RefAttributes<infer Handle>> ? Handle : never;
+/**
+ * Converts a system spec to React component by mapping the system streams to component properties, events and methods. Returns hooks for querying and modifying
+ * the system streams from the component's child components.
+ * @param systemSpec The return value from a [[system]] call.
+ * @param map The streams to props / events / methods mapping Check [[SystemPropsMap]] for more details.
+ * @param Root The optional React component to render. By default, the resulting component renders nothing, acting as a logical wrapper for its children.
+ * @returns an object containing the following:
+ *  - `Component`: the React component.
+ *  - `useEmitterValue`: a hook that lets child components use values emitted from the specified output stream.
+ *  - `useEmitter`: a hook that calls the provided callback whenever the specified stream emits a value.
+ *  - `usePublisher`: a hook which lets child components publish values to the specified stream.
+ *  <hr />
+ */
+export declare function systemToComponent<SS extends AnySystemSpec, M extends SystemPropsMap<SS>, S extends SR<SS>, R>(systemSpec: SS, map: M, Root?: R): {
+    Component: React.ForwardRefExoticComponent<React.PropsWithoutRef<{ [K in Extract<keyof M["required"], string>]: M["required"][K] extends string ? ReturnType<SS["constructor"]>[M["required"][K]] extends Observable<infer R_1> ? R_1 : never : never; } & { [K_1 in Extract<keyof M["optional"], string>]?: (M["optional"][K_1] extends string ? ReturnType<SS["constructor"]>[M["optional"][K_1]] extends Observable<infer R_2> ? R_2 : never : never) | undefined; } & { [K_2 in Extract<keyof M["events"], string>]?: (M["events"][K_2] extends string ? ReturnType<SS["constructor"]>[M["events"][K_2]] extends Observable<infer R_3> ? (value: R_3) => void : never : never) | undefined; } & (R extends React.ComponentType<infer RP> ? RP : {
+        children?: React.ReactNode;
+    })> & React.RefAttributes<MethodsFromPropMap<SS, M>>>;
+    usePublisher: <K_3 extends keyof S>(key: K_3) => (value: S[K_3] extends u.Stream<infer R_4> ? R_4 : never) => void;
+    useEmitterValue: <K_4 extends keyof S, V = S[K_4] extends u.StatefulStream<infer R_5> ? R_5 : never>(key: K_4) => V;
+    useEmitter: <K_5 extends keyof S, V_1 = S[K_5] extends u.Stream<infer R_6> ? R_6 : never>(key: K_5, callback: (value: V_1) => void) => void;
+};

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

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/**
+ * `@virtuoso.dev/react-urx` exports the [[systemToComponent]] function.
+ * It wraps urx systems in to UI **logic provider components**,
+ * mapping the system input and output streams to the component input / output points.
+ *
+ * ### Simple System wrapped as React Component
+ *
+ * ```tsx
+ * const sys = system(() => {
+ *   const foo = statefulStream(42)
+ *   return { foo }
+ * })
+ *
+ * const { Component: MyComponent, useEmitterValue } = systemToComponent(sys, {
+ *   required: { fooProp: 'foo' },
+ * })
+ *
+ * const Child = () => {
+ *   const foo = useEmitterValue('foo')
+ *   return <div>{foo}</div>
+ * }
+ *
+ * const App = () => {
+ *   return <Comp fooProp={42}><Child /><Comp>
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+var react_1 = tslib_1.__importDefault(require("react"));
+var u = tslib_1.__importStar(require("../urx"));
+/** @internal */
+function omit(keys, obj) {
+    var result = {};
+    var index = {};
+    var idx = 0;
+    var len = keys.length;
+    while (idx < len) {
+        index[keys[idx]] = 1;
+        idx += 1;
+    }
+    for (var prop in obj) {
+        if (!index.hasOwnProperty(prop)) {
+            result[prop] = obj[prop];
+        }
+    }
+    return result;
+}
+var useIsomorphicLayoutEffect = typeof document !== 'undefined' ? react_1.default.useLayoutEffect : react_1.default.useEffect;
+/**
+ * Converts a system spec to React component by mapping the system streams to component properties, events and methods. Returns hooks for querying and modifying
+ * the system streams from the component's child components.
+ * @param systemSpec The return value from a [[system]] call.
+ * @param map The streams to props / events / methods mapping Check [[SystemPropsMap]] for more details.
+ * @param Root The optional React component to render. By default, the resulting component renders nothing, acting as a logical wrapper for its children.
+ * @returns an object containing the following:
+ *  - `Component`: the React component.
+ *  - `useEmitterValue`: a hook that lets child components use values emitted from the specified output stream.
+ *  - `useEmitter`: a hook that calls the provided callback whenever the specified stream emits a value.
+ *  - `usePublisher`: a hook which lets child components publish values to the specified stream.
+ *  <hr />
+ */
+function systemToComponent(systemSpec, map, Root) {
+    var requiredPropNames = Object.keys(map.required || {});
+    var optionalPropNames = Object.keys(map.optional || {});
+    var methodNames = Object.keys(map.methods || {});
+    var eventNames = Object.keys(map.events || {});
+    var Context = react_1.default.createContext({});
+    function applyPropsToSystem(system, props) {
+        var e_1, _a, e_2, _b;
+        if (system['propsReady']) {
+            u.publish(system['propsReady'], false);
+        }
+        try {
+            for (var requiredPropNames_1 = tslib_1.__values(requiredPropNames), requiredPropNames_1_1 = requiredPropNames_1.next(); !requiredPropNames_1_1.done; requiredPropNames_1_1 = requiredPropNames_1.next()) {
+                var requiredPropName = requiredPropNames_1_1.value;
+                var stream = system[map.required[requiredPropName]];
+                u.publish(stream, props[requiredPropName]);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (requiredPropNames_1_1 && !requiredPropNames_1_1.done && (_a = requiredPropNames_1.return)) _a.call(requiredPropNames_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        try {
+            for (var optionalPropNames_1 = tslib_1.__values(optionalPropNames), optionalPropNames_1_1 = optionalPropNames_1.next(); !optionalPropNames_1_1.done; optionalPropNames_1_1 = optionalPropNames_1.next()) {
+                var optionalPropName = optionalPropNames_1_1.value;
+                if (optionalPropName in props) {
+                    var stream = system[map.optional[optionalPropName]];
+                    u.publish(stream, props[optionalPropName]);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (optionalPropNames_1_1 && !optionalPropNames_1_1.done && (_b = optionalPropNames_1.return)) _b.call(optionalPropNames_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        if (system['propsReady']) {
+            u.publish(system['propsReady'], true);
+        }
+    }
+    function buildMethods(system) {
+        return methodNames.reduce(function (acc, methodName) {
+            ;
+            acc[methodName] = function (value) {
+                var stream = system[map.methods[methodName]];
+                u.publish(stream, value);
+            };
+            return acc;
+        }, {});
+    }
+    function buildEventHandlers(system) {
+        return eventNames.reduce(function (handlers, eventName) {
+            handlers[eventName] = u.eventHandler(system[map.events[eventName]]);
+            return handlers;
+        }, {});
+    }
+    /**
+     * A React component generated from an urx system
+     */
+    // eslint-disable-next-line react/display-name
+    var Component = react_1.default.forwardRef(function (propsWithChildren, ref) {
+        var _a = propsWithChildren, children = _a.children, props = tslib_1.__rest(_a, ["children"]);
+        var _b = tslib_1.__read(react_1.default.useState(function () {
+            return u.tap(u.init(systemSpec), function (system) { return applyPropsToSystem(system, props); });
+        }), 1), system = _b[0];
+        var _c = tslib_1.__read(react_1.default.useState(u.curry1to0(buildEventHandlers, system)), 1), handlers = _c[0];
+        useIsomorphicLayoutEffect(function () {
+            var e_3, _a;
+            try {
+                for (var eventNames_1 = tslib_1.__values(eventNames), eventNames_1_1 = eventNames_1.next(); !eventNames_1_1.done; eventNames_1_1 = eventNames_1.next()) {
+                    var eventName = eventNames_1_1.value;
+                    if (eventName in props) {
+                        u.subscribe(handlers[eventName], props[eventName]);
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (eventNames_1_1 && !eventNames_1_1.done && (_a = eventNames_1.return)) _a.call(eventNames_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            return function () {
+                Object.values(handlers).map(u.reset);
+            };
+        }, [props, handlers, system]);
+        useIsomorphicLayoutEffect(function () {
+            applyPropsToSystem(system, props);
+        });
+        react_1.default.useImperativeHandle(ref, u.always(buildMethods(system)));
+        return react_1.default.createElement(Context.Provider, { value: system }, Root
+            ? react_1.default.createElement(Root, omit(tslib_1.__spread(requiredPropNames, optionalPropNames, eventNames), props), children)
+            : children);
+    });
+    var usePublisher = function (key) {
+        return react_1.default.useCallback(u.curry2to1(u.publish, react_1.default.useContext(Context)[key]), [key]);
+    };
+    /**
+     * Returns the value emitted from the stream.
+     */
+    var useEmitterValue = function (key) {
+        var system = react_1.default.useContext(Context);
+        var source = system[key];
+        var _a = tslib_1.__read(react_1.default.useState(u.curry1to0(u.getValue, source)), 2), value = _a[0], setValue = _a[1];
+        useIsomorphicLayoutEffect(function () {
+            return u.subscribe(source, function (next) {
+                if (next !== value) {
+                    setValue(u.always(next));
+                }
+            });
+        }, [source, value]);
+        return value;
+    };
+    var useEmitter = function (key, callback) {
+        var context = react_1.default.useContext(Context);
+        var source = context[key];
+        useIsomorphicLayoutEffect(function () { return u.subscribe(source, callback); }, [callback, source]);
+    };
+    return {
+        Component: Component,
+        usePublisher: usePublisher,
+        useEmitterValue: useEmitterValue,
+        useEmitter: useEmitter,
+    };
+}
+exports.systemToComponent = systemToComponent;

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

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

package/components/Virtuoso/react-virtuoso/recalcSystem.d.ts

@@ -0,0 +1,4 @@
+import * as u from './urx';
+export declare const recalcSystem: u.SystemSpec<never[], () => {
+    recalcInProgress: u.StatefulStream<boolean>;
+}>;

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var u = tslib_1.__importStar(require("./urx"));
+exports.recalcSystem = u.system(function () {
+    var recalcInProgress = u.statefulStream(false);
+    return { recalcInProgress: recalcInProgress };
+}, [], { singleton: true });