akeyless-client-commons 1.1.33 → 1.1.35

package/dist/hooks/index.js

@@ -7,6 +7,9 @@ function _array_like_to_array(arr, len) {
 function _array_with_holes(arr) {
     if (Array.isArray(arr)) return arr;
 }
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -68,6 +71,9 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
 function _iterable_to_array_limit(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
@@ -95,6 +101,9 @@ function _iterable_to_array_limit(arr, i) {
 function _non_iterable_rest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _object_spread(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
@@ -137,6 +146,9 @@ function _object_spread_props(target, source) {
 function _sliced_to_array(arr, i) {
     return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
 }
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
 function _type_of(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
@@ -508,9 +520,14 @@ var snapshot = function(config, snapshotsFirstTime, settings) {
         });
     }
     var unsubscribe = (0, import_firestore.onSnapshot)(collectionRef, function(snapshot3) {
-        if (!snapshotsFirstTime.includes(config.collectionName)) {
+        var firstTimeKey = JSON.stringify({
+            collectionName: config.collectionName,
+            conditions: config.conditions || [],
+            orderBy: config.orderBy || []
+        });
+        if (!snapshotsFirstTime.includes(firstTimeKey)) {
             var _config_onFirstTime, _config_extraParsers;
-            snapshotsFirstTime.push(config.collectionName);
+            snapshotsFirstTime.push(firstTimeKey);
             var documents = snapshot3.docs.map(function(doc2) {
                 return simpleExtractData(doc2);
             });
@@ -1012,20 +1029,240 @@ function useDeepCompareEffect(effect, dependencies) {
 }
 // src/hooks/WebWorker.ts
 var import_react4 = require("react");
+var useWebWorker = function(fn) {
+    var workerRef = (0, import_react4.useRef)(null);
+    var workerUrlRef = (0, import_react4.useRef)(null);
+    var nextJobIdRef = (0, import_react4.useRef)(1);
+    var pendingJobsRef = (0, import_react4.useRef)(/* @__PURE__ */ new Map());
+    (0, import_react4.useEffect)(function() {
+        if (typeof window === "undefined" || typeof Worker === "undefined") {
+            return function() {};
+        }
+        var functionString = fn.toString();
+        var workerSource = [
+            "const userFn = (".concat(functionString, ");"),
+            "onmessage = async function(event) {",
+            "  try {",
+            "    const { id, payload } = event.data || {};",
+            "    const result = await userFn(payload);",
+            "    postMessage({ id, ok: true, result });",
+            "  } catch (err) {",
+            "    let message;",
+            "    try { message = err && err.message ? String(err.message) : String(err); } catch (_) { message = 'Worker error'; }",
+            "    postMessage({ id, ok: false, error: message });",
+            "  }",
+            "}"
+        ].join("\n");
+        var workerBlob = new Blob([
+            workerSource
+        ], {
+            type: "application/javascript"
+        });
+        var url = URL.createObjectURL(workerBlob);
+        var worker = new Worker(url);
+        worker.onmessage = function(event) {
+            var data = event.data || {};
+            var id = data.id;
+            if (!id) return;
+            var pending = pendingJobsRef.current.get(id);
+            if (!pending) return;
+            pendingJobsRef.current.delete(id);
+            if (data.ok) {
+                pending.resolve(data.result);
+            } else {
+                var _data_error;
+                pending.reject(new Error((_data_error = data.error) !== null && _data_error !== void 0 ? _data_error : "Worker error"));
+            }
+        };
+        worker.onerror = function() {
+            pendingJobsRef.current.forEach(function(job) {
+                job.reject(new Error("Worker encountered an error"));
+            });
+            pendingJobsRef.current.clear();
+        };
+        if (workerRef.current) {
+            workerRef.current.terminate();
+        }
+        if (workerUrlRef.current) {
+            URL.revokeObjectURL(workerUrlRef.current);
+        }
+        workerRef.current = worker;
+        workerUrlRef.current = url;
+        return function() {
+            if (workerRef.current) {
+                workerRef.current.terminate();
+                workerRef.current = null;
+            }
+            if (workerUrlRef.current) {
+                URL.revokeObjectURL(workerUrlRef.current);
+                workerUrlRef.current = null;
+            }
+            pendingJobsRef.current.forEach(function(job) {
+                job.reject(new Error("Worker terminated"));
+            });
+            pendingJobsRef.current.clear();
+        };
+    }, [
+        fn
+    ]);
+    var runWorker = (0, import_react4.useCallback)(function(data, transfer) {
+        if (!workerRef.current) {
+            return new Promise(/*#__PURE__*/ function() {
+                var _ref = _async_to_generator(function(resolve, reject) {
+                    var result, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    2,
+                                    ,
+                                    3
+                                ]);
+                                return [
+                                    4,
+                                    fn(data)
+                                ];
+                            case 1:
+                                result = _state.sent();
+                                resolve(result);
+                                return [
+                                    3,
+                                    3
+                                ];
+                            case 2:
+                                err = _state.sent();
+                                reject(err);
+                                return [
+                                    3,
+                                    3
+                                ];
+                            case 3:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                });
+                return function(resolve, reject) {
+                    return _ref.apply(this, arguments);
+                };
+            }());
+        }
+        var id = nextJobIdRef.current++;
+        return new Promise(function(resolve, reject) {
+            pendingJobsRef.current.set(id, {
+                resolve: resolve,
+                reject: reject
+            });
+            try {
+                if (transfer && transfer.length) {
+                    workerRef.current.postMessage({
+                        id: id,
+                        payload: data
+                    }, transfer);
+                } else {
+                    workerRef.current.postMessage({
+                        id: id,
+                        payload: data
+                    });
+                }
+            } catch (err) {
+                pendingJobsRef.current.delete(id);
+                reject(err);
+            }
+        });
+    }, [
+        fn
+    ]);
+    return runWorker;
+};
+var WebWorker_default = useWebWorker;
 // src/hooks/snapshots.ts
 var import_react5 = require("react");
 var useDbSnapshots = function(configs, label, settings) {
     var snapshotsFirstTime = (0, import_react5.useRef)([]);
     var unsubscribeFunctions = (0, import_react5.useRef)([]);
+    var runProcessor = WebWorker_default(function(payload) {
+        return {
+            docs: payload.docs
+        };
+    });
+    var wrapConfigsForWorker = function(cfgs) {
+        return cfgs.map(function(cfg) {
+            var wrapped = _object_spread({}, cfg);
+            var wrapCb = function(cb, op) {
+                if (!cb) return void 0;
+                return /*#__PURE__*/ function() {
+                    var _ref = _async_to_generator(function(docs, config) {
+                        var safeDocs, _ref, processed, e;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    _state.trys.push([
+                                        0,
+                                        2,
+                                        ,
+                                        3
+                                    ]);
+                                    safeDocs = JSON.parse(JSON.stringify(docs));
+                                    return [
+                                        4,
+                                        runProcessor({
+                                            op: op,
+                                            docs: safeDocs
+                                        })
+                                    ];
+                                case 1:
+                                    _ref = _state.sent(), processed = _ref.docs;
+                                    cb(processed, config);
+                                    return [
+                                        3,
+                                        3
+                                    ];
+                                case 2:
+                                    e = _state.sent();
+                                    cb(docs, config);
+                                    return [
+                                        3,
+                                        3
+                                    ];
+                                case 3:
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    });
+                    return function(docs, config) {
+                        return _ref.apply(this, arguments);
+                    };
+                }();
+            };
+            wrapped.onFirstTime = wrapCb(cfg.onFirstTime, "first");
+            wrapped.onAdd = wrapCb(cfg.onAdd, "add");
+            wrapped.onModify = wrapCb(cfg.onModify, "modify");
+            wrapped.onRemove = wrapCb(cfg.onRemove, "remove");
+            if (cfg.extraParsers && cfg.extraParsers.length) {
+                wrapped.extraParsers = cfg.extraParsers.map(function(p) {
+                    return {
+                        onFirstTime: wrapCb(p.onFirstTime, "first"),
+                        onAdd: wrapCb(p.onAdd, "add"),
+                        onModify: wrapCb(p.onModify, "modify"),
+                        onRemove: wrapCb(p.onRemove, "remove")
+                    };
+                });
+            }
+            return wrapped;
+        });
+    };
     useDeepCompareEffect(function() {
-        if (configs.length === 0) {
-            return;
-        }
         var start = performance.now();
         if (!(settings === null || settings === void 0 ? void 0 : settings.disableLogs) && configs.length > 0) {
             console.log("==> ".concat(label || "DB snapshots", " started from db... "));
         }
-        var snapshotResults = configs.map(function(config) {
+        var wrappedConfigs = wrapConfigsForWorker(configs);
+        var snapshotResults = wrappedConfigs.map(function(config) {
             return snapshot(config, snapshotsFirstTime.current, settings);
         });
         unsubscribeFunctions.current = snapshotResults.map(function(result) {
@@ -1113,25 +1350,94 @@ var useSmartSnapshots = function(configs, label, settings) {
 var useSocketSnapshots = function(configs, label, settings) {
     var _auth_currentUser;
     var _ref = _sliced_to_array((0, import_react5.useState)(socketServiceInstance.isConnected()), 2), socketConnected = _ref[0], setSocketConnected = _ref[1];
-    var cleanupSubscriptionsRef = (0, import_react5.useRef)([]);
+    var _ref1 = _sliced_to_array((0, import_react5.useState)([]), 2), cleanupSubscriptions = _ref1[0], setCleanupSubscriptions = _ref1[1];
     var socketStarted = (0, import_react5.useRef)(false);
+    var runProcessor = WebWorker_default(function(payload) {
+        return {
+            docs: payload.docs
+        };
+    });
+    var wrapConfigsForWorker = function(cfgs) {
+        return cfgs.map(function(cfg) {
+            var wrapped = _object_spread({}, cfg);
+            var wrapCb = function(cb, op) {
+                if (!cb) return void 0;
+                return /*#__PURE__*/ function() {
+                    var _ref = _async_to_generator(function(docs, config) {
+                        var _ref, processed, e;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    _state.trys.push([
+                                        0,
+                                        2,
+                                        ,
+                                        3
+                                    ]);
+                                    return [
+                                        4,
+                                        runProcessor({
+                                            op: op,
+                                            docs: docs
+                                        })
+                                    ];
+                                case 1:
+                                    _ref = _state.sent(), processed = _ref.docs;
+                                    cb(processed, config);
+                                    return [
+                                        3,
+                                        3
+                                    ];
+                                case 2:
+                                    e = _state.sent();
+                                    cb(docs, config);
+                                    return [
+                                        3,
+                                        3
+                                    ];
+                                case 3:
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    });
+                    return function(docs, config) {
+                        return _ref.apply(this, arguments);
+                    };
+                }();
+            };
+            wrapped.onFirstTime = wrapCb(cfg.onFirstTime, "first");
+            wrapped.onAdd = wrapCb(cfg.onAdd, "add");
+            wrapped.onModify = wrapCb(cfg.onModify, "modify");
+            wrapped.onRemove = wrapCb(cfg.onRemove, "remove");
+            if (cfg.extraParsers && cfg.extraParsers.length) {
+                wrapped.extraParsers = cfg.extraParsers.map(function(p) {
+                    return {
+                        onFirstTime: wrapCb(p.onFirstTime, "first"),
+                        onAdd: wrapCb(p.onAdd, "add"),
+                        onModify: wrapCb(p.onModify, "modify"),
+                        onRemove: wrapCb(p.onRemove, "remove")
+                    };
+                });
+            }
+            return wrapped;
+        });
+    };
     useDeepCompareEffect(function() {
-        var isActive = true;
         if (!auth.currentUser) {
             return;
         }
-        var clearSubs = function() {
-            cleanupSubscriptionsRef.current.forEach(function(cleanup) {
-                return cleanup();
-            });
-            cleanupSubscriptionsRef.current = [];
-        };
         var subscribe = function() {
             if (configs.length === 0) {
                 return;
             }
-            var disposer = socketServiceInstance.subscribeToCollections(configs);
-            cleanupSubscriptionsRef.current.push(disposer);
+            var disposer = socketServiceInstance.subscribeToCollections(wrapConfigsForWorker(configs));
+            setCleanupSubscriptions(function(prev) {
+                return _to_consumable_array(prev).concat([
+                    disposer
+                ]);
+            });
             if (!(settings === null || settings === void 0 ? void 0 : settings.disableLogs)) {
                 console.log("==> ".concat(label || "Cache snapshots", " subscribed to ").concat(configs.map(function(c) {
                     return c.collectionName;
@@ -1140,34 +1446,32 @@ var useSocketSnapshots = function(configs, label, settings) {
         };
         if (socketServiceInstance.isConnected()) {
             setSocketConnected(true);
-            clearSubs();
             subscribe();
         } else if (!socketStarted.current) {
             socketStarted.current = true;
             auth.currentUser.getIdToken().then(function(token) {
-                if (!isActive) return;
                 socketServiceInstance.startSession(token);
                 if (!(settings === null || settings === void 0 ? void 0 : settings.disableLogs)) {
                     console.log("==> ".concat(label || "Cache snapshots", " started... "));
                 }
-            }).catch(function() {});
+            });
         }
         var offConnect = socketServiceInstance.onConnect(function() {
-            if (!isActive) return;
             setSocketConnected(true);
             socketStarted.current = false;
             subscribe();
         });
         var offDisconnect = socketServiceInstance.onDisconnect(function() {
-            if (!isActive) return;
             setSocketConnected(false);
+            cleanupSubscriptions.forEach(function(cleanup) {
+                return cleanup();
+            });
         });
         if (settings === null || settings === void 0 ? void 0 : settings.cleanupForConfigChange) {
             return function() {
-                isActive = false;
-                clearSubs();
-                offConnect();
-                offDisconnect();
+                cleanupSubscriptions.forEach(function(cleanup) {
+                    return cleanup();
+                });
                 if (!(settings === null || settings === void 0 ? void 0 : settings.disableLogs) && configs.length > 0) {
                     console.log("==> ".concat(label || "Cache snapshots", " unsubscribed. "));
                 }
@@ -1178,21 +1482,10 @@ var useSocketSnapshots = function(configs, label, settings) {
         (_auth_currentUser = auth.currentUser) === null || _auth_currentUser === void 0 ? void 0 : _auth_currentUser.uid
     ]);
     (0, import_react5.useEffect)(function() {
-        var _auth_onIdTokenChanged;
-        var unsubscribeAuth = (_auth_onIdTokenChanged = auth.onIdTokenChanged) === null || _auth_onIdTokenChanged === void 0 ? void 0 : _auth_onIdTokenChanged.call(auth, function(user) {
-            if (!user) return;
-            user.getIdToken().then(function(token) {
-                return socketServiceInstance.setAuthToken(token);
-            }).catch(function() {});
-        });
         return function() {
-            cleanupSubscriptionsRef.current.forEach(function(cleanup) {
+            cleanupSubscriptions.forEach(function(cleanup) {
                 return cleanup();
             });
-            cleanupSubscriptionsRef.current = [];
-            if (typeof unsubscribeAuth === "function") {
-                unsubscribeAuth();
-            }
             if (!(settings === null || settings === void 0 ? void 0 : settings.disableLogs) && configs.length > 0) {
                 console.log("==> ".concat(label || "Cache snapshots", " unsubscribed. "));
             }