update linting

Author: theKashey

src/assignRef.ts

@@ -19,5 +19,6 @@ export function assignRef<T>(ref: ReactRef<T>, value: T | null): ReactRef<T> {
   } else if (ref) {
     ref.current = value;
   }
+
   return ref;
 }

src/createRef.ts

@@ -8,9 +8,7 @@ import { RefObject } from 'react';
  * @see {@link useCallbackRef}
  * @see https://reactjs.org/docs/refs-and-the-dom.html#creating-refs
  */
-export function createCallbackRef<T>(
-  callback: (newValue: T | null, lastValue: T | null) => any
-): RefObject<T> {
+export function createCallbackRef<T>(callback: (newValue: T | null, lastValue: T | null) => any): RefObject<T> {
   let current: T | null = null;
 
   return {
@@ -19,10 +17,11 @@ export function createCallbackRef<T>(
     },
     set current(value: T) {
       const last = current;
+
       if (last !== value) {
         current = value;
         callback(value, last);
       }
-    }
+    },
   };
 }

src/mergeRef.ts

@@ -1,7 +1,8 @@
-import {MutableRefObject} from 'react';
-import {createCallbackRef} from './createRef';
-import {assignRef} from './assignRef';
-import {ReactRef} from './types';
+import { MutableRefObject } from 'react';
+
+import { assignRef } from './assignRef';
+import { createCallbackRef } from './createRef';
+import { ReactRef } from './types';
 
 /**
  * Merges two or more refs together providing a single interface to set their value
@@ -16,10 +17,6 @@ import {ReactRef} from './types';
  *   return <div ref={domRef}>...</div>
  * }
  */
-export function mergeRefs<T>(
-  refs: ReactRef<T>[]
-): MutableRefObject<T | null> {
-  return createCallbackRef<T>(newValue =>
-    refs.forEach(ref => assignRef(ref, newValue))
-  );
+export function mergeRefs<T>(refs: ReactRef<T>[]): MutableRefObject<T | null> {
+  return createCallbackRef<T>((newValue) => refs.forEach((ref) => assignRef(ref, newValue)));
 }

src/refToCallback.ts

@@ -1,12 +1,12 @@
-import {ReactRef, RefCallback} from './types';
+import { ReactRef, RefCallback } from './types';
 
 /**
  * Unmemoized version of {@link useRefToCallback}
  * @see {@link useRefToCallback}
  * @param ref
  */
 export function refToCallback<T>(ref: ReactRef<T>): RefCallback<T> {
-  return newValue => {
+  return (newValue) => {
     if (typeof ref === 'function') {
       ref(newValue);
     } else if (ref) {
@@ -19,13 +19,17 @@ const nullCallback = (): any => null;
 // lets maintain a weak ref to, well, ref :)
 // not using `kashe` to keep this package small
 const weakMem = new WeakMap<ReactRef<any>, RefCallback<any>>();
+
 const weakMemoize = (ref: ReactRef<any>) => {
   const usedRef = ref || nullCallback;
+
   if (weakMem.has(usedRef)) {
     return weakMem.get(usedRef);
   }
+
   const cb = refToCallback(usedRef);
   weakMem.set(usedRef, cb);
+
   return cb;
 };
 

src/transformRef.ts

@@ -1,10 +1,7 @@
-import { ReactRef, RefObject } from './types';
 import { assignRef } from './assignRef';
 import { createCallbackRef } from './createRef';
+import { ReactRef, RefObject } from './types';
 
-export function transformRef<T, K>(
-  ref: ReactRef<K>,
-  transformer: (original: T) => K
-): RefObject<T> {
-  return createCallbackRef<T>(value => assignRef(ref, transformer(value)));
+export function transformRef<T, K>(ref: ReactRef<K>, transformer: (original: T) => K): RefObject<T> {
+  return createCallbackRef<T>((value) => assignRef(ref, transformer(value)));
 }

src/useMergeRef.ts

@@ -1,7 +1,8 @@
 import * as React from 'react';
-import { useCallbackRef } from './useRef';
+
 import { assignRef } from './assignRef';
 import { ReactRef } from './types';
+import { useCallbackRef } from './useRef';
 
 /**
  * Merges two or more refs together providing a single interface to set their value
@@ -17,11 +18,6 @@ import { ReactRef } from './types';
  *   return <div ref={domRef}>...</div>
  * }
  */
-export function useMergeRefs<T>(
-  refs: ReactRef<T>[],
-  defaultValue?: T
-): React.MutableRefObject<T | null> {
-  return useCallbackRef<T>(defaultValue, newValue =>
-    refs.forEach(ref => assignRef(ref, newValue))
-  );
+export function useMergeRefs<T>(refs: ReactRef<T>[], defaultValue?: T): React.MutableRefObject<T | null> {
+  return useCallbackRef<T>(defaultValue, (newValue) => refs.forEach((ref) => assignRef(ref, newValue)));
 }

src/useRef.ts

@@ -30,12 +30,13 @@ export function useCallbackRef<T>(
       },
       set current(value) {
         const last = ref.value;
+
         if (last !== value) {
           ref.value = value;
           ref.callback(value, last);
         }
-      }
-    }
+      },
+    },
   }));
   // update callback
   ref.callback = callback;

src/useTransformRef.ts

@@ -1,6 +1,6 @@
+import { assignRef } from './assignRef';
 import { ReactRef, RefObject } from './types';
 import { useCallbackRef } from './useRef';
-import { assignRef } from './assignRef';
 
 /**
  * Create a _lense_ on Ref, making it possible to transform ref value
@@ -15,11 +15,6 @@ import { assignRef } from './assignRef';
  *  <Resizable {...props} ref={useTransformRef(ref, i => i ? i.resizable : null)}/>
  * );
  */
-export function useTransformRef<T, K>(
-  ref: ReactRef<K>,
-  transformer: (original: T) => K
-): RefObject<T> {
-  return useCallbackRef<T>(undefined, value =>
-    assignRef(ref, transformer(value))
-  );
+export function useTransformRef<T, K>(ref: ReactRef<K>, transformer: (original: T) => K): RefObject<T> {
+  return useCallbackRef<T>(undefined, (value) => assignRef(ref, transformer(value)));
 }