@alcadur/react-events-hook 1.2.0 → 1.4.0

package/build/actions/clear-memo.d.ts

@@ -0,0 +1,2 @@
+import { EventNameType } from "../events.model";
+export declare const clearMemo: (key: EventNameType) => void;

package/build/actions/clear-memo.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearMemo = void 0;
+var shared_events_1 = require("../shared-events");
+var clearMemo = function (key) {
+    shared_events_1.lastEmittedValues[key] = undefined;
+    delete shared_events_1.lastEmittedValues[key];
+};
+exports.clearMemo = clearMemo;

package/build/actions/emit-event.d.ts

@@ -0,0 +1,5 @@
+import { EventNameType } from "../events.model";
+export declare function emitEvent(event: EventNameType, ...args: any[]): void;
+export declare namespace emitEvent {
+    var memo: (event: EventNameType, ...args: any[]) => void;
+}

package/build/actions/emit-event.js

@@ -0,0 +1,45 @@
+"use strict";
+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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitEvent = emitEvent;
+var shared_events_1 = require("../shared-events");
+var clear_memo_1 = require("./clear-memo");
+function emitter(event) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    var callbacks = shared_events_1.sharedEvents[event];
+    if (!callbacks) {
+        return;
+    }
+    callbacks.forEach(function (callback) { return callback.apply(void 0, args); });
+}
+function emitEvent(event) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    emitter.apply(void 0, __spreadArray([event], args, false));
+}
+if (!emitEvent.memo) {
+    emitEvent.memo = function (event) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        shared_events_1.lastEmittedValues[event] = args;
+        if (args.length === 1 && args[0] === undefined) {
+            (0, clear_memo_1.clearMemo)(event);
+        }
+        emitter.apply(void 0, __spreadArray([event], args, false));
+    };
+}

package/build/actions/index.d.ts

@@ -0,0 +1,4 @@
+export * from './emit-event';
+export * from './on-event';
+export * from './remove-event';
+export * from './clear-memo';

package/build/actions/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./emit-event"), exports);
+__exportStar(require("./on-event"), exports);
+__exportStar(require("./remove-event"), exports);
+__exportStar(require("./clear-memo"), exports);

package/build/actions/index.test.d.ts

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

package/build/actions/index.test.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var vitest_1 = require("vitest");
+var shared_events_1 = require("../shared-events");
+var emit_event_1 = require("./emit-event");
+var on_event_1 = require("./on-event");
+var remove_event_1 = require("./remove-event");
+var clear_memo_1 = require("./clear-memo");
+(0, vitest_1.describe)("actions", function () {
+    (0, vitest_1.beforeEach)(function () {
+        Object.keys(shared_events_1.sharedEvents).forEach(function (key) { return delete shared_events_1.sharedEvents[key]; });
+        Object.keys(shared_events_1.lastEmittedValues).forEach(function (key) { return delete shared_events_1.lastEmittedValues[key]; });
+    });
+    (0, vitest_1.describe)("onEvent", function () {
+        (0, vitest_1.it)("registers a single callback", function () {
+            var callback = vitest_1.vi.fn();
+            (0, on_event_1.onEvent)("test-event", callback);
+            (0, vitest_1.expect)(shared_events_1.sharedEvents["test-event"]).toEqual([callback]);
+        });
+        (0, vitest_1.it)("registers an array of callbacks", function () {
+            var callback1 = vitest_1.vi.fn();
+            var callback2 = vitest_1.vi.fn();
+            (0, on_event_1.onEvent)("test-event", [callback1, callback2]);
+            (0, vitest_1.expect)(shared_events_1.sharedEvents["test-event"]).toEqual([callback1, callback2]);
+        });
+    });
+    (0, vitest_1.describe)("emitEvent", function () {
+        (0, vitest_1.it)("invokes all callbacks with provided args", function () {
+            var callback1 = vitest_1.vi.fn();
+            var callback2 = vitest_1.vi.fn();
+            (0, on_event_1.onEvent)("test-event", [callback1, callback2]);
+            (0, emit_event_1.emitEvent)("test-event", "data", 1);
+            (0, vitest_1.expect)(callback1).toHaveBeenCalledWith("data", 1);
+            (0, vitest_1.expect)(callback2).toHaveBeenCalledWith("data", 1);
+        });
+        (0, vitest_1.it)("does nothing when event has no callbacks", function () {
+            (0, vitest_1.expect)(function () { return (0, emit_event_1.emitEvent)("missing-event", "data"); }).not.toThrow();
+        });
+        (0, vitest_1.describe)("memo", function () {
+            (0, vitest_1.it)("invokes all callback and stores the value", function () {
+                var callback = vitest_1.vi.fn();
+                (0, on_event_1.onEvent)("memo-event", callback);
+                emit_event_1.emitEvent.memo("memo-event", "memo-data");
+                (0, vitest_1.expect)(callback).toHaveBeenCalledWith("memo-data");
+                (0, vitest_1.expect)(shared_events_1.lastEmittedValues["memo-event"]).toEqual(["memo-data"]);
+            });
+            (0, vitest_1.it)("triggers callback immediately if event was already memoized", function () {
+                var callback = vitest_1.vi.fn();
+                emit_event_1.emitEvent.memo("memo-event", "old-data");
+                (0, on_event_1.onEvent)("memo-event", callback);
+                (0, vitest_1.expect)(callback).toHaveBeenCalledWith("old-data");
+            });
+            (0, vitest_1.it)("clears memoized value when emitEvent.memo is called with undefined", function () {
+                var callback = vitest_1.vi.fn();
+                (0, on_event_1.onEvent)("memo-event", callback);
+                emit_event_1.emitEvent.memo("memo-event", "some-data");
+                (0, vitest_1.expect)(shared_events_1.lastEmittedValues["memo-event"]).toEqual(["some-data"]);
+                (0, vitest_1.expect)(callback).toHaveBeenCalledWith("some-data");
+                emit_event_1.emitEvent.memo("memo-event", undefined);
+                (0, vitest_1.expect)(shared_events_1.lastEmittedValues["memo-event"]).toBeUndefined();
+                (0, vitest_1.expect)(callback).toHaveBeenCalledWith(undefined);
+            });
+            (0, vitest_1.it)("should not trigger callback immediately when last emitted value is undefined", function () {
+                var callback = vitest_1.vi.fn();
+                var callback2 = vitest_1.vi.fn();
+                emit_event_1.emitEvent.memo("memo-event", "some-data");
+                (0, on_event_1.onEvent)("memo-event", callback);
+                (0, vitest_1.expect)(callback).toHaveBeenCalledWith("some-data");
+                emit_event_1.emitEvent.memo("memo-event", undefined);
+                (0, on_event_1.onEvent)("memo-event", callback2);
+                (0, vitest_1.expect)(callback).toHaveBeenCalledWith(undefined);
+                (0, vitest_1.expect)(callback2).not.toHaveBeenCalled();
+            });
+        });
+    });
+    (0, vitest_1.describe)("clearMemo", function () {
+        (0, vitest_1.it)("removes the memoized value for a given event", function () {
+            emit_event_1.emitEvent.memo("test-event", "data");
+            (0, vitest_1.expect)(shared_events_1.lastEmittedValues["test-event"]).toEqual(["data"]);
+            (0, clear_memo_1.clearMemo)("test-event");
+            (0, vitest_1.expect)(shared_events_1.lastEmittedValues["test-event"]).toBeUndefined();
+        });
+        (0, vitest_1.it)("does not trigger callbacks", function () {
+            var callback = vitest_1.vi.fn();
+            (0, on_event_1.onEvent)("test-event", callback);
+            emit_event_1.emitEvent.memo("test-event", "data");
+            callback.mockClear();
+            (0, clear_memo_1.clearMemo)("test-event");
+            (0, vitest_1.expect)(callback).not.toHaveBeenCalled();
+        });
+    });
+    (0, vitest_1.describe)("removeEvent", function () {
+        (0, vitest_1.it)("removes a single callback", function () {
+            var callback = vitest_1.vi.fn();
+            (0, on_event_1.onEvent)("test-event", callback);
+            (0, remove_event_1.removeEvent)("test-event", callback);
+            (0, emit_event_1.emitEvent)("test-event", "data");
+            (0, vitest_1.expect)(callback).not.toHaveBeenCalled();
+        });
+        (0, vitest_1.it)("removes multiple callbacks from array input", function () {
+            var callback1 = vitest_1.vi.fn();
+            var callback2 = vitest_1.vi.fn();
+            (0, on_event_1.onEvent)("test-event", [callback1, callback2]);
+            (0, remove_event_1.removeEvent)("test-event", [callback1, callback2]);
+            (0, emit_event_1.emitEvent)("test-event", "data");
+            (0, vitest_1.expect)(callback1).not.toHaveBeenCalled();
+            (0, vitest_1.expect)(callback2).not.toHaveBeenCalled();
+        });
+        (0, vitest_1.it)("does nothing when event has no callbacks", function () {
+            var callback = vitest_1.vi.fn();
+            (0, vitest_1.expect)(function () { return (0, remove_event_1.removeEvent)("missing-event", callback); }).not.toThrow();
+        });
+    });
+});

package/build/actions/on-event.d.ts

@@ -0,0 +1,2 @@
+import { EventCallbackType, EventNameType } from "../events.model";
+export declare function onEvent(event: EventNameType, callback: EventCallbackType[] | EventCallbackType): void;

package/build/actions/on-event.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onEvent = onEvent;
+var shared_events_1 = require("../shared-events");
+var utils_1 = require("../utils");
+function onEvent(event, callback) {
+    var _a;
+    var callbacks = (_a = shared_events_1.sharedEvents[event]) !== null && _a !== void 0 ? _a : [];
+    var newCallbacks = (0, utils_1.getAsArray)(callback);
+    callbacks.push.apply(callbacks, newCallbacks);
+    shared_events_1.sharedEvents[event] = callbacks;
+    if (shared_events_1.lastEmittedValues[event]) {
+        newCallbacks.forEach(function (callback) { return callback.apply(void 0, shared_events_1.lastEmittedValues[event]); });
+    }
+}

package/build/actions/remove-event.d.ts

@@ -0,0 +1,2 @@
+import { EventCallbackType, EventNameType } from "../events.model";
+export declare function removeEvent(event: EventNameType, callback: EventCallbackType | EventCallbackType[]): void;

package/build/actions/remove-event.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeEvent = removeEvent;
+var shared_events_1 = require("../shared-events");
+var utils_1 = require("../utils");
+function removeEvent(event, callback) {
+    var declaredCallbacks = shared_events_1.sharedEvents[event];
+    if (!declaredCallbacks) {
+        return;
+    }
+    (0, utils_1.getAsArray)(callback).forEach(function (cb) {
+        var index = declaredCallbacks.indexOf(cb);
+        if (index !== -1) {
+            declaredCallbacks.splice(index, 1);
+        }
+    });
+}

package/build/events.model.d.ts

@@ -0,0 +1,5 @@
+export type EventNameType = string | number | symbol;
+export type EventCallbackType = ((...args: any[]) => void) | (() => void);
+export type InitEventsType = {
+    [key: EventNameType]: EventCallbackType[] | EventCallbackType;
+};

package/build/events.model.js

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

package/build/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from './useEvents';

package/build/hooks/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./useEvents"), exports);

package/build/hooks/useEvents.d.ts

@@ -0,0 +1,8 @@
+import { InitEventsType } from "../events.model";
+import { emitEvent, onEvent, removeEvent } from "../actions";
+export declare const useEvents: (eventMap?: InitEventsType) => {
+    onEvent: typeof onEvent;
+    emitEvent: typeof emitEvent;
+    removeEvent: typeof removeEvent;
+    clearMemo: (key: import("../events.model").EventNameType) => void;
+};

package/build/hooks/useEvents.js

@@ -0,0 +1,33 @@
+"use strict";
+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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEvents = void 0;
+var react_1 = require("react");
+var actions_1 = require("../actions");
+var useEvents = function (eventMap) {
+    if (eventMap === void 0) { eventMap = {}; }
+    (0, react_1.useEffect)(function () {
+        if (!eventMap) {
+            return;
+        }
+        var events = __spreadArray(__spreadArray([], Object.keys(eventMap), true), Object.getOwnPropertySymbols(eventMap), true);
+        events.forEach(function (event) {
+            (0, actions_1.onEvent)(event, eventMap[event]);
+        });
+        return function () {
+            events.forEach(function (event) {
+                (0, actions_1.removeEvent)(event, eventMap[event]);
+            });
+        };
+    }, [eventMap]);
+    return { onEvent: actions_1.onEvent, emitEvent: actions_1.emitEvent, removeEvent: actions_1.removeEvent, clearMemo: actions_1.clearMemo };
+};
+exports.useEvents = useEvents;

package/build/hooks/useEvents.test.d.ts

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

package/build/hooks/useEvents.test.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = require("@testing-library/react");
+var useEvents_1 = require("./useEvents");
+var vitest_1 = require("vitest");
+var shared_events_1 = require("../shared-events");
+(0, vitest_1.describe)('useEvents', function () {
+    (0, vitest_1.beforeEach)(function () {
+        Object.keys(shared_events_1.sharedEvents).forEach(function (key) { return delete shared_events_1.sharedEvents[key]; });
+        Object.keys(shared_events_1.lastEmittedValues).forEach(function (key) { return delete shared_events_1.lastEmittedValues[key]; });
+    });
+    (0, vitest_1.it)('should register and emit events', function () {
+        var result = (0, react_1.renderHook)(function () { return (0, useEvents_1.useEvents)(); }).result;
+        var callback = vitest_1.vi.fn();
+        (0, react_1.act)(function () {
+            result.current.onEvent('test-event', callback);
+        });
+        (0, react_1.act)(function () {
+            result.current.emitEvent('test-event', 'data');
+        });
+        (0, vitest_1.expect)(callback).toHaveBeenCalledWith('data');
+    });
+    (0, vitest_1.it)('should remove events', function () {
+        var result = (0, react_1.renderHook)(function () { return (0, useEvents_1.useEvents)(); }).result;
+        var callback = vitest_1.vi.fn();
+        (0, react_1.act)(function () {
+            result.current.onEvent('test-event', callback);
+            result.current.removeEvent('test-event', callback);
+        });
+        (0, react_1.act)(function () {
+            result.current.emitEvent('test-event', 'data');
+        });
+        (0, vitest_1.expect)(callback).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('should register events from init map', function () {
+        var callback = vitest_1.vi.fn();
+        var callbackSymbol = vitest_1.vi.fn();
+        var symbolEvent = Symbol('init-event');
+        (0, react_1.renderHook)(function () {
+            var _a;
+            return (0, useEvents_1.useEvents)((_a = {
+                    'init-event': callback
+                },
+                _a[symbolEvent] = callbackSymbol,
+                _a));
+        });
+        var result = (0, react_1.renderHook)(function () { return (0, useEvents_1.useEvents)(); }).result;
+        (0, react_1.act)(function () {
+            result.current.emitEvent('init-event', 'init-data');
+            result.current.emitEvent(symbolEvent);
+        });
+        (0, vitest_1.expect)(callback).toHaveBeenCalledWith('init-data');
+        (0, vitest_1.expect)(callbackSymbol).toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('should support memoized events', function () {
+        var result = (0, react_1.renderHook)(function () { return (0, useEvents_1.useEvents)(); }).result;
+        var callback = vitest_1.vi.fn();
+        (0, react_1.act)(function () {
+            result.current.emitEvent.memo('memo-event', 'memo-data');
+        });
+        (0, react_1.act)(function () {
+            result.current.onEvent('memo-event', callback);
+        });
+        (0, vitest_1.expect)(callback).toHaveBeenCalledWith('memo-data');
+    });
+    (0, vitest_1.it)('should clear memoized events', function () {
+        var result = (0, react_1.renderHook)(function () { return (0, useEvents_1.useEvents)(); }).result;
+        var callback = vitest_1.vi.fn();
+        (0, react_1.act)(function () {
+            result.current.emitEvent.memo('memo-event', 'memo-data');
+        });
+        (0, react_1.act)(function () {
+            result.current.clearMemo('memo-event');
+        });
+        (0, react_1.act)(function () {
+            result.current.onEvent('memo-event', callback);
+        });
+        (0, vitest_1.expect)(callback).not.toHaveBeenCalled();
+    });
+});

package/build/index.d.ts

@@ -0,0 +1,3 @@
+export * from './hooks';
+export * from './utils';
+export * from './actions';

package/build/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hooks"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./actions"), exports);

package/build/setupTests.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/build/setupTests.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("@testing-library/jest-dom");

package/build/shared-events.d.ts

@@ -0,0 +1,7 @@
+import type { EventCallbackType, EventNameType } from "./events.model";
+export declare const sharedEvents: {
+    [key: EventNameType]: EventCallbackType[];
+};
+export declare const lastEmittedValues: {
+    [key: EventNameType]: any;
+};

package/build/shared-events.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lastEmittedValues = exports.sharedEvents = void 0;
+exports.sharedEvents = {};
+exports.lastEmittedValues = {};

package/build/utils.d.ts

@@ -0,0 +1,2 @@
+import { EventCallbackType } from "./events.model";
+export declare function getAsArray(value: EventCallbackType[] | EventCallbackType): EventCallbackType[];

package/build/utils.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAsArray = getAsArray;
+function getAsArray(value) {
+    return Array.isArray(value) ? value : [value];
+}

package/build/utils.test.d.ts

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

package/build/utils.test.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("./utils");
+var vitest_1 = require("vitest");
+(0, vitest_1.describe)('utils', function () {
+    (0, vitest_1.describe)('getAsArray', function () {
+        (0, vitest_1.it)('should return the same array if an array is passed', function () {
+            var arr = [vitest_1.vi.fn()];
+            (0, vitest_1.expect)((0, utils_1.getAsArray)(arr)).toBe(arr);
+        });
+        (0, vitest_1.it)('should wrap a single value in an array', function () {
+            var callback = vitest_1.vi.fn();
+            (0, vitest_1.expect)((0, utils_1.getAsArray)(callback)).toEqual([callback]);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alcadur/react-events-hook",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Helps in easy communication between React components as also with external sources",
   "keywords": [
     "react",
@@ -23,7 +23,7 @@
   "license": "MIT",
   "author": "Alcadur",
   "type": "module",
-  "main": "index.ts",
+  "main": "build/index.js",
   "scripts": {
     "test": "vitest run"
   },

package/src/index.ts

@@ -1,2 +1,3 @@
 export * from './hooks';
 export * from './utils';
+export * from './actions';

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "outDir": "dist",
+    "outDir": "build",
     "jsx": "react",
     "skipLibCheck": true,
     "allowSyntheticDefaultImports": true,