@kuindji/reactive 1.0.23 → 1.0.24

package/dist/action.js

@@ -1,4 +1,3 @@
-"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,13 +7,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-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)();
+import { createEvent } from "./event";
+export function createAction(action) {
+    const { trigger, addListener, removeAllListeners, removeListener, promise, } = createEvent();
+    const { all: triggerBeforeAction, addListener: addBeforeActionListener, removeAllListeners: removeAllBeforeActionListeners, removeListener: removeBeforeActionListener, promise: beforeActionPromise, } = createEvent();
+    const { trigger: triggerError, addListener: addErrorListener, removeAllListeners: removeAllErrorListeners, removeListener: removeErrorListener, promise: errorPromise, hasListener: hasErrorListeners, } = createEvent();
     const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
         try {
             const beforeResults = triggerBeforeAction(...args);

package/dist/actionBus.js

@@ -1,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createActionBus = createActionBus;
-const action_1 = require("./action");
-const event_1 = require("./event");
-function createActionBus(initialActions = {}, errorListener) {
+import { createAction } from "./action";
+import { createEvent } from "./event";
+export function createActionBus(initialActions = {}, errorListener) {
     const actions = new Map();
-    const errorEvent = (0, event_1.createEvent)();
+    const errorEvent = createEvent();
     if (errorListener) {
         errorEvent.addListener(errorListener);
     }
     const add = (name, action) => {
         if (!actions.has(name)) {
-            const a = (0, action_1.createAction)(action);
+            const a = createAction(action);
             a.addErrorListener(({ error, args }) => {
                 errorEvent.emit({ name, error, args, type: "action" });
             });

package/dist/actionMap.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createActionMap = createActionMap;
-const action_1 = require("./action");
-function createActionMap(actions, onAnyError) {
+import { createAction } from "./action";
+export function createActionMap(actions, onAnyError) {
     const errorListenersMap = {};
     for (const key in actions) {
         errorListenersMap[key] = (errorResponse) => {
@@ -18,7 +15,7 @@ function createActionMap(actions, onAnyError) {
     }
     const map = {};
     for (const key in actions) {
-        const action = (0, action_1.createAction)(actions[key]);
+        const action = createAction(actions[key]);
         action.addErrorListener(errorListenersMap[key]);
         map[key] = action;
     }

package/dist/event.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEvent = createEvent;
-const asyncCall_1 = require("./lib/asyncCall");
-const listenerSorter_1 = require("./lib/listenerSorter");
-const tagsIntersect_1 = require("./lib/tagsIntersect");
-const types_1 = require("./lib/types");
-function createEvent(eventOptions = {}) {
+import asyncCall from "./lib/asyncCall";
+import listenerSorter from "./lib/listenerSorter";
+import tagsIntersect from "./lib/tagsIntersect";
+import { TriggerReturnType } from "./lib/types";
+export function createEvent(eventOptions = {}) {
     let listeners = [];
     const errorListeners = [];
     let queue = [];
@@ -41,7 +38,7 @@ function createEvent(eventOptions = {}) {
             listeners.forEach((l, inx) => {
                 l.index = inx;
             });
-            listeners.sort((l1, l2) => (0, listenerSorter_1.default)(l1, l2));
+            listeners.sort((l1, l2) => listenerSorter(l1, l2));
         }
         if ((listenerOptions === null || listenerOptions === void 0 ? void 0 : listenerOptions.alwaysFirst) === true
             || (listenerOptions === null || listenerOptions === void 0 ? void 0 : listenerOptions.alwaysLast) === true) {
@@ -174,7 +171,7 @@ function createEvent(eventOptions = {}) {
         }
         try {
             const result = isAsync !== false
-                ? (0, asyncCall_1.default)(listener.handler, listener.context, args, isAsync)
+                ? asyncCall(listener.handler, listener.context, args, isAsync)
                 : listener.handler.bind(listener.context)(...args);
             if (resolve !== null) {
                 if (result instanceof Promise) {
@@ -216,22 +213,22 @@ function createEvent(eventOptions = {}) {
         }
     };
     const _listenerCallWPrev = (listener, args, prevValue, returnType) => {
-        if (returnType === types_1.TriggerReturnType.PIPE) {
+        if (returnType === TriggerReturnType.PIPE) {
             args[0] = prevValue;
             // since we don't user listener's arg transformer,
             // we don't need to prepare args
             // args = _prepareListenerArgs(args);
             return _listenerCall(listener, args);
         }
-        else if (returnType === types_1.TriggerReturnType.UNTIL_TRUE
+        else if (returnType === TriggerReturnType.UNTIL_TRUE
             && prevValue === true) {
             return true;
         }
-        else if (returnType === types_1.TriggerReturnType.UNTIL_FALSE
+        else if (returnType === TriggerReturnType.UNTIL_FALSE
             && prevValue === false) {
             return false;
         }
-        else if (returnType === types_1.TriggerReturnType.FIRST_NON_EMPTY
+        else if (returnType === TriggerReturnType.FIRST_NON_EMPTY
             && prevValue !== null
             && prevValue !== undefined) {
             return prevValue;
@@ -256,24 +253,24 @@ function createEvent(eventOptions = {}) {
         // in pipe mode if there is no listeners,
         // we just return piped value
         if (listeners.length === 0) {
-            if (returnType === types_1.TriggerReturnType.PIPE) {
+            if (returnType === TriggerReturnType.PIPE) {
                 return args.length > 0 ? args[0] : undefined;
             }
-            else if (returnType === types_1.TriggerReturnType.ALL
-                || returnType === types_1.TriggerReturnType.CONCAT
-                || returnType === types_1.TriggerReturnType.RAW) {
+            else if (returnType === TriggerReturnType.ALL
+                || returnType === TriggerReturnType.CONCAT
+                || returnType === TriggerReturnType.RAW) {
                 return [];
             }
-            else if (returnType === types_1.TriggerReturnType.MERGE) {
+            else if (returnType === TriggerReturnType.MERGE) {
                 return {};
             }
             return;
         }
         const listenersQueue = listeners.slice();
-        const isConsequent = returnType === types_1.TriggerReturnType.PIPE
-            || returnType === types_1.TriggerReturnType.UNTIL_TRUE
-            || returnType === types_1.TriggerReturnType.UNTIL_FALSE
-            || returnType === types_1.TriggerReturnType.FIRST_NON_EMPTY;
+        const isConsequent = returnType === TriggerReturnType.PIPE
+            || returnType === TriggerReturnType.UNTIL_TRUE
+            || returnType === TriggerReturnType.UNTIL_FALSE
+            || returnType === TriggerReturnType.FIRST_NON_EMPTY;
         let listener;
         let listenerResult;
         const results = [];
@@ -289,12 +286,12 @@ function createEvent(eventOptions = {}) {
             }
             if (tags
                 && tags.length > 0
-                && (!listener.tags || !(0, tagsIntersect_1.default)(tags, listener.tags))) {
+                && (!listener.tags || !tagsIntersect(tags, listener.tags))) {
                 continue;
             }
             if (currentTagsFilter !== null
                 && currentTagsFilter.length > 0
-                && !(0, tagsIntersect_1.default)(currentTagsFilter, listener.tags)) {
+                && !tagsIntersect(currentTagsFilter, listener.tags)) {
                 continue;
             }
             listener.count++;
@@ -326,24 +323,24 @@ function createEvent(eventOptions = {}) {
             if (listener.called === listener.limit) {
                 removeListener(listener.handler, listener.context);
             }
-            if (returnType === types_1.TriggerReturnType.FIRST) {
+            if (returnType === TriggerReturnType.FIRST) {
                 return listenerResult;
             }
             if (isConsequent) {
                 switch (returnType) {
-                    case types_1.TriggerReturnType.UNTIL_TRUE: {
+                    case TriggerReturnType.UNTIL_TRUE: {
                         if (listenerResult === true) {
                             return true;
                         }
                         break;
                     }
-                    case types_1.TriggerReturnType.UNTIL_FALSE: {
+                    case TriggerReturnType.UNTIL_FALSE: {
                         if (listenerResult === false) {
                             return false;
                         }
                         break;
                     }
-                    case types_1.TriggerReturnType.FIRST_NON_EMPTY: {
+                    case TriggerReturnType.FIRST_NON_EMPTY: {
                         if (!hasPromises
                             && !(listenerResult instanceof Promise)
                             && listenerResult !== null
@@ -360,7 +357,7 @@ function createEvent(eventOptions = {}) {
             results.push(listenerResult);
         }
         switch (returnType) {
-            case types_1.TriggerReturnType.RAW: {
+            case TriggerReturnType.RAW: {
                 return results;
             }
             case undefined:
@@ -370,36 +367,36 @@ function createEvent(eventOptions = {}) {
                 }
                 return;
             }
-            case types_1.TriggerReturnType.ALL: {
+            case TriggerReturnType.ALL: {
                 return hasPromises
                     ? Promise.all(results)
                     : results;
             }
-            case types_1.TriggerReturnType.CONCAT: {
+            case TriggerReturnType.CONCAT: {
                 return hasPromises
                     ? Promise.all(results).then((r) => r.flat())
                     : results.flat();
             }
-            case types_1.TriggerReturnType.MERGE: {
+            case TriggerReturnType.MERGE: {
                 return hasPromises
                     ? Promise.all(results).then((r) => Object.assign({}, ...r))
                     : Object.assign({}, ...results);
             }
-            case types_1.TriggerReturnType.LAST: {
+            case TriggerReturnType.LAST: {
                 return results.pop();
             }
-            case types_1.TriggerReturnType.UNTIL_TRUE: {
+            case TriggerReturnType.UNTIL_TRUE: {
                 return;
             }
-            case types_1.TriggerReturnType.UNTIL_FALSE: {
+            case TriggerReturnType.UNTIL_FALSE: {
                 return;
             }
-            case types_1.TriggerReturnType.FIRST_NON_EMPTY: {
+            case TriggerReturnType.FIRST_NON_EMPTY: {
                 return hasPromises
                     ? Promise.all(results).then((r) => r.find((item) => item !== undefined && item !== null))
                     : results.find((item) => item !== undefined && item !== null);
             }
-            case types_1.TriggerReturnType.PIPE: {
+            case TriggerReturnType.PIPE: {
                 return results[results.length - 1];
             }
         }
@@ -429,83 +426,83 @@ function createEvent(eventOptions = {}) {
             });
     };
     const first = (...args) => {
-        return _trigger(args, types_1.TriggerReturnType.FIRST);
+        return _trigger(args, TriggerReturnType.FIRST);
     };
     const resolveFirst = (...args) => {
-        const response = _trigger(args, types_1.TriggerReturnType.FIRST);
+        const response = _trigger(args, TriggerReturnType.FIRST);
         if (response instanceof Promise) {
             return response;
         }
         return Promise.resolve(response);
     };
     const all = (...args) => {
-        return _trigger(args, types_1.TriggerReturnType.ALL);
+        return _trigger(args, TriggerReturnType.ALL);
     };
     const resolveAll = (...args) => {
-        const response = _trigger(args, types_1.TriggerReturnType.ALL);
+        const response = _trigger(args, TriggerReturnType.ALL);
         if (response instanceof Promise) {
             return response;
         }
         return Promise.resolve(response);
     };
     const last = (...args) => {
-        return _trigger(args, types_1.TriggerReturnType.LAST);
+        return _trigger(args, TriggerReturnType.LAST);
     };
     const resolveLast = (...args) => {
-        const response = _trigger(args, types_1.TriggerReturnType.LAST);
+        const response = _trigger(args, TriggerReturnType.LAST);
         if (response instanceof Promise) {
             return response;
         }
         return Promise.resolve(response);
     };
     const merge = (...args) => {
-        return _trigger(args, types_1.TriggerReturnType.MERGE);
+        return _trigger(args, TriggerReturnType.MERGE);
     };
     const resolveMerge = (...args) => {
-        const response = _trigger(args, types_1.TriggerReturnType.MERGE);
+        const response = _trigger(args, TriggerReturnType.MERGE);
         if (response instanceof Promise) {
             return response;
         }
         return Promise.resolve(response);
     };
     const concat = (...args) => {
-        return _trigger(args, types_1.TriggerReturnType.CONCAT);
+        return _trigger(args, TriggerReturnType.CONCAT);
     };
     const resolveConcat = (...args) => {
-        const response = _trigger(args, types_1.TriggerReturnType.CONCAT);
+        const response = _trigger(args, TriggerReturnType.CONCAT);
         if (response instanceof Promise) {
             return response;
         }
         return Promise.resolve(response);
     };
     const firstNonEmpty = (...args) => {
-        return _trigger(args, types_1.TriggerReturnType.FIRST_NON_EMPTY);
+        return _trigger(args, TriggerReturnType.FIRST_NON_EMPTY);
     };
     const resolveFirstNonEmpty = (...args) => {
-        const response = _trigger(args, types_1.TriggerReturnType.FIRST_NON_EMPTY);
+        const response = _trigger(args, TriggerReturnType.FIRST_NON_EMPTY);
         if (response instanceof Promise) {
             return response;
         }
         return Promise.resolve(response);
     };
     const untilTrue = (...args) => {
-        _trigger(args, types_1.TriggerReturnType.UNTIL_TRUE);
+        _trigger(args, TriggerReturnType.UNTIL_TRUE);
     };
     const untilFalse = (...args) => {
-        _trigger(args, types_1.TriggerReturnType.UNTIL_FALSE);
+        _trigger(args, TriggerReturnType.UNTIL_FALSE);
     };
     const pipe = (...args) => {
-        return _trigger(args, types_1.TriggerReturnType.PIPE);
+        return _trigger(args, TriggerReturnType.PIPE);
     };
     const resolvePipe = (...args) => {
-        const response = _trigger(args, types_1.TriggerReturnType.PIPE);
+        const response = _trigger(args, TriggerReturnType.PIPE);
         if (response instanceof Promise) {
             return response;
         }
         return Promise.resolve(response);
     };
     const raw = (...args) => {
-        return _trigger(args, types_1.TriggerReturnType.RAW);
+        return _trigger(args, TriggerReturnType.RAW);
     };
     const api = {
         addListener,