@ringcentral/juno 2.40.1 → 2.41.1

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

@@ -0,0 +1,148 @@
+/**
+ * ## Thinking in Systems
+ * systems are a stateful **data-processing machines** which accept input through **input streams**,
+ * init and maintain state in **depots** and, in certain conditions, emit values to subscriptions through **output streams**.
+ * Systems can specify other systems as dependencies, and can act as singletons in the resulting dependency tree.
+ *
+ * ### Depots
+ *
+ * The first, and probably the most critical part to understand are **the depots**
+ * mostly because they are somewhat implicit.
+ * Unlike other state management paradigms, the depots are not kept in a single data structure.
+ * Insted, depots are defined and maintained as stateful streams, stateful transfomers
+ * like [[combineLatest]] or stateful operators like[ []withLatestFrom] or [[scan]].
+ *
+ * **Depots persist values over time**.
+ * If it was not for them, the system had to re-receive its entire input state simultaneously in order to calculate the values for its output stream.
+ *
+ * Of course, strictly speaking, it is possible to implement a pure, stateless system as a form of a complex map/reduce. urx would not mind that ;).
+ *
+ * ### Input Streams
+ *
+ * The system receives updates from the rest of the world through values published in its input streams.
+ * The streams used can be either stateless (acting as means to send **signals**) or stateful, where the initial stream state acts as the default value for that system parameter.
+ *
+ * The effects of the input streams are up to the system data-processing logic. It can change its depots' state, and/or emit values through its output streams.
+ *
+ * ### Data Processing
+ *
+ * The actual system behavior is exclusively implemented by **applying transformers and operators** to the input streams, producing the respective output streams.
+ * In the final state the system streams are organized in a directed graph, where incoming data is routed through certain edges and nodes.
+ * Simple systems like the one in [urx by example](https://urx.virtuoso.dev/docs/urx-by-example) can use a straightforward single-step transformation (in this case, `combineLatest` and `map`),
+ * while complex ones can introduce multiple intermediate streams to model their logic.
+ *
+ * ### Output Streams
+ *
+ * The system publishes updates to its clients (other systems or an UI bound to it) by publishing data in its output streams.
+ * State-reflecting output streams, like `sum` in the [urx by example](https://urx.virtuoso.dev/docs/urx-by-example) should use stateful streams as output streams.
+ * Signal-like output should use regular, stateless streams. In general, stateless input streams tend to have a symmetrical stateless streams, and the opposite.
+ *
+ * @packageDocumentation
+ */
+import { Emitter } from './actions';
+/**
+ * Systems are a dictionaries of streams. a [[SystemConstructor]] should return a System.
+ */
+export interface System {
+    [key: string]: Emitter<any>;
+}
+/**
+ * a SystemSpec is the result from a [[system]] call. To obtain the [[System]], pass the spec to [[init]].
+ */
+export interface SystemSpec<SS extends SystemSpecs, C extends SystemConstructor<SS>> {
+    id: string;
+    constructor: C;
+    dependencies: SS;
+    singleton: boolean;
+}
+/** @internal **/
+export declare type AnySystemSpec = SystemSpec<any, any>;
+/** @internal **/
+export declare type SystemSpecs = AnySystemSpec[];
+/** @internal **/
+export declare type SR<E extends AnySystemSpec, R extends System = ReturnType<E['constructor']>> = R;
+/** @internal **/
+export declare type SpecResults<SS extends SystemSpecs, L = SS['length']> = L extends 0 ? [] : L extends 1 ? [SR<SS[0]>] : L extends 2 ? [SR<SS[0]>, SR<SS[1]>] : L extends 3 ? [SR<SS[0]>, SR<SS[1]>, SR<SS[2]>] : L extends 4 ? [SR<SS[0]>, SR<SS[1]>, SR<SS[2]>, SR<SS[3]>] : L extends 5 ? [SR<SS[0]>, SR<SS[1]>, SR<SS[2]>, SR<SS[3]>, SR<SS[4]>] : L extends 6 ? [SR<SS[0]>, SR<SS[1]>, SR<SS[2]>, SR<SS[3]>, SR<SS[4]>, SR<SS[5]>] : L extends 7 ? [SR<SS[0]>, SR<SS[1]>, SR<SS[2]>, SR<SS[3]>, SR<SS[4]>, SR<SS[5]>, SR<SS[6]>] : L extends 8 ? [SR<SS[0]>, SR<SS[1]>, SR<SS[2]>, SR<SS[3]>, SR<SS[4]>, SR<SS[5]>, SR<SS[6]>, SR<SS[7]>] : L extends 9 ? [SR<SS[0]>, SR<SS[1]>, SR<SS[2]>, SR<SS[3]>, SR<SS[4]>, SR<SS[5]>, SR<SS[6]>, SR<SS[7]>, SR<SS[8]>] : L extends 10 ? [SR<SS[0]>, SR<SS[1]>, SR<SS[2]>, SR<SS[3]>, SR<SS[4]>, SR<SS[5]>, SR<SS[6]>, SR<SS[7]>, SR<SS[8]>, SR<SS[9]>] : L extends 11 ? [SR<SS[0]>, SR<SS[1]>, SR<SS[2]>, SR<SS[3]>, SR<SS[4]>, SR<SS[5]>, SR<SS[6]>, SR<SS[7]>, SR<SS[8]>, SR<SS[9]>, SR<SS[10]>] : never;
+/**
+ * The system constructor is a function which initializes and connects streams and returns them as a [[System]].
+ * If the [[system]] call specifies system dependencies, the constructor receives the dependencies as an array argument.
+ */
+export declare type SystemConstructor<D extends SystemSpecs> = (dependencies: SpecResults<D>) => System;
+/**
+ * `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 declare function system<F extends SystemConstructor<D>, D extends SystemSpecs>(constructor: F, dependencies?: D, { singleton }?: {
+    singleton: boolean;
+}): SystemSpec<D, F>;
+/**
+ * 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 declare function init<SS extends AnySystemSpec>(systemSpec: SS): SR<SS>;

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * `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.
+ */
+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,
+    };
+}
+exports.system = system;
+/** @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.
+ */
+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);
+}
+exports.init = init;

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

@@ -0,0 +1,71 @@
+/**
+ * Transformers change and combine streams, similar to operators.
+ * urx comes with two combinators - [[combineLatest]] and [[merge]], and one convenience filter - [[duc]].
+ *
+ * @packageDocumentation
+ */
+import { Emitter } from './actions';
+import { Comparator } from './pipe';
+/**
+ * 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 declare function merge<T>(...sources: Emitter<T>[]): Emitter<T>;
+/**
+ * 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 declare function duc<T>(source: Emitter<T>, comparator?: Comparator<T>): Emitter<T>;
+/**
+ * Creates an emitter with the latest values from all passed emitters as an array.
+ *
+ * `combineLatest` acts as a Depot. Using it on stateless streams persists the last emitted value of each [[Emitter]].
+ * Provided that all emitters have emitted at least once, subscribing to the resulting emitter will immediately receive their combined latest values.
+ *
+ * ```ts
+ * const foo = stream<number>()
+ * const bar = stream<number>()
+ *
+ * subscribe(combineLatest(foo, bar), ([foo, bar]) => console.log({ foo, bar }))
+ *
+ * publish(foo, 42)
+ * publish(bar, 43) // { foo: 42, bar: 43 }
+ * publish(foo, 44) // { foo: 44, bar: 43 }
+ * publish(bar, 45) // { foo: 44, bar: 45 }
+ * ```
+ */
+export declare function combineLatest<O1, O2>(...emitters: [Emitter<O1>, Emitter<O2>]): Emitter<[O1, O2]>;
+export declare function combineLatest<O1, O2, O3>(...emitters: [Emitter<O1>, Emitter<O2>, Emitter<O3>]): Emitter<[O1, O2, O3]>;
+export declare function combineLatest<O1, O2, O3, O4>(...emitters: [Emitter<O1>, Emitter<O2>, Emitter<O3>, Emitter<O4>]): Emitter<[O1, O2, O3, O4]>;
+export declare function combineLatest<O1, O2, O3>(...emitters: [Emitter<O1>, Emitter<O2>, Emitter<O3>]): Emitter<[O1, O2, O3]>;
+export declare function combineLatest<O1, O2, O3, O4, O5>(...emitters: [Emitter<O1>, Emitter<O2>, Emitter<O3>, Emitter<O4>, Emitter<O5>]): Emitter<[O1, O2, O3, O4, O5]>;
+export declare function combineLatest<O1, O2, O3, O4, O5, O6>(...emitters: [Emitter<O1>, Emitter<O2>, Emitter<O3>, Emitter<O4>, Emitter<O5>, Emitter<O6>]): Emitter<[O1, O2, O3, O4, O5, O6]>;
+export declare function combineLatest<O1, O2, O3, O4, O5, O6, O7>(...emitters: [Emitter<O1>, Emitter<O2>, Emitter<O3>, Emitter<O4>, Emitter<O5>, Emitter<O6>, Emitter<O7>]): Emitter<[O1, O2, O3, O4, O5, O6, O7]>;
+export declare function combineLatest<O1, O2, O3, O4, O5, O6, O7, O8>(...emitters: [Emitter<O1>, Emitter<O2>, Emitter<O3>, Emitter<O4>, Emitter<O5>, Emitter<O6>, Emitter<O7>, Emitter<O8>]): Emitter<[O1, O2, O3, O4, O5, O6, O7, O8]>;
+export declare function combineLatest<O1, O2, O3, O4, O5, O6, O7, O8, O9>(...emitters: [Emitter<O1>, Emitter<O2>, Emitter<O3>, Emitter<O4>, Emitter<O5>, Emitter<O6>, Emitter<O7>, Emitter<O8>, Emitter<O9>]): Emitter<[O1, O2, O3, O4, O5, O6, O7, O8, O9]>;
+export declare function combineLatest<O1, O2, O3, O4, O5, O6, O7, O8, O9, O10>(...emitters: [Emitter<O1>, Emitter<O2>, Emitter<O3>, Emitter<O4>, Emitter<O5>, Emitter<O6>, Emitter<O7>, Emitter<O8>, Emitter<O9>, Emitter<O10>]): Emitter<[O1, O2, O3, O4, O5, O6, O7, O8, O9, O10]>;
+export declare function combineLatest<O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11>(...emitters: [Emitter<O1>, Emitter<O2>, Emitter<O3>, Emitter<O4>, Emitter<O5>, Emitter<O6>, Emitter<O7>, Emitter<O8>, Emitter<O9>, Emitter<O10>, Emitter<O11>]): Emitter<[O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11]>;

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("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
+ */
+var actions_1 = require("./actions");
+var constants_1 = require("./constants");
+var pipe_1 = require("./pipe");
+var streams_1 = require("./streams");
+var utils_1 = require("./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)
+ * ```
+ */
+function merge() {
+    var sources = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        sources[_i] = arguments[_i];
+    }
+    return function (action, subscription) {
+        switch (action) {
+            case constants_1.SUBSCRIBE:
+                return utils_1.joinProc.apply(void 0, tslib_1.__spread(sources.map(function (source) { return actions_1.subscribe(source, subscription); })));
+            case constants_1.RESET:
+                // do nothing, we are stateless
+                return;
+            default:
+                throw new Error("unrecognized action " + action);
+        }
+    };
+}
+exports.merge = merge;
+/**
+ * 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.
+ */
+function duc(source, comparator) {
+    if (comparator === void 0) { comparator = pipe_1.defaultComparator; }
+    return pipe_1.pipe(source, pipe_1.distinctUntilChanged(comparator));
+}
+exports.duc = duc;
+function combineLatest() {
+    var emitters = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        emitters[_i] = arguments[_i];
+    }
+    var innerSubject = streams_1.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);
+        actions_1.subscribe(source, function (value) {
+            values[index] = value;
+            called = called | bit;
+            if (called === allCalled) {
+                actions_1.publish(innerSubject, values);
+            }
+        });
+    });
+    return function (action, subscription) {
+        switch (action) {
+            case constants_1.SUBSCRIBE:
+                if (called === allCalled) {
+                    subscription(values);
+                }
+                return actions_1.subscribe(innerSubject, subscription);
+            case constants_1.RESET:
+                return actions_1.reset(innerSubject);
+            default:
+                throw new Error("unrecognized action " + action);
+        }
+    };
+}
+exports.combineLatest = combineLatest;

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

@@ -0,0 +1,57 @@
+/**
+ * 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
+ */
+/** @internal */
+export interface Proc {
+    (): any;
+}
+/**
+ * Performs left to right composition of two functions.
+ */
+export declare function compose<I, A, R>(a: (arg: A) => R, b: (arg: I) => A): (arg: I) => R;
+/**
+ * Takes a value and applies a function to it.
+ */
+export declare function thrush<I, K>(arg: I, proc: (arg: I) => K): K;
+/**
+ * Takes a 2 argument function and partially applies the first argument.
+ */
+export declare function curry2to1<T, K, R>(proc: (arg1: T, arg2: K) => R, arg1: T): (arg2: K) => R;
+/**
+ * Takes a 1 argument function and returns a function which when called, executes it with the provided argument.
+ */
+export declare function curry1to0<T, R>(proc: (arg: T) => R, arg: T): () => R;
+/**
+ * Returns a function which extracts the property from from the passed object.
+ */
+export declare function prop(property: string): (object: any) => any;
+/**
+ * Calls callback with the first argument, and returns it.
+ */
+export declare function tap<T>(arg: T, proc: (arg: T) => any): T;
+/**
+ *  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 declare function tup<T extends Array<any>>(...args: T): T;
+/**
+ * Calls the passed function.
+ */
+export declare function call(proc: Proc): void;
+/**
+ * returns a function which when called always returns the passed value
+ */
+export declare function always<T>(value: T): () => T;
+/**
+ * returns a function which calls all passed functions in the passed order.
+ * joinProc does not pass arguments or collect return values.
+ */
+export declare function joinProc(...procs: Proc[]): () => void;
+export declare function isDefined<T>(arg: T): boolean;
+export declare function noop(): void;

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

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Performs left to right composition of two functions.
+ */
+function compose(a, b) {
+    return function (arg) { return a(b(arg)); };
+}
+exports.compose = compose;
+/**
+ * Takes a value and applies a function to it.
+ */
+function thrush(arg, proc) {
+    return proc(arg);
+}
+exports.thrush = thrush;
+/**
+ * Takes a 2 argument function and partially applies the first argument.
+ */
+function curry2to1(proc, arg1) {
+    return function (arg2) { return proc(arg1, arg2); };
+}
+exports.curry2to1 = curry2to1;
+/**
+ * Takes a 1 argument function and returns a function which when called, executes it with the provided argument.
+ */
+function curry1to0(proc, arg) {
+    return function () { return proc(arg); };
+}
+exports.curry1to0 = curry1to0;
+/**
+ * Returns a function which extracts the property from from the passed object.
+ */
+function prop(property) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return
+    return function (object) { return object[property]; };
+}
+exports.prop = prop;
+/**
+ * Calls callback with the first argument, and returns it.
+ */
+function tap(arg, proc) {
+    proc(arg);
+    return arg;
+}
+exports.tap = tap;
+/**
+ *  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]
+ */
+function tup() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return args;
+}
+exports.tup = tup;
+/**
+ * Calls the passed function.
+ */
+function call(proc) {
+    proc();
+}
+exports.call = call;
+/**
+ * returns a function which when called always returns the passed value
+ */
+function always(value) {
+    return function () { return value; };
+}
+exports.always = always;
+/**
+ * returns a function which calls all passed functions in the passed order.
+ * joinProc does not pass arguments or collect return values.
+ */
+function joinProc() {
+    var procs = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        procs[_i] = arguments[_i];
+    }
+    return function () {
+        procs.map(call);
+    };
+}
+exports.joinProc = joinProc;
+function isDefined(arg) {
+    return arg !== undefined;
+}
+exports.isDefined = isDefined;
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+function noop() { }
+exports.noop = noop;

package/components/Virtuoso/react-virtuoso/utils/approximatelyEqual.d.ts

@@ -0,0 +1 @@
+export declare function approximatelyEqual(num1: number, num2: number): boolean;

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function approximatelyEqual(num1, num2) {
+    return Math.abs(num1 - num2) < 1.01;
+}
+exports.approximatelyEqual = approximatelyEqual;

package/components/Virtuoso/react-virtuoso/utils/context.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+export interface VirtuosoMockContextValue {
+    viewportHeight: number;
+    itemHeight: number;
+}
+export declare const VirtuosoMockContext: React.Context<VirtuosoMockContextValue | undefined>;
+export interface VirtuosoGridMockContextValue {
+    viewportHeight: number;
+    viewportWidth: number;
+    itemHeight: number;
+    itemWidth: number;
+}
+export declare const VirtuosoGridMockContext: React.Context<VirtuosoGridMockContextValue | undefined>;

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var react_1 = tslib_1.__importDefault(require("react"));
+exports.VirtuosoMockContext = react_1.default.createContext(undefined);
+exports.VirtuosoGridMockContext = react_1.default.createContext(undefined);

package/components/Virtuoso/react-virtuoso/utils/skipFrames.d.ts

@@ -0,0 +1 @@
+export declare function skipFrames(frameCount: number, callback: () => void): void;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function skipFrames(frameCount, callback) {
+    if (frameCount == 0) {
+        callback();
+    }
+    else {
+        requestAnimationFrame(function () { return skipFrames(frameCount - 1, callback); });
+    }
+}
+exports.skipFrames = skipFrames;

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

@@ -1,14 +1,15 @@
-import * as u from '@virtuoso.dev/urx';
-import { ScrollContainerState, WindowViewportInfo } from './interfaces';
+import * as u from './urx';
+import { WindowViewportInfo, ScrollContainerState } from './interfaces';
 export declare const windowScrollerSystem: u.SystemSpec<[u.SystemSpec<never[], () => {
     scrollContainerState: u.Stream<ScrollContainerState>;
     scrollTop: u.Stream<number>;
     viewportHeight: u.Stream<number>;
     headerHeight: u.StatefulStream<number>;
+    fixedHeaderHeight: u.StatefulStream<number>;
+    fixedFooterHeight: u.StatefulStream<number>;
     footerHeight: u.StatefulStream<number>;
     scrollHeight: u.Stream<number>;
     smoothScrollTargetReached: u.Stream<true>;
-    react18ConcurrentRendering: u.StatefulStream<boolean>;
     scrollTo: u.Stream<ScrollToOptions>;
     scrollBy: u.Stream<ScrollToOptions>;
     statefulScrollTop: u.StatefulStream<number>;
@@ -19,10 +20,11 @@ export declare const windowScrollerSystem: u.SystemSpec<[u.SystemSpec<never[], (
     scrollTop: u.Stream<number>;
     viewportHeight: u.Stream<number>;
     headerHeight: u.StatefulStream<number>;
+    fixedHeaderHeight: u.StatefulStream<number>;
+    fixedFooterHeight: u.StatefulStream<number>;
     footerHeight: u.StatefulStream<number>;
     scrollHeight: u.Stream<number>;
     smoothScrollTargetReached: u.Stream<true>;
-    react18ConcurrentRendering: u.StatefulStream<boolean>;
     scrollTo: u.Stream<ScrollToOptions>;
     scrollBy: u.Stream<ScrollToOptions>;
     statefulScrollTop: u.StatefulStream<number>;