@michalrakus/x-react-web-lib 1.32.8 → 1.32.9

package/lib/components/XLazyDataTable/XLazyDataTable.js

@@ -544,6 +544,9 @@ var XLazyDataTable = function (props) {
                     setFiltersAfterFiltering(filters);
                     setFtsInputValueAfterFiltering(ftsInputValue ? __assign({}, ftsInputValue) : undefined);
                     setOptionalCustomFilterAfterFiltering(optionalCustomFilter);
+                    // async check for new version - the purpose is to get new version of app to the browser (if available) in short time (10 minutes)
+                    // (if there is no new version, the check will run async (as the last operation) and nothing will happen)
+                    XUtils_1.XUtils.reloadIfNewVersion();
                     return [2 /*return*/];
             }
         });

package/lib/components/XUtils.d.ts

@@ -49,6 +49,8 @@ export declare class XUtils {
     static csvEncodingOptions: CsvEncoding[];
     static remSize: number | null;
     static FIELD_LABEL_WIDTH: string;
+    static lastVersionCheckTimestamp: number | null;
+    static VERSION_CHECK_PERIOD: number;
     static demo(): boolean;
     static isMobile(): boolean;
     static mobileCssSuffix(): string;
@@ -108,4 +110,8 @@ export declare class XUtils {
     static saveValueIntoStorage(key: string, value: any): void;
     static getValueFromStorage(key: string, initValue: any): any;
     static removeValueFromStorage(key: string): void;
+    static reloadIfNewVersion(): void;
+    static reloadIfNewVersionNow(): Promise<void>;
+    static isNewVersion(): Promise<boolean>;
+    static reload(): void;
 }

package/lib/components/XUtils.js

@@ -749,6 +749,95 @@ var XUtils = /** @class */ (function () {
     XUtils.removeValueFromStorage = function (key) {
         sessionStorage.removeItem(key);
     };
+    // hleper method used for items of XLazyDataTable (shortcut ldt)
+    // static getValueFromStorageLdt(entity: string, stateKeySuffix: XStateKeySuffix, initValue: any): any {
+    //     return XUtils.getValueFromStorage(`xldt-state-${entity}-${stateKeySuffix}`, initValue);
+    // }
+    XUtils.reloadIfNewVersion = function () {
+        // to save requests, we check for new version only if 10 minutes (or another time period) are passed from the last check
+        // we could use method setInterval (timer) and run check exactly 10 minutes but the disadvantage is that then there will be
+        // some processing during idle time and that can exhaust battery on mobile phone (mobile phone will not go to sleeping mode) - is it true?
+        var currentTimestamp = Date.now(); // Current time
+        if (XUtils.lastVersionCheckTimestamp === null || currentTimestamp - XUtils.lastVersionCheckTimestamp > XUtils.VERSION_CHECK_PERIOD) {
+            XUtils.reloadIfNewVersionNow();
+            XUtils.lastVersionCheckTimestamp = currentTimestamp;
+        }
+    };
+    XUtils.reloadIfNewVersionNow = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, XUtils.isNewVersion()];
+                    case 1:
+                        if (_a.sent()) {
+                            alert("New version was released. Application will be restarted.");
+                            XUtils.reload();
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    XUtils.isNewVersion = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, text, r, remoteMainScript, localMainScript, scripts, scripts_1, scripts_1_1, script, rl, err_1;
+            var e_7, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, fetch("index.html", { method: 'GET', cache: "no-store" })];
+                    case 1:
+                        response = _b.sent();
+                        return [4 /*yield*/, response.text()];
+                    case 2:
+                        text = _b.sent();
+                        r = /^.*<script.*\/(main.*\.js).*$/gim.exec(text);
+                        if (!r || r.length < 2) {
+                            return [2 /*return*/, false];
+                        }
+                        remoteMainScript = r.length > 1 ? r[1] : null;
+                        if (remoteMainScript === null) {
+                            return [2 /*return*/, false];
+                        }
+                        localMainScript = null;
+                        scripts = document.body.getElementsByTagName('script');
+                        try {
+                            for (scripts_1 = __values(scripts), scripts_1_1 = scripts_1.next(); !scripts_1_1.done; scripts_1_1 = scripts_1.next()) {
+                                script = scripts_1_1.value;
+                                rl = /^.*\/(main.*\.js).*$/gim.exec(script.src);
+                                if (!rl || rl.length < 2) {
+                                    continue;
+                                }
+                                localMainScript = rl[1];
+                                break;
+                            }
+                        }
+                        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                        finally {
+                            try {
+                                if (scripts_1_1 && !scripts_1_1.done && (_a = scripts_1.return)) _a.call(scripts_1);
+                            }
+                            finally { if (e_7) throw e_7.error; }
+                        }
+                        if (localMainScript === null) {
+                            return [2 /*return*/, false];
+                        }
+                        return [2 /*return*/, remoteMainScript !== localMainScript];
+                    case 3:
+                        err_1 = _b.sent();
+                        console.log(err_1);
+                        return [2 /*return*/, false];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    XUtils.reload = function () {
+        // page reload (like pressing F5 or Enter on url bar)
+        // warning - if user has typed some data in form, the data will be lost
+        window.location.reload();
+    };
     XUtils.dropdownEmptyOptionValue = " ";
     XUtils.xBackendUrl = undefined;
     // nacachovany XToken - na rozlicnych miestach potrebujeme vediet uzivatela
@@ -766,6 +855,8 @@ var XUtils = /** @class */ (function () {
     XUtils.remSize = null;
     // konstanty (zatial takto jednoducho)
     XUtils.FIELD_LABEL_WIDTH = '10.5rem';
+    XUtils.lastVersionCheckTimestamp = null;
+    XUtils.VERSION_CHECK_PERIOD = 10 * 60 * 1000; // 10 minutes in milliseconds
     return XUtils;
 }());
 exports.XUtils = XUtils;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@michalrakus/x-react-web-lib",
-  "version": "1.32.8",
+  "version": "1.32.9",
   "description": "",
   "scripts": {
     "clean": "rimraf lib",