Latest repo

node_modules/make-event-props/dist/esm/index.d.ts

@@ -0,0 +1,37 @@
+export declare const clipboardEvents: readonly ["onCopy", "onCut", "onPaste"];
+export declare const compositionEvents: readonly ["onCompositionEnd", "onCompositionStart", "onCompositionUpdate"];
+export declare const focusEvents: readonly ["onFocus", "onBlur"];
+export declare const formEvents: readonly ["onInput", "onInvalid", "onReset", "onSubmit"];
+export declare const imageEvents: readonly ["onLoad", "onError"];
+export declare const keyboardEvents: readonly ["onKeyDown", "onKeyPress", "onKeyUp"];
+export declare const mediaEvents: readonly ["onAbort", "onCanPlay", "onCanPlayThrough", "onDurationChange", "onEmptied", "onEncrypted", "onEnded", "onError", "onLoadedData", "onLoadedMetadata", "onLoadStart", "onPause", "onPlay", "onPlaying", "onProgress", "onRateChange", "onSeeked", "onSeeking", "onStalled", "onSuspend", "onTimeUpdate", "onVolumeChange", "onWaiting"];
+export declare const mouseEvents: readonly ["onClick", "onContextMenu", "onDoubleClick", "onMouseDown", "onMouseEnter", "onMouseLeave", "onMouseMove", "onMouseOut", "onMouseOver", "onMouseUp"];
+export declare const dragEvents: readonly ["onDrag", "onDragEnd", "onDragEnter", "onDragExit", "onDragLeave", "onDragOver", "onDragStart", "onDrop"];
+export declare const selectionEvents: readonly ["onSelect"];
+export declare const touchEvents: readonly ["onTouchCancel", "onTouchEnd", "onTouchMove", "onTouchStart"];
+export declare const pointerEvents: readonly ["onPointerDown", "onPointerMove", "onPointerUp", "onPointerCancel", "onGotPointerCapture", "onLostPointerCapture", "onPointerEnter", "onPointerLeave", "onPointerOver", "onPointerOut"];
+export declare const uiEvents: readonly ["onScroll"];
+export declare const wheelEvents: readonly ["onWheel"];
+export declare const animationEvents: readonly ["onAnimationStart", "onAnimationEnd", "onAnimationIteration"];
+export declare const transitionEvents: readonly ["onTransitionEnd"];
+export declare const otherEvents: readonly ["onToggle"];
+export declare const changeEvents: readonly ["onChange"];
+export declare const allEvents: readonly ["onCopy", "onCut", "onPaste", "onCompositionEnd", "onCompositionStart", "onCompositionUpdate", "onFocus", "onBlur", "onInput", "onInvalid", "onReset", "onSubmit", "onLoad", "onError", "onKeyDown", "onKeyPress", "onKeyUp", "onAbort", "onCanPlay", "onCanPlayThrough", "onDurationChange", "onEmptied", "onEncrypted", "onEnded", "onError", "onLoadedData", "onLoadedMetadata", "onLoadStart", "onPause", "onPlay", "onPlaying", "onProgress", "onRateChange", "onSeeked", "onSeeking", "onStalled", "onSuspend", "onTimeUpdate", "onVolumeChange", "onWaiting", "onClick", "onContextMenu", "onDoubleClick", "onMouseDown", "onMouseEnter", "onMouseLeave", "onMouseMove", "onMouseOut", "onMouseOver", "onMouseUp", "onDrag", "onDragEnd", "onDragEnter", "onDragExit", "onDragLeave", "onDragOver", "onDragStart", "onDrop", "onSelect", "onTouchCancel", "onTouchEnd", "onTouchMove", "onTouchStart", "onPointerDown", "onPointerMove", "onPointerUp", "onPointerCancel", "onGotPointerCapture", "onLostPointerCapture", "onPointerEnter", "onPointerLeave", "onPointerOver", "onPointerOut", "onScroll", "onWheel", "onAnimationStart", "onAnimationEnd", "onAnimationIteration", "onTransitionEnd", "onChange", "onToggle"];
+type AllEvents = (typeof allEvents)[number];
+type EventHandler<ArgsType> = (event: any, args: ArgsType) => void;
+type EventHandlerWithoutArgs<ArgsType, OriginalEventHandler> = OriginalEventHandler extends (event: infer Event, args: ArgsType) => void ? (event: Event) => void : never;
+export type EventProps<ArgsType> = {
+    [K in AllEvents]?: EventHandler<ArgsType>;
+};
+type Props<ArgsType> = Record<string, unknown> & EventProps<ArgsType>;
+type EventPropsWithoutArgs<ArgsType, PropsType> = {
+    [K in keyof PropsType as K extends AllEvents ? K : never]: EventHandlerWithoutArgs<ArgsType, PropsType[K]>;
+};
+/**
+ * Returns an object with on-event callback props curried with provided args.
+ * @param {Object} props Props passed to a component.
+ * @param {Function=} getArgs A function that returns argument(s) on-event callbacks
+ *   shall be curried with.
+ */
+export default function makeEventProps<ArgsType, PropsType extends Props<ArgsType> = Props<ArgsType>>(props: PropsType, getArgs?: (eventName: string) => ArgsType): EventPropsWithoutArgs<ArgsType, PropsType>;
+export {};

node_modules/make-event-props/dist/esm/index.js

@@ -0,0 +1,116 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+// As defined on the list of supported events: https://reactjs.org/docs/events.html
+export var clipboardEvents = ['onCopy', 'onCut', 'onPaste'];
+export var compositionEvents = [
+    'onCompositionEnd',
+    'onCompositionStart',
+    'onCompositionUpdate',
+];
+export var focusEvents = ['onFocus', 'onBlur'];
+export var formEvents = ['onInput', 'onInvalid', 'onReset', 'onSubmit'];
+export var imageEvents = ['onLoad', 'onError'];
+export var keyboardEvents = ['onKeyDown', 'onKeyPress', 'onKeyUp'];
+export var mediaEvents = [
+    'onAbort',
+    'onCanPlay',
+    'onCanPlayThrough',
+    'onDurationChange',
+    'onEmptied',
+    'onEncrypted',
+    'onEnded',
+    'onError',
+    'onLoadedData',
+    'onLoadedMetadata',
+    'onLoadStart',
+    'onPause',
+    'onPlay',
+    'onPlaying',
+    'onProgress',
+    'onRateChange',
+    'onSeeked',
+    'onSeeking',
+    'onStalled',
+    'onSuspend',
+    'onTimeUpdate',
+    'onVolumeChange',
+    'onWaiting',
+];
+export var mouseEvents = [
+    'onClick',
+    'onContextMenu',
+    'onDoubleClick',
+    'onMouseDown',
+    'onMouseEnter',
+    'onMouseLeave',
+    'onMouseMove',
+    'onMouseOut',
+    'onMouseOver',
+    'onMouseUp',
+];
+export var dragEvents = [
+    'onDrag',
+    'onDragEnd',
+    'onDragEnter',
+    'onDragExit',
+    'onDragLeave',
+    'onDragOver',
+    'onDragStart',
+    'onDrop',
+];
+export var selectionEvents = ['onSelect'];
+export var touchEvents = ['onTouchCancel', 'onTouchEnd', 'onTouchMove', 'onTouchStart'];
+export var pointerEvents = [
+    'onPointerDown',
+    'onPointerMove',
+    'onPointerUp',
+    'onPointerCancel',
+    'onGotPointerCapture',
+    'onLostPointerCapture',
+    'onPointerEnter',
+    'onPointerLeave',
+    'onPointerOver',
+    'onPointerOut',
+];
+export var uiEvents = ['onScroll'];
+export var wheelEvents = ['onWheel'];
+export var animationEvents = [
+    'onAnimationStart',
+    'onAnimationEnd',
+    'onAnimationIteration',
+];
+export var transitionEvents = ['onTransitionEnd'];
+export var otherEvents = ['onToggle'];
+export var changeEvents = ['onChange'];
+export var allEvents = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], clipboardEvents, true), compositionEvents, true), focusEvents, true), formEvents, true), imageEvents, true), keyboardEvents, true), mediaEvents, true), mouseEvents, true), dragEvents, true), selectionEvents, true), touchEvents, true), pointerEvents, true), uiEvents, true), wheelEvents, true), animationEvents, true), transitionEvents, true), changeEvents, true), otherEvents, true);
+/**
+ * Returns an object with on-event callback props curried with provided args.
+ * @param {Object} props Props passed to a component.
+ * @param {Function=} getArgs A function that returns argument(s) on-event callbacks
+ *   shall be curried with.
+ */
+export default function makeEventProps(props, getArgs) {
+    var eventProps = {};
+    allEvents.forEach(function (eventName) {
+        var eventHandler = props[eventName];
+        if (!eventHandler) {
+            return;
+        }
+        if (getArgs) {
+            eventProps[eventName] = (function (event) {
+                return eventHandler(event, getArgs(eventName));
+            });
+        }
+        else {
+            eventProps[eventName] = eventHandler;
+        }
+    });
+    return eventProps;
+}

node_modules/make-event-props/dist/esm/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/make-event-props/dist/esm/index.spec.js

@@ -0,0 +1,199 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from 'vitest';
+import React from 'react';
+import makeEventProps, { allEvents } from './index.js';
+describe('makeEventProps()', function () {
+    var fakeEvent = {};
+    it('returns object with valid and only valid event callbacks', function () {
+        var props = {
+            onClick: vi.fn(),
+            someInvalidProp: vi.fn(),
+        };
+        var result = makeEventProps(props);
+        expect(result).toMatchObject({ onClick: expect.any(Function) });
+    });
+    it('calls getArgs function on event invoke if given', function () {
+        var props = {
+            onClick: vi.fn(),
+            someInvalidProp: vi.fn(),
+        };
+        var getArgs = vi.fn();
+        var result = makeEventProps(props, getArgs);
+        // getArgs shall not be invoked before a given event is fired
+        expect(getArgs).not.toHaveBeenCalled();
+        result.onClick(fakeEvent);
+        expect(getArgs).toHaveBeenCalledTimes(1);
+        expect(getArgs).toHaveBeenCalledWith('onClick');
+    });
+    it('properly calls callbacks given in props given no getArgs function', function () {
+        var props = {
+            onClick: vi.fn(),
+        };
+        var result = makeEventProps(props);
+        result.onClick(fakeEvent);
+        expect(props.onClick).toHaveBeenCalledWith(fakeEvent);
+    });
+    it('properly calls callbacks given in props given getArgs function', function () {
+        var props = {
+            onClick: vi.fn(),
+        };
+        var getArgs = vi.fn();
+        var args = {};
+        getArgs.mockReturnValue(args);
+        var result = makeEventProps(props, getArgs);
+        result.onClick(fakeEvent);
+        expect(props.onClick).toHaveBeenCalledWith(fakeEvent, args);
+    });
+    it('should not filter out valid event props', function () {
+        var props = {
+            onClick: vi.fn(),
+        };
+        var result = makeEventProps(props);
+        // @ts-expect-no-error
+        result.onClick;
+    });
+    it('should filter out invalid event props', function () {
+        var props = {
+            someInvalidProp: vi.fn(),
+        };
+        var result = makeEventProps(props);
+        // @ts-expect-error-next-line
+        result.someInvalidProp;
+    });
+    it('should allow valid onClick handler to be passed', function () {
+        var props = {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            onClick: function (event) {
+                // Intentionally empty
+            },
+        };
+        // @ts-expect-no-error
+        makeEventProps(props);
+    });
+    it('should not allow invalid onClick handler to be passed', function () {
+        var props = {
+            onClick: 'potato',
+        };
+        // @ts-expect-error-next-line
+        makeEventProps(props);
+    });
+    it('should allow onClick handler with extra args to be passed if getArgs is provided', function () {
+        var props = {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            onClick: function (event, args) {
+                // Intentionally empty
+            },
+        };
+        // @ts-expect-no-error
+        makeEventProps(props, function () { return 'hello'; });
+    });
+    it('should not allow onClick handler with extra args to be passed if getArgs is not provided', function () {
+        var props = {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            onClick: function (event, args) {
+                // Intentionally empty
+            },
+        };
+        // @ts-expect-error-next-line
+        makeEventProps(props);
+    });
+    it('should not allow onClick handler with extra args to be passed if getArgs is provided but returns different type', function () {
+        var props = {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            onClick: function (event, args) {
+                // Intentionally empty
+            },
+        };
+        // @ts-expect-error-next-line
+        makeEventProps(props, function () { return 5; });
+    });
+    it('should allow div onClick handler to be passed to div', function () {
+        var props = {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            onClick: function (event) {
+                // Intentionally empty
+            },
+        };
+        var result = makeEventProps(props);
+        // @ts-expect-no-error
+        _jsx("div", { onClick: result.onClick });
+    });
+    it('should not allow div onClick handler to be passed to button', function () {
+        var props = {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            onClick: function (event) {
+                // Intentionally empty
+            },
+        };
+        var result = makeEventProps(props);
+        // @ts-expect-error-next-line
+        _jsx("button", { onClick: result.onClick });
+    });
+    it('should allow div onClick handler with extra args to be passed to div if getArgs is provided', function () {
+        var props = {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            onClick: function (event, args) {
+                // Intentionally empty
+            },
+        };
+        var result = makeEventProps(props, function () { return 'hello'; });
+        // @ts-expect-no-error
+        _jsx("div", { onClick: result.onClick });
+    });
+    it('should not allow div onClick handler with extra args to be passed to button if getArgs is provided', function () {
+        var props = {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            onClick: function (event, args) {
+                // Intentionally empty
+            },
+        };
+        var result = makeEventProps(props, function () { return 'hello'; });
+        // @ts-expect-error-next-line
+        _jsx("button", { onClick: result.onClick });
+    });
+    it('should allow onClick handler with valid extra args to be passed with args explicitly typed', function () {
+        var props = {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            onClick: function (event, args) {
+                // Intentionally empty
+            },
+        };
+        // @ts-expect-no-error
+        makeEventProps(props, function () { return 'hello'; });
+    });
+    it('should not allow onClick handler with invalid extra args to be passed with args explicitly typed', function () {
+        var props = {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            onClick: function (event, args) {
+                // Intentionally empty
+            },
+        };
+        // @ts-expect-error-next-line
+        makeEventProps(props, function () { return 'hello'; });
+    });
+    it('should allow getArgs returning valid type to be passed with args explicitly typed', function () {
+        var props = {};
+        // @ts-expect-no-error
+        makeEventProps(props, function () { return 'hello'; });
+    });
+    it('should not allow getArgs returning invalid type to be passed with args explicitly typed', function () {
+        var props = {};
+        // @ts-expect-error-next-line
+        makeEventProps(props, function () { return 5; });
+    });
+});
+describe('allEvents', function () {
+    it('should contain all events', function () {
+        var sortedAllEvents = new Set(__spreadArray([], allEvents, true).sort());
+        expect(sortedAllEvents).toMatchSnapshot();
+    });
+});