🏹 Adds a withTarget helper

For dealing with getting event targets

Author: himynameisdave

src/helpers/__tests__/with-target.spec.ts

@@ -0,0 +1,15 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+import withTarget from '../with-target';
+import { EventType, $TSFixMe } from '../../index.d';
+
+
+describe('withTarget', () => {
+    it('calls the provided method with event.target (if it exists)', () => {
+        const mockEvent: EventType | $TSFixMe = {
+            target: 'mockEvent',
+        };
+        const mock = jest.fn();
+        withTarget(mock)(mockEvent);
+        expect(mock).toHaveBeenCalledWith(mockEvent);
+    });
+});

src/helpers/noop.ts

@@ -0,0 +1,6 @@
+/**
+ * No-operation
+ */
+const noop = (): void => {};
+
+export default noop;

src/helpers/with-event-factory.ts

@@ -1,4 +1,5 @@
 import callIfExists from './call-if-exists';
+import noop from './noop';
 import { EventType, EventHandler, UserEventHandler } from '../index.d';
 
 export type TWithEventFactory = (method: string) => UserEventHandler;
@@ -9,7 +10,7 @@ export type TWithEventFactory = (method: string) => UserEventHandler;
  *  @param {Function} method - the event method which you want to call
  *  @return {Function} - function which accepts the consumer's event handler function and returns the final event handler function
  */
-const withEventFactory: TWithEventFactory = (method: string = ''): UserEventHandler => (fn: EventHandler): EventHandler => (event: EventType): void => {
+const withEventFactory: TWithEventFactory = (method: string = ''): UserEventHandler => (fn: EventHandler = noop): EventHandler => (event: EventType = {} as any): void => {
     callIfExists(method)(event);
     return fn(event);
 };

src/helpers/with-target.ts

@@ -0,0 +1,18 @@
+import { EventType, EventHandler, $TSFixMe } from '../index.d';
+import noop from './noop';
+
+
+export type TEventTarget = EventTarget | HTMLInputElement | $TSFixMe;
+export type TWithTargetHandler = (target: TEventTarget, event: EventType) => void;
+export type TWithTarget = (fn: TWithTargetHandler) => EventHandler;
+
+/**
+ * Calls a fn with event.target (if it exists)
+ *
+ * @param fn Function which will be called with event.target (if it exists)
+ */
+const withTarget: TWithTarget = (fn: TWithTargetHandler = noop): EventHandler => (event: EventType = {} as $TSFixMe): void => {
+    return fn(event?.target, event);
+};
+
+export default withTarget;

src/with-keypress.ts

@@ -1,11 +1,12 @@
 import { EventType, EventHandler, UserEventHandler } from './index.d';
+import noop from './helpers/noop';
 
 /**
  * Generic withKeypress generator
  *
  * @param {string} key The key which must be pressed for the fn to be invoked
  */
-const withKeyPress = (key: string): UserEventHandler => (fn: EventHandler): EventHandler => (event: EventType): void => {
+const withKeyPress = (key: string): UserEventHandler => (fn: EventHandler = noop): EventHandler => (event: EventType = {} as any): void => {
     if (event.key === key) {
         return fn(event);
     }

src/with-target-value.ts

@@ -1,18 +1,17 @@
-export type WithTargetValue = (value: string | undefined, event: KeyboardEvent | InputEvent | any) => void;
+import withTarget from './helpers/with-target';
+import noop from './helpers/noop';
+import { EventType, EventHandler } from './index.d';
 
 
+export type TWithTargetValueHandler = (value: string | null, event: EventType) => void;
+
 /**
  *  Accepts a function, who's first argument is event.target.value (if exists),
  *  followed by the full event object.
  *
  *  @param {Function} fn - Consumer's handler function
  *  @return {Function} - event handler function
  */
-const withTargetValue = (fn: WithTargetValue) => (event: InputEvent | any) => {
-    if (!event || !event.target) {
-        return fn(undefined, event);
-    }
-    return fn(event.target.value, event);
-};
+const withTargetValue = (fn: TWithTargetValueHandler = noop): EventHandler => withTarget((target, event): void => fn(target?.value, event));
 
 export default withTargetValue;