akeyless-client-commons 1.0.1

package/dist/helpers/index.mjs

@@ -0,0 +1,1494 @@
+// src/helpers/firebase.ts
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+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 _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+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 _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import moment from "moment";
+import { initializeApp } from "firebase/app";
+import { getStorage } from "firebase/storage";
+import { getAuth } from "firebase/auth";
+import { addDoc, collection, deleteDoc, doc, getDoc, getDocs, query, setDoc, Timestamp, where, getFirestore, onSnapshot, orderBy } from "firebase/firestore";
+// src/helpers/cars.ts
+var formatCarNumber = function(car_number) {
+    var cn2 = car_number;
+    if ((cn2 === null || cn2 === void 0 ? void 0 : cn2.length) == 8) return "".concat(cn2[0]).concat(cn2[1]).concat(cn2[2], "-").concat(cn2[3]).concat(cn2[4], "-").concat(cn2[5]).concat(cn2[6]).concat(cn2[7]);
+    if ((cn2 === null || cn2 === void 0 ? void 0 : cn2.length) == 7) return "".concat(cn2[0]).concat(cn2[1], "-").concat(cn2[2]).concat(cn2[3]).concat(cn2[4], "-").concat(cn2[5]).concat(cn2[6]);
+    if ((cn2 === null || cn2 === void 0 ? void 0 : cn2.length) == 6) return "".concat(cn2[0]).concat(cn2[1], "-").concat(cn2[2]).concat(cn2[3], "-").concat(cn2[4]).concat(cn2[5]);
+    if ((cn2 === null || cn2 === void 0 ? void 0 : cn2.length) == 5) return "".concat(cn2[0], "-").concat(cn2[1]).concat(cn2[2], "-").concat(cn2[3]).concat(cn2[4]);
+    return cn2;
+};
+// src/helpers/firebase.ts
+var initApp = function() {
+    var isNodeEnv2 = typeof process !== "undefined" && process.env;
+    var firebaseConfig = {
+        apiKey: isNodeEnv2 ? process.env.NEXT_PUBLIC_API_KEY : import.meta.env.VITE_API_KEY,
+        authDomain: isNodeEnv2 ? process.env.NEXT_PUBLIC_AUTH_DOMAIN : import.meta.env.VITE_AUTH_DOMAIN,
+        projectId: isNodeEnv2 ? process.env.NEXT_PUBLIC_PROJECT_ID : import.meta.env.VITE_PROJECT_ID,
+        storageBucket: isNodeEnv2 ? process.env.NEXT_PUBLIC_STORAGE_BUCKET : import.meta.env.VITE_STORAGE_BUCKET,
+        messagingSenderId: isNodeEnv2 ? process.env.NEXT_PUBLIC_MESSAGING_SENDER_ID : import.meta.env.VITE_MESSAGING_SENDER_ID,
+        appId: isNodeEnv2 ? process.env.NEXT_PUBLIC_APP_ID : import.meta.env.VITE_APP_ID
+    };
+    try {
+        var app = initializeApp(firebaseConfig);
+        var auth2 = getAuth(app);
+        var db2 = getFirestore(app);
+        var storage2 = getStorage(app);
+        return {
+            db: db2,
+            auth: auth2,
+            storage: storage2
+        };
+    } catch (error) {
+        console.error("Failed to initialize Firebase app:", error);
+        return {};
+    }
+};
+var _initApp = initApp(), db = _initApp.db, auth = _initApp.auth, storage = _initApp.storage;
+var collections = {
+    clients: collection(db, "nx-clients"),
+    sites: collection(db, "nx-sites"),
+    cars: collection(db, "units"),
+    users: collection(db, "nx-users"),
+    lastLocations: collection(db, "last_locations"),
+    ermEvents: collection(db, "erm_events_general"),
+    erm2Events: collection(db, "erm2_events_general"),
+    ruptelaEvents: collection(db, "ruptela_events_general"),
+    polygons: collection(db, "nx-polygons"),
+    polygonEvents: collection(db, "polygon_events"),
+    polygonCars: collection(db, "polygon_cars"),
+    canbus: collection(db, "erm_canbus_parameters"),
+    states: collection(db, "erm_states"),
+    app_pro_commands_queue: collection(db, "app_pro_commands_queue"),
+    trips: collection(db, "erm2_trip"),
+    tripsDetails: collection(db, "erm2_trip_details"),
+    audit: collection(db, "nx-audit"),
+    nx_settings: collection(db, "nx-settings"),
+    settings: collection(db, "settings"),
+    translations: collection(db, "nx-translations"),
+    nx_cars: collection(db, "nx-cars"),
+    boards: collection(db, "boards"),
+    protection_types: collection(db, "protectionTypes"),
+    board_types: collection(db, "boardTypes"),
+    charge_capacities: collection(db, "nx-charge-capacities")
+};
+var fire_base_TIME_TEMP = Timestamp.now;
+var extractAlertsData = function(doc2) {
+    var data = doc2.data();
+    var car_number = data.car_number, timestamp = data.timestamp;
+    return _object_spread_props(_object_spread({}, data), {
+        timestamp_seconds: timestamp.seconds,
+        timestamp_ui: moment.unix(timestamp.seconds).format("DD/MM/YY HH:mm"),
+        car_number: formatCarNumber(car_number)
+    });
+};
+var simpleExtractData = function(doc2) {
+    var docData = doc2.data();
+    return _object_spread_props(_object_spread({}, docData), {
+        id: doc2.id
+    });
+};
+var extractSiteData = function(doc2) {
+    var _data_updated, _data_created;
+    var data = doc2.data();
+    var dateUpdated = new Date(((_data_updated = data.updated) === null || _data_updated === void 0 ? void 0 : _data_updated.seconds) * 1e3 + data.updated.nanoseconds / 1e6);
+    var dateCreated = new Date(((_data_created = data.created) === null || _data_created === void 0 ? void 0 : _data_created.seconds) * 1e3 + data.created.nanoseconds / 1e6);
+    return _object_spread_props(_object_spread({}, data), {
+        id: doc2.id,
+        created: moment(dateCreated).format("DD.MM.YYYY - HH:mm"),
+        updated: moment(dateUpdated).format("DD.MM.YYYY - HH:mm")
+    });
+};
+var extractClientData = function(doc2) {
+    var _data_updated, _data_created;
+    var data = doc2.data();
+    var dateUpdated = new Date(((_data_updated = data.updated) === null || _data_updated === void 0 ? void 0 : _data_updated.seconds) * 1e3 + data.updated.nanoseconds / 1e6);
+    var dateCreated = new Date(((_data_created = data.created) === null || _data_created === void 0 ? void 0 : _data_created.seconds) * 1e3 + data.created.nanoseconds / 1e6);
+    return _object_spread_props(_object_spread({}, data), {
+        id: doc2.id,
+        created: moment(dateCreated).format("HH:mm  DD/MM/YY"),
+        updated: moment(dateUpdated).format("HH:mm  DD/MM/YY")
+    });
+};
+var extractBoardsData = function(doc2) {
+    var _data_uploaded;
+    var data = doc2.data();
+    var dateUploaded = typeof data.uploaded === "string" ? data.uploaded : moment.unix((_data_uploaded = data.uploaded) === null || _data_uploaded === void 0 ? void 0 : _data_uploaded.seconds).format("DD/MM/YY HH:mm");
+    return _object_spread_props(_object_spread({}, data), {
+        id: doc2.id,
+        uploaded: dateUploaded
+    });
+};
+var extractCarsData = function(doc2) {
+    var carData = doc2.data();
+    var icon;
+    var gov_info = carData.gov_info;
+    if (gov_info) {
+        if (carData.icon) {
+            icon = carData.icon;
+        } else if (gov_info.vehicle_type === "atv") {
+            icon = "truck";
+        } else if (gov_info.vehicle_type === "motorcycle") {
+            icon = "motorcycle";
+        } else {
+            icon = "car";
+        }
+    } else {
+        icon = "car";
+    }
+    return _object_spread_props(_object_spread({}, carData), {
+        id: doc2.id,
+        brand: carData.brand || carData.manufacturer,
+        car_number: carData.carId,
+        icon: icon
+    });
+};
+var extractCanbusData = function(doc2) {
+    var data = doc2.data();
+    var newDate = null;
+    if (data.timestamp && typeof data.timestamp.seconds === "number" && data.timestamp.seconds > 0) {
+        newDate = new Date(data.timestamp.seconds * 1e3);
+    }
+    return _object_spread_props(_object_spread({}, data), {
+        date_ui: newDate ? moment(newDate).format("DD/MM/YYYY - HH:mm") : "N/A"
+    });
+};
+var extractLocationData = function(doc2) {
+    var locationData = doc2.data();
+    var latitude = locationData.latitude, longitude = locationData.longitude, spd = locationData.spd, timestamp = locationData.timestamp, prev_latitude = locationData.prev_latitude, prev_longitude = locationData.prev_longitude;
+    return _object_spread_props(_object_spread({}, locationData), {
+        id: doc2.id,
+        lat: latitude,
+        lng: longitude,
+        prev_lat: prev_latitude,
+        prev_lng: prev_longitude,
+        timestamp: timestamp === null || timestamp === void 0 ? void 0 : timestamp.seconds,
+        spd: Number(spd).toFixed(0)
+    });
+};
+var get_all_documents = /*#__PURE__*/ function() {
+    var _ref = _async_to_generator(function(collection_path) {
+        var snapshot2, documents, error;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    return [
+                        4,
+                        getDocs(collection(db, collection_path))
+                    ];
+                case 1:
+                    snapshot2 = _state.sent();
+                    documents = snapshot2.docs.map(function(doc2) {
+                        return simpleExtractData(doc2);
+                    });
+                    return [
+                        2,
+                        documents
+                    ];
+                case 2:
+                    error = _state.sent();
+                    return [
+                        2,
+                        []
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function get_all_documents(collection_path) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var get_document_by_id = /*#__PURE__*/ function() {
+    var _ref = _async_to_generator(function(collection_path, doc_id) {
+        var doc_ref, doc_snap, error;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    doc_ref = doc(db, collection_path, doc_id);
+                    return [
+                        4,
+                        getDoc(doc_ref)
+                    ];
+                case 1:
+                    doc_snap = _state.sent();
+                    if (!doc_snap.exists()) {
+                        throw new Error("Document not found, document id: " + doc_id);
+                    }
+                    return [
+                        2,
+                        simpleExtractData(doc_snap)
+                    ];
+                case 2:
+                    error = _state.sent();
+                    console.error("Error from get_document_by_id", error);
+                    return [
+                        2,
+                        null
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function get_document_by_id(collection_path, doc_id) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var set_document = /*#__PURE__*/ function() {
+    var _ref = _async_to_generator(function(collection_path, doc_id, data) {
+        var doc_ref, error;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    doc_ref = doc(db, collection_path, doc_id);
+                    return [
+                        4,
+                        setDoc(doc_ref, data, {
+                            merge: true
+                        })
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2,
+                        true
+                    ];
+                case 2:
+                    error = _state.sent();
+                    console.error("Failed to create document by id: ".concat(doc_id, " in collection: ").concat(collection_path), {
+                        error: error,
+                        data: data
+                    });
+                    return [
+                        2,
+                        false
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function set_document(collection_path, doc_id, data) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var add_document = /*#__PURE__*/ function() {
+    var _ref = _async_to_generator(function(collection_path, data) {
+        var include_id, col_ref, doc_ref, error;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    include_id = _arguments.length > 2 && _arguments[2] !== void 0 ? _arguments[2] : false;
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        5,
+                        ,
+                        6
+                    ]);
+                    col_ref = collection(db, collection_path);
+                    return [
+                        4,
+                        addDoc(col_ref, data)
+                    ];
+                case 2:
+                    doc_ref = _state.sent();
+                    if (!include_id) return [
+                        3,
+                        4
+                    ];
+                    return [
+                        4,
+                        setDoc(doc_ref, _object_spread_props(_object_spread({}, data), {
+                            id: doc_ref.id
+                        }), {
+                            merge: true
+                        })
+                    ];
+                case 3:
+                    _state.sent();
+                    _state.label = 4;
+                case 4:
+                    return [
+                        2,
+                        true
+                    ];
+                case 5:
+                    error = _state.sent();
+                    console.error("Failed to create document in collection: ".concat(collection_path), error);
+                    return [
+                        2,
+                        false
+                    ];
+                case 6:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function add_document(collection_path, data) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var delete_document = /*#__PURE__*/ function() {
+    var _ref = _async_to_generator(function(collection_path, doc_id) {
+        var doc_ref, error;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    doc_ref = doc(db, collection_path, doc_id);
+                    return [
+                        4,
+                        deleteDoc(doc_ref)
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2,
+                        true
+                    ];
+                case 2:
+                    error = _state.sent();
+                    console.error("Failed to delete document with id ".concat(doc_id, " from collection ").concat(collection_path), error);
+                    return [
+                        2,
+                        false
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function delete_document(collection_path, doc_id) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var query_document = /*#__PURE__*/ function() {
+    var _ref = _async_to_generator(function(collection_path, field_name, operator, value) {
+        var ignore_log, q, query_snapshot, documents, error;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    ignore_log = _arguments.length > 4 && _arguments[4] !== void 0 ? _arguments[4] : false;
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        3,
+                        ,
+                        4
+                    ]);
+                    q = query(collection(db, collection_path), where(field_name, operator, value));
+                    return [
+                        4,
+                        getDocs(q)
+                    ];
+                case 2:
+                    query_snapshot = _state.sent();
+                    documents = query_snapshot.docs.map(function(doc2) {
+                        return simpleExtractData(doc2);
+                    });
+                    if (documents.length < 1) {
+                        throw new Error("No data to return from: \ncollection: ".concat(collection_path, ", \nfield_name: ").concat(field_name, ", \noperator: ").concat(operator, ", \nvalue: ").concat(value));
+                    }
+                    return [
+                        2,
+                        documents[0]
+                    ];
+                case 3:
+                    error = _state.sent();
+                    if (!ignore_log) {
+                        console.error("Error querying document:", error);
+                    }
+                    return [
+                        2,
+                        null
+                    ];
+                case 4:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function query_document(collection_path, field_name, operator, value) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var query_documents = /*#__PURE__*/ function() {
+    var _ref = _async_to_generator(function(collection_path, field_name, operator, value) {
+        var q, query_snapshot, documents, error;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    q = query(collection(db, collection_path), where(field_name, operator, value));
+                    return [
+                        4,
+                        getDocs(q)
+                    ];
+                case 1:
+                    query_snapshot = _state.sent();
+                    documents = query_snapshot.docs.map(function(doc2) {
+                        return simpleExtractData(doc2);
+                    });
+                    return [
+                        2,
+                        documents
+                    ];
+                case 2:
+                    error = _state.sent();
+                    console.error("Error querying documents: ".concat(collection_path, " - ").concat(field_name, " - ").concat(operator, " - ").concat(value, " "), error);
+                    return [
+                        2,
+                        []
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function query_documents(collection_path, field_name, operator, value) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var query_documents_by_conditions = /*#__PURE__*/ function() {
+    var _ref = _async_to_generator(function(collection_path, where_conditions) {
+        var db_query, query_snapshot, documents, error;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    db_query = collection(db, collection_path);
+                    where_conditions.forEach(function(condition) {
+                        db_query = query(db_query, where(condition.field_name, condition.operator, condition.value));
+                    });
+                    return [
+                        4,
+                        getDocs(db_query)
+                    ];
+                case 1:
+                    query_snapshot = _state.sent();
+                    documents = query_snapshot.docs.map(function(doc2) {
+                        return simpleExtractData(doc2);
+                    });
+                    return [
+                        2,
+                        documents
+                    ];
+                case 2:
+                    error = _state.sent();
+                    console.error("Error querying documents: ".concat(collection_path, " - ").concat(JSON.stringify(where_conditions), " "), error);
+                    return [
+                        2,
+                        []
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function query_documents_by_conditions(collection_path, where_conditions) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var query_document_by_conditions = /*#__PURE__*/ function() {
+    var _ref = _async_to_generator(function(collection_path, where_conditions) {
+        var db_query, query_snapshot, documents, error;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    db_query = collection(db, collection_path);
+                    where_conditions.forEach(function(condition) {
+                        db_query = query(db_query, where(condition.field_name, condition.operator, condition.value));
+                    });
+                    return [
+                        4,
+                        getDocs(db_query)
+                    ];
+                case 1:
+                    query_snapshot = _state.sent();
+                    documents = query_snapshot.docs.map(function(doc2) {
+                        return simpleExtractData(doc2);
+                    });
+                    if (!documents[0]) {
+                        throw new Error("No data returned from DB");
+                    }
+                    return [
+                        2,
+                        documents[0]
+                    ];
+                case 2:
+                    error = _state.sent();
+                    console.error("Error querying documents: ".concat(collection_path, " - ").concat(JSON.stringify(where_conditions), " "), error);
+                    return [
+                        2,
+                        null
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function query_document_by_conditions(collection_path, where_conditions) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var snapshot = function(config, snapshotsFirstTime) {
+    var resolvePromise;
+    var isResolved = false;
+    var promise = new Promise(function(resolve) {
+        console.log("==> ".concat(config.collectionName, " subscribed."));
+        resolvePromise = function() {
+            if (!isResolved) {
+                isResolved = true;
+                resolve();
+            }
+        };
+    });
+    var collectionRef = collection(db, config.collectionName);
+    if (config.conditions) {
+        config.conditions.forEach(function(condition) {
+            collectionRef = query(collectionRef, where(condition.field_name, condition.operator, condition.value));
+        });
+    }
+    if (config.orderBy) {
+        config.orderBy.forEach(function(order) {
+            collectionRef = query(collectionRef, orderBy(order.fieldName, order.direction));
+        });
+    }
+    var unsubscribe = onSnapshot(collectionRef, function(snapshot2) {
+        if (!snapshotsFirstTime.includes(config.collectionName)) {
+            var _config_onFirstTime, _config_extraParsers;
+            snapshotsFirstTime.push(config.collectionName);
+            var documents = snapshot2.docs.map(function(doc2) {
+                return simpleExtractData(doc2);
+            });
+            (_config_onFirstTime = config.onFirstTime) === null || _config_onFirstTime === void 0 ? void 0 : _config_onFirstTime.call(config, documents, config);
+            (_config_extraParsers = config.extraParsers) === null || _config_extraParsers === void 0 ? void 0 : _config_extraParsers.forEach(function(extraParser) {
+                var _extraParser_onFirstTime;
+                (_extraParser_onFirstTime = extraParser.onFirstTime) === null || _extraParser_onFirstTime === void 0 ? void 0 : _extraParser_onFirstTime.call(extraParser, documents, config);
+            });
+            resolvePromise();
+        } else {
+            var _config_onAdd, _config_onModify, _config_onRemove, _config_extraParsers1;
+            var addedDocs = [];
+            var modifiedDocs = [];
+            var removedDocs = [];
+            snapshot2.docChanges().forEach(function(change) {
+                if (change.type === "added") {
+                    addedDocs.push(simpleExtractData(change.doc));
+                } else if (change.type === "modified") {
+                    modifiedDocs.push(simpleExtractData(change.doc));
+                } else if (change.type === "removed") {
+                    removedDocs.push(simpleExtractData(change.doc));
+                }
+            });
+            addedDocs.length && ((_config_onAdd = config.onAdd) === null || _config_onAdd === void 0 ? void 0 : _config_onAdd.call(config, addedDocs, config));
+            modifiedDocs.length && ((_config_onModify = config.onModify) === null || _config_onModify === void 0 ? void 0 : _config_onModify.call(config, modifiedDocs, config));
+            removedDocs.length && ((_config_onRemove = config.onRemove) === null || _config_onRemove === void 0 ? void 0 : _config_onRemove.call(config, removedDocs, config));
+            (_config_extraParsers1 = config.extraParsers) === null || _config_extraParsers1 === void 0 ? void 0 : _config_extraParsers1.forEach(function(extraParser) {
+                var _extraParser_onAdd, _extraParser_onModify, _extraParser_onRemove;
+                addedDocs.length && ((_extraParser_onAdd = extraParser.onAdd) === null || _extraParser_onAdd === void 0 ? void 0 : _extraParser_onAdd.call(extraParser, addedDocs, config));
+                modifiedDocs.length && ((_extraParser_onModify = extraParser.onModify) === null || _extraParser_onModify === void 0 ? void 0 : _extraParser_onModify.call(extraParser, modifiedDocs, config));
+                removedDocs.length && ((_extraParser_onRemove = extraParser.onRemove) === null || _extraParser_onRemove === void 0 ? void 0 : _extraParser_onRemove.call(extraParser, removedDocs, config));
+            });
+        }
+    }, function(error) {
+        console.error("Error listening to collection: ".concat(config.collectionName), error);
+        resolvePromise();
+    });
+    return {
+        promise: promise,
+        unsubscribe: unsubscribe
+    };
+};
+var snapshotDocument = function(config, snapshotsFirstTime) {
+    var resolvePromise;
+    var isResolved = false;
+    var promise = new Promise(function(resolve) {
+        console.log("==> Document in ".concat(config.collectionName, " subscribed."));
+        resolvePromise = function() {
+            if (!isResolved) {
+                isResolved = true;
+                resolve();
+            }
+        };
+    });
+    var documentRef = doc(db, config.collectionName, config.documentId);
+    var unsubscribe = onSnapshot(documentRef, function(docSnapshot) {
+        if (!snapshotsFirstTime.includes(config.collectionName)) {
+            snapshotsFirstTime.push(config.collectionName);
+            if (docSnapshot.exists()) {
+                var document2 = simpleExtractData(docSnapshot);
+                if (checkConditions(document2, config.conditions)) {
+                    var _config_onFirstTime, _config_extraParsers;
+                    (_config_onFirstTime = config.onFirstTime) === null || _config_onFirstTime === void 0 ? void 0 : _config_onFirstTime.call(config, [
+                        document2
+                    ], config);
+                    (_config_extraParsers = config.extraParsers) === null || _config_extraParsers === void 0 ? void 0 : _config_extraParsers.forEach(function(extraParser) {
+                        var _extraParser_onFirstTime;
+                        (_extraParser_onFirstTime = extraParser.onFirstTime) === null || _extraParser_onFirstTime === void 0 ? void 0 : _extraParser_onFirstTime.call(extraParser, [
+                            document2
+                        ], config);
+                    });
+                } else {
+                    console.warn("Document in ".concat(config.collectionName, " does not meet conditions."));
+                }
+            } else {
+                console.warn("Document not found in ".concat(config.collectionName, "."));
+            }
+            resolvePromise();
+        } else {
+            if (docSnapshot.exists()) {
+                var document21 = simpleExtractData(docSnapshot);
+                if (checkConditions(document21, config.conditions)) {
+                    var _config_onModify, _config_extraParsers1;
+                    (_config_onModify = config.onModify) === null || _config_onModify === void 0 ? void 0 : _config_onModify.call(config, [
+                        document21
+                    ], config);
+                    (_config_extraParsers1 = config.extraParsers) === null || _config_extraParsers1 === void 0 ? void 0 : _config_extraParsers1.forEach(function(extraParser) {
+                        var _extraParser_onModify;
+                        (_extraParser_onModify = extraParser.onModify) === null || _extraParser_onModify === void 0 ? void 0 : _extraParser_onModify.call(extraParser, [
+                            document21
+                        ], config);
+                    });
+                }
+            } else {
+                var _config_onRemove, _config_extraParsers2;
+                (_config_onRemove = config.onRemove) === null || _config_onRemove === void 0 ? void 0 : _config_onRemove.call(config, [], config);
+                (_config_extraParsers2 = config.extraParsers) === null || _config_extraParsers2 === void 0 ? void 0 : _config_extraParsers2.forEach(function(extraParser) {
+                    var _extraParser_onRemove;
+                    (_extraParser_onRemove = extraParser.onRemove) === null || _extraParser_onRemove === void 0 ? void 0 : _extraParser_onRemove.call(extraParser, [], config);
+                });
+            }
+        }
+    }, function(error) {
+        console.error("Error listening to document in ".concat(config.collectionName, ":"), error);
+        resolvePromise();
+    });
+    return {
+        promise: promise,
+        unsubscribe: unsubscribe
+    };
+};
+var checkConditions = function(document2, conditions) {
+    if (!conditions || conditions.length === 0) return true;
+    return conditions.every(function(condition) {
+        var fieldValue = document2[condition.field_name];
+        switch(condition.operator){
+            case "==":
+                return fieldValue === condition.value;
+            case "!=":
+                return fieldValue !== condition.value;
+            case "<":
+                return fieldValue < condition.value;
+            case "<=":
+                return fieldValue <= condition.value;
+            case ">":
+                return fieldValue > condition.value;
+            case ">=":
+                return fieldValue >= condition.value;
+            case "array-contains":
+                return Array.isArray(fieldValue) && fieldValue.includes(condition.value);
+            default:
+                return false;
+        }
+    });
+};
+var cleanNxSites = /*#__PURE__*/ function() {
+    var _ref = _async_to_generator(function() {
+        var clients, sites, allSitesToDelete;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        get_all_documents("nx-clients")
+                    ];
+                case 1:
+                    clients = _state.sent().map(function(v) {
+                        return v.id;
+                    });
+                    return [
+                        4,
+                        get_all_documents("nx-sites")
+                    ];
+                case 2:
+                    sites = _state.sent();
+                    allSitesToDelete = sites.filter(function(v) {
+                        return !clients.includes(v.client);
+                    });
+                    console.log("allSitesToDelete", allSitesToDelete);
+                    allSitesToDelete.forEach(/*#__PURE__*/ function() {
+                        var _ref = _async_to_generator(function(v) {
+                            return _ts_generator(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        return [
+                                            4,
+                                            delete_document("nx-sites", v.id)
+                                        ];
+                                    case 1:
+                                        _state.sent();
+                                        console.log("Site ".concat(v.id, " deleted."));
+                                        return [
+                                            2
+                                        ];
+                                }
+                            });
+                        });
+                        return function(v) {
+                            return _ref.apply(this, arguments);
+                        };
+                    }());
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function cleanNxSites() {
+        return _ref.apply(this, arguments);
+    };
+}();
+// src/helpers/global.ts
+import { CountryOptions } from "akeyless-types-commons";
+import axios from "axios";
+// src/helpers/phoneNumber.ts
+import { parsePhoneNumberFromString } from "libphonenumber-js";
+var isInternational = function(phone_number) {
+    return phone_number.startsWith("+");
+};
+var isInternationalIsraelPhone = function(phone_number) {
+    return phone_number.startsWith("+9725");
+};
+var local_israel_phone_format = function(international_number) {
+    return international_number.replace("+972", "0");
+};
+var international_israel_phone_format = function(phone) {
+    var validNumber = phone.slice(1, phone.length);
+    return "+972".concat(validNumber);
+};
+var displayFormatPhoneNumber = function(phoneNumber) {
+    if (isInternational(phoneNumber)) {
+        var phoneNumberObject = parsePhoneNumberFromString(phoneNumber);
+        if (!phoneNumberObject) {
+            return phoneNumber;
+        }
+        return phoneNumberObject.formatInternational().replace(/\s/g, "");
+    }
+    return phoneNumber.replace(/(\d{3})(\d{3})(\d{4})/, "$1-$2-$3");
+};
+var is_iccid = function(number) {
+    if (number.length < 19 || number.length > 22) return false;
+    if (!/^\d+$/.test(number)) return false;
+    if (!number.startsWith("89")) return false;
+    return true;
+};
+// src/helpers/global.ts
+import { isEqual } from "lodash";
+var calculateBearing = function(startLat, startLng, endLat, endLng) {
+    if (startLat === endLat || startLng === endLng) {
+        return 0;
+    }
+    if (startLat === void 0 || startLng === void 0 || endLat === void 0 || endLng === void 0) {
+        return 0;
+    }
+    var startLatRad = startLat * Math.PI / 180;
+    var startLngRad = startLng * Math.PI / 180;
+    var endLatRad = endLat * Math.PI / 180;
+    var endLngRad = endLng * Math.PI / 180;
+    var dLon = endLngRad - startLngRad;
+    var y = Math.sin(dLon) * Math.cos(endLatRad);
+    var x = Math.cos(startLatRad) * Math.sin(endLatRad) - Math.sin(startLatRad) * Math.cos(endLatRad) * Math.cos(dLon);
+    var bearing = Math.atan2(y, x) * 180 / Math.PI;
+    return (bearing + 360) % 360;
+};
+var renderOnce = function() {
+    return true;
+};
+var propsAreEqual = function(prevProps, nextProps) {
+    return isEqual(prevProps, nextProps);
+};
+var getUserCountryByIp = /*#__PURE__*/ function() {
+    var _ref = _async_to_generator(function() {
+        var response, error;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    return [
+                        4,
+                        axios.get("https://ipapi.co/json/")
+                    ];
+                case 1:
+                    response = _state.sent();
+                    return [
+                        2,
+                        (response.data.country_code || CountryOptions.IL).toLowerCase()
+                    ];
+                case 2:
+                    error = _state.sent();
+                    console.error("Error fetching Country:", error);
+                    return [
+                        2,
+                        CountryOptions.IL
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function getUserCountryByIp() {
+        return _ref.apply(this, arguments);
+    };
+}();
+var parsePermissions = function(object) {
+    if (!(object === null || object === void 0 ? void 0 : object.features)) {
+        return {};
+    }
+    var features = object.features;
+    var result = {};
+    features.forEach(function(feature) {
+        if (!feature.includes("__")) {
+            return;
+        }
+        var _feature_split = _sliced_to_array(feature.split("__"), 2), featureType = _feature_split[0], featureName = _feature_split[1];
+        if (!featureType || !featureName) {
+            return;
+        }
+        if (!result[featureType]) {
+            result[featureType] = {};
+        }
+        result[featureType][featureName] = true;
+    });
+    return result;
+};
+var initializeUserPermissions = /*#__PURE__*/ function() {
+    var _ref = _async_to_generator(function(param) {
+        var phoneNumber, firstTimeArray, getUpdatePermissions, unsubscribe, permissions, _snapshot, promise, unsubscribeSnapshot, error;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    phoneNumber = param.phoneNumber, firstTimeArray = param.firstTimeArray, getUpdatePermissions = param.getUpdatePermissions;
+                    unsubscribe = null;
+                    permissions = {};
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        3,
+                        ,
+                        4
+                    ]);
+                    _snapshot = snapshot({
+                        collectionName: "nx-users",
+                        conditions: [
+                            {
+                                field_name: "phone_number",
+                                operator: "in",
+                                value: [
+                                    phoneNumber,
+                                    local_israel_phone_format(phoneNumber)
+                                ]
+                            }
+                        ],
+                        onFirstTime: function(docs) {
+                            if (!docs.length) {
+                                throw new Error("User not found");
+                            }
+                            permissions = parsePermissions(docs[0]);
+                            getUpdatePermissions(parsePermissions(docs[0]));
+                        },
+                        onModify: function(docs) {
+                            getUpdatePermissions(parsePermissions(docs[0]));
+                        }
+                    }, firstTimeArray), promise = _snapshot.promise, unsubscribeSnapshot = _snapshot.unsubscribe;
+                    unsubscribe = unsubscribeSnapshot;
+                    return [
+                        4,
+                        promise
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        2,
+                        {
+                            unsubscribe: unsubscribe,
+                            permissions: permissions
+                        }
+                    ];
+                case 3:
+                    error = _state.sent();
+                    if (unsubscribe) {
+                        unsubscribe();
+                    }
+                    console.error("Error initializing user permissions:", error.message);
+                    throw error;
+                case 4:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function initializeUserPermissions(_) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var userNameFormat = function(user) {
+    return "".concat((user === null || user === void 0 ? void 0 : user.first_name) || "", " ").concat((user === null || user === void 0 ? void 0 : user.last_name) || "").trim();
+};
+var multiStringFormat = function(str1, str2, str3) {
+    return "".concat(str1, " ").concat(str2 || "", " ").concat(str3 || "").trim();
+};
+var getLocationUrl = function(lang, lat) {
+    return "https://www.google.com/maps?q=".concat(lang, ",").concat(lat);
+};
+var isNodeEnv = typeof process !== "undefined" && process.env;
+var _ref = {
+    mode: isNodeEnv ? process.env.NEXT_PUBLIC_MODE : import.meta.env.VITE_MODE,
+    isLocal: (isNodeEnv ? process.env.NEXT_PUBLIC_IS_LOCAL : import.meta.env.VITE_is_local) === "true"
+}, mode = _ref.mode, isLocal = _ref.isLocal;
+// src/helpers/forms.ts
+import XRegExp from "xregexp";
+var textRegex = XRegExp("[^\\p{L}\\s-]", "gu");
+var numbersRegex = XRegExp("[^0-9\\s-+]", "g");
+var numbersOnlyRegex = XRegExp("[^0-9]", "g");
+var priceRegex = XRegExp("[^0-9.]", "g");
+var emailRegex = XRegExp("[^\\p{L}0-9.@\\s-]", "gu");
+var colorRegex = XRegExp("[^#0-9A-Fa-f]", "g");
+var carsRegex = XRegExp("[^\\p{L}0-9,_]", "gu");
+var textNumbersRegex = XRegExp("[^\\p{L}0-9\\s+\\-]", "gu");
+var addressRegex = XRegExp("[^\\p{L}0-9\\s.,+-\\-]", "gu");
+var chartsRegex = XRegExp("[^\\p{L}0-9\\s.,_@!+-\\-]", "gu");
+var handleChange = function(e) {
+    e.target.setCustomValidity("");
+    var validation = e.target.getAttribute("data-validation");
+    if (validation === "text") {
+        e.target.value = XRegExp.replace(e.target.value, textRegex, "");
+    } else if (validation === "numbers") {
+        e.target.value = XRegExp.replace(e.target.value, numbersRegex, "");
+    } else if (validation === "numbersOnly") {
+        e.target.value = XRegExp.replace(e.target.value, numbersOnlyRegex, "");
+    } else if (validation === "price") {
+        e.target.value = XRegExp.replace(e.target.value, priceRegex, "");
+    } else if (validation === "textNumbers") {
+        e.target.value = XRegExp.replace(e.target.value, textNumbersRegex, "");
+    } else if (validation === "email") {
+        e.target.value = XRegExp.replace(e.target.value, emailRegex, "");
+    } else if (validation === "color") {
+        e.target.value = XRegExp.replace(e.target.value, colorRegex, "");
+    } else if (validation === "address") {
+        e.target.value = XRegExp.replace(e.target.value, addressRegex, "");
+    } else if (validation === "cars") {
+        e.target.value = XRegExp.replace(e.target.value, carsRegex, "");
+    } else if (validation === "charts") {
+        e.target.value = XRegExp.replace(e.target.value, chartsRegex, "");
+    }
+};
+var handlePaste = function(e) {
+    var validation = e.currentTarget.getAttribute("data-validation");
+    var pasteData = e.clipboardData.getData("text");
+    if (validation === "text") {
+        pasteData = XRegExp.replace(pasteData, textRegex, "");
+    } else if (validation === "numbers") {
+        pasteData = XRegExp.replace(pasteData, numbersRegex, "");
+    } else if (validation === "numbersOnly") {
+        pasteData = XRegExp.replace(pasteData, numbersOnlyRegex, "");
+    } else if (validation === "price") {
+        pasteData = XRegExp.replace(pasteData, priceRegex, "");
+    } else if (validation === "textNumbers") {
+        pasteData = XRegExp.replace(pasteData, textNumbersRegex, "");
+    } else if (validation === "email") {
+        pasteData = XRegExp.replace(pasteData, emailRegex, "");
+    } else if (validation === "color") {
+        pasteData = XRegExp.replace(pasteData, colorRegex, "");
+    } else if (validation === "address") {
+        pasteData = XRegExp.replace(pasteData, addressRegex, "");
+    } else if (validation === "cars") {
+        pasteData = XRegExp.replace(pasteData, carsRegex, "");
+    } else if (validation === "charts") {
+        pasteData = XRegExp.replace(pasteData, chartsRegex, "");
+    }
+    e.preventDefault();
+    document.execCommand("insertText", false, pasteData);
+};
+var handleInvalid = function(e, requireError) {
+    e.target.setCustomValidity(requireError || "This filed is required !");
+};
+var useValidation = function(validationType, requireError) {
+    return {
+        onChange: handleChange,
+        onPaste: handlePaste,
+        onInvalid: function(e) {
+            return handleInvalid(e, requireError);
+        },
+        "data-validation": validationType
+    };
+};
+var getFormElementValue = function(form, name) {
+    var _form_elements_namedItem;
+    return ((_form_elements_namedItem = form.elements.namedItem(name)) === null || _form_elements_namedItem === void 0 ? void 0 : _form_elements_namedItem.value) || "";
+};
+var parseMultiSelectInput = function(input) {
+    var value = JSON.parse(input) || [];
+    return value.map(function(v) {
+        return v.value;
+    });
+};
+// src/helpers/store.ts
+var setState = function(updater, set, stateName) {
+    return set(function(state) {
+        return _define_property({}, stateName, typeof updater === "function" ? updater(state[stateName]) : updater);
+    });
+};
+var createSelectors = function(store) {
+    var selectors = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        var _loop = function() {
+            var k = _step.value;
+            selectors[k] = function() {
+                return store(function(s) {
+                    return s[k];
+                });
+            };
+        };
+        for(var _iterator = Object.keys(store.getState())[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return selectors;
+};
+var useStoreValues = function(store, keys) {
+    var result = {};
+    keys.forEach(function(key) {
+        result[key] = store.use[key]();
+    });
+    return result;
+};
+// src/lib/utils.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn() {
+    for(var _len = arguments.length, inputs = new Array(_len), _key = 0; _key < _len; _key++){
+        inputs[_key] = arguments[_key];
+    }
+    return twMerge(clsx(inputs));
+}
+// src/helpers/time_helpers.ts
+import { Timestamp as Timestamp2 } from "firebase/firestore";
+import moment2 from "moment-timezone";
+function timestamp_to_string(firebaseTimestamp, options) {
+    var date;
+    if (_instanceof(firebaseTimestamp, Timestamp2)) {
+        date = firebaseTimestamp.toDate();
+    } else if (_instanceof(firebaseTimestamp, Date)) {
+        date = firebaseTimestamp;
+    } else if (typeof firebaseTimestamp === "string") {
+        date = moment2.utc(firebaseTimestamp, (options === null || options === void 0 ? void 0 : options.fromFormat) || "DD/MM/YYYY HH:mm:ss").toDate();
+        if (isNaN(date.getTime())) {
+            throw new Error("Invalid date string format");
+        }
+    } else {
+        throw new Error("Invalid input: firebaseTimestamp must be a Timestamp, Date, or valid date string.");
+    }
+    if (options === null || options === void 0 ? void 0 : options.tz) {
+        var result = moment2(date).tz(options === null || options === void 0 ? void 0 : options.tz).format((options === null || options === void 0 ? void 0 : options.format) || "DD/MM/YYYY HH:mm:ss");
+        return result;
+    }
+    return moment2.utc(date).format((options === null || options === void 0 ? void 0 : options.format) || "DD/MM/YYYY HH:mm:ss");
+}
+function timestamp_to_millis(firebaseTimestamp) {
+    var timestamp = new Timestamp2(firebaseTimestamp === null || firebaseTimestamp === void 0 ? void 0 : firebaseTimestamp.seconds, firebaseTimestamp === null || firebaseTimestamp === void 0 ? void 0 : firebaseTimestamp.nanoseconds);
+    return timestamp.toMillis();
+}
+function sort_by_timestamp(a, b) {
+    var reverse = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    return reverse ? timestamp_to_millis(b) - timestamp_to_millis(a) : timestamp_to_millis(a) - timestamp_to_millis(b);
+}
+// src/helpers/api.ts
+import axios2 from "axios";
+var baseDomain = mode === "qa" ? "https://nx-api.xyz/api" : "https://nx-api.info/api";
+var devicesDomain = isLocal ? "http://localhost:9001/api/devices" : baseDomain + "/devices";
+var biDomain = isLocal ? "http://localhost:9002/api/bi" : baseDomain + "/bi";
+var callCenterDomain = isLocal ? "http://localhost:9003/api/call-center" : baseDomain + "/call-center";
+var akeylessOnlineDomain = mode === "qa" ? "https://akeyless-online.xyz" : "https://akeyless-online.info";
+var nx_api_call = /*#__PURE__*/ function() {
+    var _ref = _async_to_generator(function(serverName, method, url, data) {
+        var urlResult, headers, _tmp, _, response, error, _error_response;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        3,
+                        ,
+                        4
+                    ]);
+                    urlResult = "".concat(devicesDomain, "/").concat(url);
+                    switch(serverName){
+                        case "bi":
+                            urlResult = "".concat(biDomain, "/").concat(url);
+                            break;
+                        case "devices":
+                            urlResult = "".concat(devicesDomain, "/").concat(url);
+                            break;
+                        case "call-center":
+                            urlResult = "".concat(callCenterDomain, "/").concat(url);
+                            break;
+                        default:
+                            break;
+                    }
+                    _tmp = {};
+                    _ = "bearer ";
+                    return [
+                        4,
+                        auth.currentUser.getIdToken()
+                    ];
+                case 1:
+                    headers = (_tmp.authorization = _ + _state.sent(), _tmp);
+                    return [
+                        4,
+                        axios2({
+                            method: method,
+                            url: urlResult,
+                            headers: headers,
+                            data: data
+                        })
+                    ];
+                case 2:
+                    response = _state.sent();
+                    return [
+                        2,
+                        response.data || null
+                    ];
+                case 3:
+                    error = _state.sent();
+                    console.error("Error from nx_api_call: ".concat(JSON.stringify({
+                        serverName: serverName,
+                        method: method,
+                        url: url,
+                        data: data
+                    })), (error === null || error === void 0 ? void 0 : (_error_response = error.response) === null || _error_response === void 0 ? void 0 : _error_response.data) || error);
+                    return [
+                        2,
+                        null
+                    ];
+                case 4:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function nx_api_call(serverName, method, url, data) {
+        return _ref.apply(this, arguments);
+    };
+}();
+export { add_document, addressRegex, akeylessOnlineDomain, auth, baseDomain, biDomain, calculateBearing, callCenterDomain, carsRegex, chartsRegex, cleanNxSites, cn, collections, colorRegex, createSelectors, db, delete_document, devicesDomain, displayFormatPhoneNumber, emailRegex, extractAlertsData, extractBoardsData, extractCanbusData, extractCarsData, extractClientData, extractLocationData, extractSiteData, fire_base_TIME_TEMP, formatCarNumber, getFormElementValue, getLocationUrl, getUserCountryByIp, get_all_documents, get_document_by_id, handleChange, handleInvalid, handlePaste, initializeUserPermissions, international_israel_phone_format, isInternational, isInternationalIsraelPhone, isLocal, isNodeEnv, is_iccid, local_israel_phone_format, mode, multiStringFormat, numbersOnlyRegex, numbersRegex, nx_api_call, parseMultiSelectInput, parsePermissions, priceRegex, propsAreEqual, query_document, query_document_by_conditions, query_documents, query_documents_by_conditions, renderOnce, setState, set_document, simpleExtractData, snapshot, snapshotDocument, sort_by_timestamp, storage, textNumbersRegex, textRegex, timestamp_to_millis, timestamp_to_string, useStoreValues, useValidation, userNameFormat };
+//# sourceMappingURL=index.mjs.map