init 3

node_modules/use-callback-ref/dist/es2015/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/es2015/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/es2019/createRef.js

@@ -0,0 +1,23 @@
+/**
+ * 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 function createCallbackRef(callback) {
+    let current = null;
+    return {
+        get current() {
+            return current;
+        },
+        set current(value) {
+            const last = current;
+            if (last !== value) {
+                current = value;
+                callback(value, last);
+            }
+        },
+    };
+}

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

@@ -0,0 +1,18 @@
+import { assignRef } from './assignRef';
+import { createCallbackRef } from './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>
+ * }
+ */
+export function mergeRefs(refs) {
+    return createCallbackRef((newValue) => refs.forEach((ref) => assignRef(ref, newValue)));
+}

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

@@ -0,0 +1,14 @@
+import { assignRef } from './assignRef';
+import { createCallbackRef } from './createRef';
+/**
+ * Transforms one ref to another
+ * @example
+ * ```tsx
+ * const ResizableWithRef = forwardRef((props, ref) =>
+ *   <Resizable {...props} ref={transformRef(ref, i => i ? i.resizable : null)}/>
+ * );
+ * ```
+ */
+export function transformRef(ref, transformer) {
+    return createCallbackRef((value) => assignRef(ref, transformer(value)));
+}

node_modules/use-callback-ref/dist/es2019/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/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/types.js

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