Initial commit

node_modules/use-callback-ref/dist/es5/assignRef.d.ts

@@ -0,0 +1,15 @@
+import { ReactRef } from './types';
+/**
+ * Assigns a value for a given ref, no matter of the ref format
+ * @param {RefObject} ref - a callback function or ref object
+ * @param value - a new value
+ *
+ * @see https://github.com/theKashey/use-callback-ref#assignref
+ * @example
+ * const refObject = useRef();
+ * const refFn = (ref) => {....}
+ *
+ * assignRef(refObject, "refValue");
+ * assignRef(refFn, "refValue");
+ */
+export declare function assignRef<T>(ref: ReactRef<T>, value: T | null): ReactRef<T>;

node_modules/use-callback-ref/dist/es5/assignRef.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignRef = void 0;
+/**
+ * Assigns a value for a given ref, no matter of the ref format
+ * @param {RefObject} ref - a callback function or ref object
+ * @param value - a new value
+ *
+ * @see https://github.com/theKashey/use-callback-ref#assignref
+ * @example
+ * const refObject = useRef();
+ * const refFn = (ref) => {....}
+ *
+ * assignRef(refObject, "refValue");
+ * assignRef(refFn, "refValue");
+ */
+function assignRef(ref, value) {
+    if (typeof ref === 'function') {
+        ref(value);
+    }
+    else if (ref) {
+        ref.current = value;
+    }
+    return ref;
+}
+exports.assignRef = assignRef;

node_modules/use-callback-ref/dist/es5/createRef.d.ts

@@ -0,0 +1,10 @@
+import { RefObject } from 'react';
+/**
+ * creates a Ref object with on change callback
+ * @param callback
+ * @returns {RefObject}
+ *
+ * @see {@link useCallbackRef}
+ * @see https://reactjs.org/docs/refs-and-the-dom.html#creating-refs
+ */
+export declare function createCallbackRef<T>(callback: (newValue: T | null, lastValue: T | null) => any): RefObject<T>;

node_modules/use-callback-ref/dist/es5/createRef.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCallbackRef = void 0;
+/**
+ * creates a Ref object with on change callback
+ * @param callback
+ * @returns {RefObject}
+ *
+ * @see {@link useCallbackRef}
+ * @see https://reactjs.org/docs/refs-and-the-dom.html#creating-refs
+ */
+function createCallbackRef(callback) {
+    var current = null;
+    return {
+        get current() {
+            return current;
+        },
+        set current(value) {
+            var last = current;
+            if (last !== value) {
+                current = value;
+                callback(value, last);
+            }
+        },
+    };
+}
+exports.createCallbackRef = createCallbackRef;

node_modules/use-callback-ref/dist/es5/index.d.ts

@@ -0,0 +1,8 @@
+export { assignRef } from './assignRef';
+export { useCallbackRef } from './useRef';
+export { createCallbackRef } from './createRef';
+export { mergeRefs } from './mergeRef';
+export { useMergeRefs } from './useMergeRef';
+export { useTransformRef } from './useTransformRef';
+export { transformRef } from './transformRef';
+export { refToCallback, useRefToCallback } from './refToCallback';

node_modules/use-callback-ref/dist/es5/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRefToCallback = exports.refToCallback = exports.transformRef = exports.useTransformRef = exports.useMergeRefs = exports.mergeRefs = exports.createCallbackRef = exports.useCallbackRef = exports.assignRef = void 0;
+var assignRef_1 = require("./assignRef");
+Object.defineProperty(exports, "assignRef", { enumerable: true, get: function () { return assignRef_1.assignRef; } });
+// callback ref
+var useRef_1 = require("./useRef");
+Object.defineProperty(exports, "useCallbackRef", { enumerable: true, get: function () { return useRef_1.useCallbackRef; } });
+var createRef_1 = require("./createRef");
+Object.defineProperty(exports, "createCallbackRef", { enumerable: true, get: function () { return createRef_1.createCallbackRef; } });
+// merge ref
+var mergeRef_1 = require("./mergeRef");
+Object.defineProperty(exports, "mergeRefs", { enumerable: true, get: function () { return mergeRef_1.mergeRefs; } });
+var useMergeRef_1 = require("./useMergeRef");
+Object.defineProperty(exports, "useMergeRefs", { enumerable: true, get: function () { return useMergeRef_1.useMergeRefs; } });
+// transform ref
+var useTransformRef_1 = require("./useTransformRef");
+Object.defineProperty(exports, "useTransformRef", { enumerable: true, get: function () { return useTransformRef_1.useTransformRef; } });
+var transformRef_1 = require("./transformRef");
+Object.defineProperty(exports, "transformRef", { enumerable: true, get: function () { return transformRef_1.transformRef; } });
+// refToCallback
+var refToCallback_1 = require("./refToCallback");
+Object.defineProperty(exports, "refToCallback", { enumerable: true, get: function () { return refToCallback_1.refToCallback; } });
+Object.defineProperty(exports, "useRefToCallback", { enumerable: true, get: function () { return refToCallback_1.useRefToCallback; } });

node_modules/use-callback-ref/dist/es5/mergeRef.d.ts

@@ -0,0 +1,16 @@
+import { MutableRefObject } from 'react';
+import { ReactRef } from './types';
+/**
+ * Merges two or more refs together providing a single interface to set their value
+ * @param {RefObject|Ref} refs
+ * @returns {MutableRefObject} - a new ref, which translates all changes to {refs}
+ *
+ * @see {@link useMergeRefs} to be used in ReactComponents
+ * @example
+ * const Component = React.forwardRef((props, ref) => {
+ *   const ownRef = useRef();
+ *   const domRef = mergeRefs([ref, ownRef]); // 👈 merge together
+ *   return <div ref={domRef}>...</div>
+ * }
+ */
+export declare function mergeRefs<T>(refs: ReactRef<T>[]): MutableRefObject<T | null>;

node_modules/use-callback-ref/dist/es5/mergeRef.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeRefs = void 0;
+var assignRef_1 = require("./assignRef");
+var createRef_1 = require("./createRef");
+/**
+ * Merges two or more refs together providing a single interface to set their value
+ * @param {RefObject|Ref} refs
+ * @returns {MutableRefObject} - a new ref, which translates all changes to {refs}
+ *
+ * @see {@link useMergeRefs} to be used in ReactComponents
+ * @example
+ * const Component = React.forwardRef((props, ref) => {
+ *   const ownRef = useRef();
+ *   const domRef = mergeRefs([ref, ownRef]); // 👈 merge together
+ *   return <div ref={domRef}>...</div>
+ * }
+ */
+function mergeRefs(refs) {
+    return (0, createRef_1.createCallbackRef)(function (newValue) { return refs.forEach(function (ref) { return (0, assignRef_1.assignRef)(ref, newValue); }); });
+}
+exports.mergeRefs = mergeRefs;

node_modules/use-callback-ref/dist/es5/refToCallback.d.ts

@@ -0,0 +1,24 @@
+import { ReactRef, RefCallback } from './types';
+/**
+ * Unmemoized version of {@link useRefToCallback}
+ * @see {@link useRefToCallback}
+ * @param ref
+ */
+export declare function refToCallback<T>(ref: ReactRef<T>): RefCallback<T>;
+/**
+ * Transforms a given `ref` into `callback`.
+ *
+ * To transform `callback` into ref use {@link useCallbackRef|useCallbackRef(undefined, callback)}
+ *
+ * @param {ReactRef} ref
+ * @returns {Function}
+ *
+ * @see https://github.com/theKashey/use-callback-ref#reftocallback
+ *
+ * @example
+ * const ref = useRef(0);
+ * const setRef = useRefToCallback(ref);
+ * 👉 setRef(10);
+ * ✅ ref.current === 10
+ */
+export declare function useRefToCallback<T>(ref: ReactRef<T>): RefCallback<T>;

node_modules/use-callback-ref/dist/es5/refToCallback.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRefToCallback = exports.refToCallback = void 0;
+/**
+ * Unmemoized version of {@link useRefToCallback}
+ * @see {@link useRefToCallback}
+ * @param ref
+ */
+function refToCallback(ref) {
+    return function (newValue) {
+        if (typeof ref === 'function') {
+            ref(newValue);
+        }
+        else if (ref) {
+            ref.current = newValue;
+        }
+    };
+}
+exports.refToCallback = refToCallback;
+var nullCallback = function () { return null; };
+// lets maintain a weak ref to, well, ref :)
+// not using `kashe` to keep this package small
+var weakMem = new WeakMap();
+var weakMemoize = function (ref) {
+    var usedRef = ref || nullCallback;
+    var storedRef = weakMem.get(usedRef);
+    if (storedRef) {
+        return storedRef;
+    }
+    var cb = refToCallback(usedRef);
+    weakMem.set(usedRef, cb);
+    return cb;
+};
+/**
+ * Transforms a given `ref` into `callback`.
+ *
+ * To transform `callback` into ref use {@link useCallbackRef|useCallbackRef(undefined, callback)}
+ *
+ * @param {ReactRef} ref
+ * @returns {Function}
+ *
+ * @see https://github.com/theKashey/use-callback-ref#reftocallback
+ *
+ * @example
+ * const ref = useRef(0);
+ * const setRef = useRefToCallback(ref);
+ * 👉 setRef(10);
+ * ✅ ref.current === 10
+ */
+function useRefToCallback(ref) {
+    return weakMemoize(ref);
+}
+exports.useRefToCallback = useRefToCallback;

node_modules/use-callback-ref/dist/es5/transformRef.d.ts

@@ -0,0 +1,11 @@
+import { ReactRef, RefObject } from './types';
+/**
+ * Transforms one ref to another
+ * @example
+ * ```tsx
+ * const ResizableWithRef = forwardRef((props, ref) =>
+ *   <Resizable {...props} ref={transformRef(ref, i => i ? i.resizable : null)}/>
+ * );
+ * ```
+ */
+export declare function transformRef<T, K>(ref: ReactRef<K>, transformer: (original: T | null) => K): RefObject<T>;

node_modules/use-callback-ref/dist/es5/transformRef.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformRef = void 0;
+var assignRef_1 = require("./assignRef");
+var createRef_1 = require("./createRef");
+/**
+ * Transforms one ref to another
+ * @example
+ * ```tsx
+ * const ResizableWithRef = forwardRef((props, ref) =>
+ *   <Resizable {...props} ref={transformRef(ref, i => i ? i.resizable : null)}/>
+ * );
+ * ```
+ */
+function transformRef(ref, transformer) {
+    return (0, createRef_1.createCallbackRef)(function (value) { return (0, assignRef_1.assignRef)(ref, transformer(value)); });
+}
+exports.transformRef = transformRef;

node_modules/use-callback-ref/dist/es5/types.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+export declare type RefCallback<T> = (newValue: T | null) => void;
+export declare type RefObject<T> = React.MutableRefObject<T | null>;
+export declare type DefinedReactRef<T> = RefCallback<T> | RefObject<T>;
+export declare type ReactRef<T> = DefinedReactRef<T> | null;

node_modules/use-callback-ref/dist/es5/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/use-callback-ref/dist/es5/useMergeRef.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { ReactRef } from './types';
+/**
+ * Merges two or more refs together providing a single interface to set their value
+ * @param {RefObject|Ref} refs
+ * @returns {MutableRefObject} - a new ref, which translates all changes to {refs}
+ *
+ * @see {@link mergeRefs} a version without buit-in memoization
+ * @see https://github.com/theKashey/use-callback-ref#usemergerefs
+ * @example
+ * const Component = React.forwardRef((props, ref) => {
+ *   const ownRef = useRef();
+ *   const domRef = useMergeRefs([ref, ownRef]); // 👈 merge together
+ *   return <div ref={domRef}>...</div>
+ * }
+ */
+export declare function useMergeRefs<T>(refs: ReactRef<T>[], defaultValue?: T): React.MutableRefObject<T | null>;

node_modules/use-callback-ref/dist/es5/useMergeRef.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMergeRefs = void 0;
+var tslib_1 = require("tslib");
+var React = tslib_1.__importStar(require("react"));
+var assignRef_1 = require("./assignRef");
+var useRef_1 = require("./useRef");
+var useIsomorphicLayoutEffect = typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect;
+var currentValues = new WeakMap();
+/**
+ * Merges two or more refs together providing a single interface to set their value
+ * @param {RefObject|Ref} refs
+ * @returns {MutableRefObject} - a new ref, which translates all changes to {refs}
+ *
+ * @see {@link mergeRefs} a version without buit-in memoization
+ * @see https://github.com/theKashey/use-callback-ref#usemergerefs
+ * @example
+ * const Component = React.forwardRef((props, ref) => {
+ *   const ownRef = useRef();
+ *   const domRef = useMergeRefs([ref, ownRef]); // 👈 merge together
+ *   return <div ref={domRef}>...</div>
+ * }
+ */
+function useMergeRefs(refs, defaultValue) {
+    var callbackRef = (0, useRef_1.useCallbackRef)(defaultValue || null, function (newValue) {
+        return refs.forEach(function (ref) { return (0, assignRef_1.assignRef)(ref, newValue); });
+    });
+    // handle refs changes - added or removed
+    useIsomorphicLayoutEffect(function () {
+        var oldValue = currentValues.get(callbackRef);
+        if (oldValue) {
+            var prevRefs_1 = new Set(oldValue);
+            var nextRefs_1 = new Set(refs);
+            var current_1 = callbackRef.current;
+            prevRefs_1.forEach(function (ref) {
+                if (!nextRefs_1.has(ref)) {
+                    (0, assignRef_1.assignRef)(ref, null);
+                }
+            });
+            nextRefs_1.forEach(function (ref) {
+                if (!prevRefs_1.has(ref)) {
+                    (0, assignRef_1.assignRef)(ref, current_1);
+                }
+            });
+        }
+        currentValues.set(callbackRef, refs);
+    }, [refs]);
+    return callbackRef;
+}
+exports.useMergeRefs = useMergeRefs;

node_modules/use-callback-ref/dist/es5/useRef.d.ts

@@ -0,0 +1,16 @@
+import { MutableRefObject } from 'react';
+/**
+ * creates a MutableRef with ref change callback
+ * @param initialValue - initial ref value
+ * @param {Function} callback - a callback to run when value changes
+ *
+ * @example
+ * const ref = useCallbackRef(0, (newValue, oldValue) => console.log(oldValue, '->', newValue);
+ * ref.current = 1;
+ * // prints 0 -> 1
+ *
+ * @see https://reactjs.org/docs/hooks-reference.html#useref
+ * @see https://github.com/theKashey/use-callback-ref#usecallbackref---to-replace-reactuseref
+ * @returns {MutableRefObject}
+ */
+export declare function useCallbackRef<T>(initialValue: T | null, callback: (newValue: T | null, lastValue: T | null) => void): MutableRefObject<T | null>;

node_modules/use-callback-ref/dist/es5/useRef.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCallbackRef = void 0;
+var react_1 = require("react");
+/**
+ * creates a MutableRef with ref change callback
+ * @param initialValue - initial ref value
+ * @param {Function} callback - a callback to run when value changes
+ *
+ * @example
+ * const ref = useCallbackRef(0, (newValue, oldValue) => console.log(oldValue, '->', newValue);
+ * ref.current = 1;
+ * // prints 0 -> 1
+ *
+ * @see https://reactjs.org/docs/hooks-reference.html#useref
+ * @see https://github.com/theKashey/use-callback-ref#usecallbackref---to-replace-reactuseref
+ * @returns {MutableRefObject}
+ */
+function useCallbackRef(initialValue, callback) {
+    var ref = (0, react_1.useState)(function () { return ({
+        // value
+        value: initialValue,
+        // last callback
+        callback: callback,
+        // "memoized" public interface
+        facade: {
+            get current() {
+                return ref.value;
+            },
+            set current(value) {
+                var last = ref.value;
+                if (last !== value) {
+                    ref.value = value;
+                    ref.callback(value, last);
+                }
+            },
+        },
+    }); })[0];
+    // update callback
+    ref.callback = callback;
+    return ref.facade;
+}
+exports.useCallbackRef = useCallbackRef;

node_modules/use-callback-ref/dist/es5/useTransformRef.d.ts

@@ -0,0 +1,15 @@
+import { ReactRef, RefObject } from './types';
+/**
+ * Create a _lense_ on Ref, making it possible to transform ref value
+ * @param {ReactRef} ref
+ * @param {Function} transformer. 👉 Ref would be __NOT updated__ on `transformer` update.
+ * @returns {RefObject}
+ *
+ * @see https://github.com/theKashey/use-callback-ref#usetransformref-to-replace-reactuseimperativehandle
+ * @example
+ *
+ * const ResizableWithRef = forwardRef((props, ref) =>
+ *  <Resizable {...props} ref={useTransformRef(ref, i => i ? i.resizable : null)}/>
+ * );
+ */
+export declare function useTransformRef<T, K>(ref: ReactRef<K>, transformer: (original: T | null) => K): RefObject<T>;

node_modules/use-callback-ref/dist/es5/useTransformRef.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTransformRef = void 0;
+var assignRef_1 = require("./assignRef");
+var useRef_1 = require("./useRef");
+/**
+ * Create a _lense_ on Ref, making it possible to transform ref value
+ * @param {ReactRef} ref
+ * @param {Function} transformer. 👉 Ref would be __NOT updated__ on `transformer` update.
+ * @returns {RefObject}
+ *
+ * @see https://github.com/theKashey/use-callback-ref#usetransformref-to-replace-reactuseimperativehandle
+ * @example
+ *
+ * const ResizableWithRef = forwardRef((props, ref) =>
+ *  <Resizable {...props} ref={useTransformRef(ref, i => i ? i.resizable : null)}/>
+ * );
+ */
+function useTransformRef(ref, transformer) {
+    return (0, useRef_1.useCallbackRef)(null, function (value) { return (0, assignRef_1.assignRef)(ref, transformer(value)); });
+}
+exports.useTransformRef = useTransformRef;