@kuindji/reactive 1.0.14 → 1.0.16

package/dist/action.d.ts

@@ -9,6 +9,7 @@ export type ActionResponse<Response extends any = any, Args extends any[] = any[
     args: Args;
 };
 export type ListenerSignature<ActionSignature extends BaseHandler> = (arg: ActionResponse<Awaited<ReturnType<ActionSignature>>, Parameters<ActionSignature>>) => void;
+export type BeforeActionSignature<ActionSignature extends BaseHandler> = (...args: Parameters<ActionSignature>) => false | void | Promise<false | void>;
 export type ActionDefinitionHelper<A extends BaseHandler> = {
     actionSignature: A;
     actionArguments: Parameters<A>;
@@ -17,6 +18,7 @@ export type ActionDefinitionHelper<A extends BaseHandler> = {
     errorResponseType: ErrorResponse<Parameters<A>>;
     listenerArgument: ActionResponse<Awaited<ReturnType<A>>, Parameters<A>>;
     listenerSignature: ListenerSignature<A>;
+    beforeActionSignature: BeforeActionSignature<A>;
     errorListenerArgument: ErrorResponse<Parameters<A>>;
     errorListenerSignature: ErrorListenerSignature<Parameters<A>>;
 };
@@ -44,6 +46,10 @@ export declare function createAction<A extends BaseHandler>(action: A): ApiType<
     readonly removeAllErrorListeners: (tag?: string) => void;
     readonly removeErrorListener: (handler: ErrorListenerSignature<Parameters<A>>, context?: object | null, tag?: string | null) => boolean;
     readonly errorPromise: (options?: import("./event").ListenerOptions) => Promise<[errorResponse: ErrorResponse<Parameters<A>>]>;
+    readonly addBeforeActionListener: (handler: BeforeActionSignature<A>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly removeAllBeforeActionListeners: (tag?: string) => void;
+    readonly removeBeforeActionListener: (handler: BeforeActionSignature<A>, context?: object | null, tag?: string | null) => boolean;
+    readonly beforeActionPromise: (options?: import("./event").ListenerOptions) => Promise<Parameters<A>>;
 }>;
 export type BaseActionDefinition = ActionDefinitionHelper<(...args: [any]) => any>;
 export type BaseAction = ReturnType<typeof createAction<(...args: [any]) => any>>;

package/dist/action.js

@@ -13,9 +13,25 @@ exports.createAction = createAction;
 const event_1 = require("./event");
 function createAction(action) {
     const { trigger, addListener, removeAllListeners, removeListener, promise, } = (0, event_1.createEvent)();
+    const { all: triggerBeforeAction, addListener: addBeforeActionListener, removeAllListeners: removeAllBeforeActionListeners, removeListener: removeBeforeActionListener, promise: beforeActionPromise, } = (0, event_1.createEvent)();
     const { trigger: triggerError, addListener: addErrorListener, removeAllListeners: removeAllErrorListeners, removeListener: removeErrorListener, promise: errorPromise, hasListener: hasErrorListeners, } = (0, event_1.createEvent)();
     const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
         try {
+            const beforeResults = triggerBeforeAction(...args);
+            for (let before of beforeResults) {
+                if (before instanceof Promise) {
+                    before = yield before;
+                }
+                if (before === false) {
+                    const response = {
+                        response: null,
+                        error: "Action cancelled",
+                        args: args,
+                    };
+                    trigger(response);
+                    return response;
+                }
+            }
             let result = action(...args);
             if (result instanceof Promise) {
                 result = yield result;
@@ -72,6 +88,10 @@ function createAction(action) {
         removeAllErrorListeners,
         removeErrorListener,
         errorPromise,
+        addBeforeActionListener,
+        removeAllBeforeActionListeners,
+        removeBeforeActionListener,
+        beforeActionPromise,
     };
     return api;
 }

package/dist/actionMap.d.ts

@@ -19,5 +19,9 @@ export declare function createActionMap<M extends BaseActionsMap>(actions: M, on
     readonly removeAllErrorListeners: (tag?: string) => void;
     readonly removeErrorListener: (handler: ErrorListenerSignature<Parameters<M[key]>>, context?: object | null, tag?: string | null) => boolean;
     readonly errorPromise: (options?: import("./event").ListenerOptions) => Promise<[errorResponse: ErrorResponse<Parameters<M[key]>>]>;
+    readonly addBeforeActionListener: (handler: import("./action").BeforeActionSignature<M[key]>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly removeAllBeforeActionListeners: (tag?: string) => void;
+    readonly removeBeforeActionListener: (handler: import("./action").BeforeActionSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
+    readonly beforeActionPromise: (options?: import("./event").ListenerOptions) => Promise<Parameters<M[key]>>;
     __type: import("./action").ActionDefinitionHelper<M[key]>;
 }; };

package/dist/react/useAction.d.ts

@@ -1,5 +1,5 @@
 import { createAction } from "../action";
-import type { ActionResponse, ListenerSignature } from "../action";
+import type { ActionResponse, BeforeActionSignature, ListenerSignature } from "../action";
 import type { BaseHandler, ErrorListenerSignature, ErrorResponse } from "../lib/types";
 export type { ActionResponse, BaseHandler, ErrorListenerSignature, ErrorResponse, ListenerSignature, };
-export declare function useAction<ActionSignature extends BaseHandler, Listener extends ListenerSignature<ActionSignature>, ErrorListener extends ErrorListenerSignature<Parameters<ActionSignature>>>(actionSignature: ActionSignature, listener?: Listener | null, errorListener?: ErrorListener | null): ReturnType<typeof createAction<ActionSignature>>;
+export declare function useAction<ActionSignature extends BaseHandler, Listener extends ListenerSignature<ActionSignature>, ErrorListener extends ErrorListenerSignature<Parameters<ActionSignature>>, BeforeActionListener extends BeforeActionSignature<ActionSignature>>(actionSignature: ActionSignature, listener?: Listener | null, errorListener?: ErrorListener | null, beforeActionListener?: BeforeActionListener | null): ReturnType<typeof createAction<ActionSignature>>;

package/dist/react/useAction.js

@@ -4,12 +4,13 @@ exports.useAction = useAction;
 const react_1 = require("react");
 const action_1 = require("../action");
 const ErrorBoundary_1 = require("./ErrorBoundary");
-function useAction(actionSignature, listener, errorListener) {
+function useAction(actionSignature, listener, errorListener, beforeActionListener) {
     const boundaryErrorListener = (0, react_1.useContext)(ErrorBoundary_1.ErrorBoundaryContext);
     const updateRef = (0, react_1.useRef)(0);
     const listenerRef = (0, react_1.useRef)(listener);
     const errorListenerRef = (0, react_1.useRef)(errorListener);
     const boundaryErrorListenerRef = (0, react_1.useRef)(boundaryErrorListener);
+    const beforeActionListenerRef = (0, react_1.useRef)(beforeActionListener);
     const action = (0, react_1.useMemo)(() => {
         const action = (0, action_1.createAction)(actionSignature);
         if (listenerRef.current) {
@@ -21,6 +22,9 @@ function useAction(actionSignature, listener, errorListener) {
         if (boundaryErrorListenerRef.current) {
             action.addErrorListener(boundaryErrorListenerRef.current);
         }
+        if (beforeActionListenerRef.current) {
+            action.addBeforeActionListener(beforeActionListenerRef.current);
+        }
         return action;
     }, []);
     (0, react_1.useEffect)(() => {
@@ -62,5 +66,36 @@ function useAction(actionSignature, listener, errorListener) {
             }
         }
     }, [boundaryErrorListener]);
+    (0, react_1.useEffect)(() => {
+        if (beforeActionListenerRef.current !== beforeActionListener) {
+            if (beforeActionListenerRef.current) {
+                action.removeBeforeActionListener(beforeActionListenerRef.current);
+            }
+            beforeActionListenerRef.current = beforeActionListener !== null && beforeActionListener !== void 0 ? beforeActionListener : null;
+            if (beforeActionListener) {
+                action.addBeforeActionListener(beforeActionListener);
+            }
+        }
+    }, [beforeActionListener]);
+    (0, react_1.useEffect)(() => {
+        return () => {
+            if (listenerRef.current) {
+                listenerRef.current = null;
+            }
+            if (errorListenerRef.current) {
+                errorListenerRef.current = null;
+            }
+            if (boundaryErrorListenerRef.current) {
+                boundaryErrorListenerRef.current = null;
+            }
+            if (beforeActionListenerRef.current) {
+                beforeActionListenerRef.current = null;
+            }
+            action.removeAllListeners();
+            action.removeAllBeforeActionListeners();
+            action.removeAllErrorListeners();
+            updateRef.current = 0;
+        };
+    }, []);
     return action;
 }

package/dist/react/useEvent.js

@@ -6,7 +6,6 @@ const event_1 = require("../event");
 const ErrorBoundary_1 = require("./ErrorBoundary");
 function useEvent(eventOptions = {}, listener, errorListener) {
     const boundaryErrorListener = (0, react_1.useContext)(ErrorBoundary_1.ErrorBoundaryContext);
-    const updateRef = (0, react_1.useRef)(0);
     const listenerRef = (0, react_1.useRef)(listener);
     const errorListenerRef = (0, react_1.useRef)(errorListener);
     const boundaryErrorListenerRef = (0, react_1.useRef)(boundaryErrorListener);
@@ -23,12 +22,6 @@ function useEvent(eventOptions = {}, listener, errorListener) {
         }
         return event;
     }, []);
-    (0, react_1.useEffect)(() => {
-        if (updateRef.current > 0) {
-            throw new Error("Event cannot be updated");
-        }
-        updateRef.current++;
-    }, [event]);
     (0, react_1.useEffect)(() => {
         if (listenerRef.current !== listener) {
             if (listenerRef.current) {
@@ -62,5 +55,21 @@ function useEvent(eventOptions = {}, listener, errorListener) {
             }
         }
     }, [boundaryErrorListener]);
+    (0, react_1.useEffect)(() => {
+        return () => {
+            if (listenerRef.current) {
+                event.removeListener(listenerRef.current);
+                listenerRef.current = null;
+            }
+            if (errorListenerRef.current) {
+                event.removeErrorListener(errorListenerRef.current);
+                errorListenerRef.current = null;
+            }
+            if (boundaryErrorListenerRef.current) {
+                event.removeErrorListener(boundaryErrorListenerRef.current);
+                boundaryErrorListenerRef.current = null;
+            }
+        };
+    }, []);
     return event;
 }

package/dist/react/useEventBus.js

@@ -7,9 +7,9 @@ const ErrorBoundary_1 = require("./ErrorBoundary");
 function useEventBus(eventBusOptions, allEventsListener, errorListener) {
     const boundaryErrorListener = (0, react_1.useContext)(ErrorBoundary_1.ErrorBoundaryContext);
     const updateRef = (0, react_1.useRef)(0);
-    const errorListenerRef = (0, react_1.useRef)(errorListener);
-    const allEventsListenerRef = (0, react_1.useRef)(allEventsListener);
-    const boundaryErrorListenerRef = (0, react_1.useRef)(boundaryErrorListener);
+    const errorListenerRef = (0, react_1.useRef)(errorListener || null);
+    const allEventsListenerRef = (0, react_1.useRef)(allEventsListener || null);
+    const boundaryErrorListenerRef = (0, react_1.useRef)(boundaryErrorListener || null);
     const eventBus = (0, react_1.useMemo)(() => {
         const eventBus = (0, eventBus_1.createEventBus)(eventBusOptions);
         if (allEventsListener) {
@@ -36,7 +36,7 @@ function useEventBus(eventBusOptions, allEventsListener, errorListener) {
             if (allEventsListenerRef.current) {
                 eventBus.removeAllEventsListener(allEventsListenerRef.current);
             }
-            allEventsListenerRef.current = allEventsListener;
+            allEventsListenerRef.current = allEventsListener || null;
             if (allEventsListener) {
                 eventBus.addAllEventsListener(allEventsListener);
             }
@@ -47,7 +47,7 @@ function useEventBus(eventBusOptions, allEventsListener, errorListener) {
             if (errorListenerRef.current) {
                 eventBus.removeErrorListener(errorListenerRef.current);
             }
-            errorListenerRef.current = errorListener;
+            errorListenerRef.current = errorListener || null;
             if (errorListener) {
                 eventBus.addErrorListener(errorListener);
             }
@@ -58,11 +58,29 @@ function useEventBus(eventBusOptions, allEventsListener, errorListener) {
             if (boundaryErrorListenerRef.current) {
                 eventBus.removeErrorListener(boundaryErrorListenerRef.current);
             }
-            boundaryErrorListenerRef.current = boundaryErrorListener;
+            boundaryErrorListenerRef.current = boundaryErrorListener
+                || null;
             if (boundaryErrorListener) {
                 eventBus.addErrorListener(boundaryErrorListener);
             }
         }
     }, [boundaryErrorListener]);
+    (0, react_1.useEffect)(() => {
+        return () => {
+            if (allEventsListenerRef.current) {
+                eventBus.removeAllEventsListener(allEventsListenerRef.current);
+                allEventsListenerRef.current = null;
+            }
+            if (errorListenerRef.current) {
+                eventBus.removeErrorListener(errorListenerRef.current);
+                errorListenerRef.current = null;
+            }
+            if (boundaryErrorListenerRef.current) {
+                eventBus.removeErrorListener(boundaryErrorListenerRef.current);
+                boundaryErrorListenerRef.current = null;
+            }
+            updateRef.current = 0;
+        };
+    }, []);
     return eventBus;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kuindji/reactive",
-    "version": "1.0.14",
+    "version": "1.0.16",
     "author": "Ivan Kuindzhi",
     "repository": {
         "type": "git",