mftsccs-browser 1.1.29-beta → 1.1.30-beta

package/dist/main.bundle.js

@@ -475,46 +475,128 @@ var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _argume
 
 function CreateTheGhostConceptApi(conceptData, connectionData) {
     return __awaiter(this, void 0, void 0, function* () {
-        let result = {
-            "concepts": [],
-            "connections": []
-        };
         try {
-            const myHeaders = new Headers();
-            let myBody = {
-                "concepts": conceptData,
-                "connections": connectionData
+            const CHUNK_SIZE = 1000;
+            let result = {
+                "concepts": [],
+                "connections": []
             };
-            myHeaders.set("Content-Type", "application/json");
-            myHeaders.set('Authorization', "Bearer " + _DataStructures_Security_TokenStorage__WEBPACK_IMPORTED_MODULE_1__.TokenStorage.BearerAccessToken);
-            myHeaders.set('Accept', 'application/json');
-            //  myHeaders.set('Randomizer', BaseUrl.BASE_RANDOMIZER.toString());
-            myHeaders.set('Randomizer', _DataStructures_BaseUrl__WEBPACK_IMPORTED_MODULE_0__.BaseUrl.getRandomizer().toString());
-            const response = yield fetch(_DataStructures_BaseUrl__WEBPACK_IMPORTED_MODULE_0__.BaseUrl.CreateGhostConceptApiUrl(), {
-                method: 'POST',
-                headers: myHeaders,
-                body: JSON.stringify(myBody),
-            });
-            if (!response.ok) {
-                (0,_Services_Common_ErrorPosting__WEBPACK_IMPORTED_MODULE_2__.HandleHttpError)(response);
-                throw new Error(`Error! status: ${response.status}`);
+            // strip data
+            const stripedConcept = yield stripTypeFromConceptOrConnection(conceptData);
+            const stripedConnection = yield stripTypeFromConceptOrConnection(connectionData);
+            // sync all in one request if data is less
+            if (conceptData.length + connectionData.length <= (CHUNK_SIZE * 2)) {
+                const response = yield syncConceptConnection(stripedConcept, stripedConnection);
+                if (Array.isArray(response === null || response === void 0 ? void 0 : response.concepts))
+                    result.concepts = [...result.concepts, ...response.concepts];
+                if (Array.isArray(response === null || response === void 0 ? void 0 : response.connections))
+                    result.connections = [...result.connections, ...response.connections];
+                return result;
+            }
+            // split data 
+            const splittedConcepts = chunkArrayByItemCount(stripedConcept, CHUNK_SIZE);
+            const splittedConnections = chunkArrayByItemCount(stripedConnection, CHUNK_SIZE);
+            const syncConceptPromises = [];
+            const syncConnectionPromises = [];
+            // sync concept
+            for (let i = 0; i < splittedConcepts.length; i++) {
+                const concepts = splittedConcepts[i];
+                syncConceptPromises.push(syncConceptConnection(concepts, []));
+            }
+            const conceptResponses = yield Promise.all(syncConceptPromises);
+            for (let i = 0; i < conceptResponses.length; i++) {
+                const conceptsRes = conceptResponses[i];
+                if (Array.isArray(conceptsRes === null || conceptsRes === void 0 ? void 0 : conceptsRes.concepts))
+                    result.concepts = [...result.concepts, ...conceptsRes.concepts];
+                if (Array.isArray(conceptsRes === null || conceptsRes === void 0 ? void 0 : conceptsRes.connections))
+                    result.connections = [...result.connections, ...conceptsRes.connections];
+            }
+            // sync connection
+            for (let i = 0; i < splittedConnections.length; i++) {
+                const connections = splittedConnections[i];
+                syncConnectionPromises.push(syncConceptConnection([], connections));
+            }
+            const connectionResponses = yield Promise.all(syncConnectionPromises);
+            for (let i = 0; i < connectionResponses.length; i++) {
+                const connectionsRes = connectionResponses[i];
+                if (Array.isArray(connectionsRes === null || connectionsRes === void 0 ? void 0 : connectionsRes.concepts))
+                    result.concepts = [...result.concepts, ...connectionsRes.concepts];
+                if (Array.isArray(connectionsRes === null || connectionsRes === void 0 ? void 0 : connectionsRes.connections))
+                    result.connections = [...result.connections, ...connectionsRes.connections];
             }
-            const resultString = yield response.json();
-            result.concepts = resultString.concepts;
-            result.connections = resultString.connections;
             return result;
         }
         catch (error) {
-            if (error instanceof Error) {
-                console.log('Create the concept api error message: ', error.message);
-            }
-            else {
-                console.log('Create the concept api unexpected error: ', error);
-            }
+            console.log(error);
             throw error;
         }
     });
 }
+/**
+ *
+ * @param concepts Concept[]
+ * @param connections Connection[]
+ * @returns Promise<{concepts: [], connections: []}>
+ */
+const syncConceptConnection = (concepts, connections) => __awaiter(void 0, void 0, void 0, function* () {
+    let result = {
+        "concepts": [],
+        "connections": []
+    };
+    try {
+        const myHeaders = new Headers();
+        let myBody = {
+            "concepts": concepts,
+            "connections": connections
+        };
+        myHeaders.set("Content-Type", "application/json");
+        myHeaders.set('Authorization', "Bearer " + _DataStructures_Security_TokenStorage__WEBPACK_IMPORTED_MODULE_1__.TokenStorage.BearerAccessToken);
+        myHeaders.set('Accept', 'application/json');
+        //  myHeaders.set('Randomizer', BaseUrl.BASE_RANDOMIZER.toString());
+        myHeaders.set('Randomizer', _DataStructures_BaseUrl__WEBPACK_IMPORTED_MODULE_0__.BaseUrl.getRandomizer().toString());
+        const response = yield fetch(_DataStructures_BaseUrl__WEBPACK_IMPORTED_MODULE_0__.BaseUrl.CreateGhostConceptApiUrl(), {
+            method: 'POST',
+            headers: myHeaders,
+            body: JSON.stringify(myBody),
+        });
+        if (!response.ok) {
+            (0,_Services_Common_ErrorPosting__WEBPACK_IMPORTED_MODULE_2__.HandleHttpError)(response);
+            throw new Error(`Error! status: ${response.status}`);
+        }
+        const resultString = yield response.json();
+        result.concepts = resultString.concepts;
+        result.connections = resultString.connections;
+        return result;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.log('Create the concept api error message: ', error.message);
+        }
+        else {
+            console.log('Create the concept api unexpected error: ', error);
+        }
+        throw error;
+    }
+});
+// Function to split an array into chunks of 1024 items (500KB per chunk)
+function chunkArrayByItemCount(array, itemsPerChunk) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += itemsPerChunk) {
+        const chunk = array.slice(i, i + itemsPerChunk); // Slice the array into smaller chunks
+        chunks.push(chunk);
+    }
+    return chunks;
+}
+// method to strip type object from concept or connection
+const stripTypeFromConceptOrConnection = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (items = []) {
+    return yield Promise.all(items.map(item => {
+        let newItem = JSON.parse(JSON.stringify(item));
+        delete newItem.type;
+        delete newItem.ofConcept;
+        delete newItem.toConcept;
+        return newItem;
+    }));
+});
 
 
 /***/ }),
@@ -9872,7 +9954,7 @@ function storeToDatabase(databaseName, object) {
  */
 function UpdateToDatabase(databaseName, object) {
     return new Promise(function (resolve, reject) {
-        console.log("this is wriring to the database local", object);
+        // console.log("this is wriring to the database local", object);
         openDatabase(databaseName).then((db) => {
             let transaction = db.transaction(databaseName, "readwrite");
             let objStore = transaction.objectStore(databaseName);
@@ -10126,7 +10208,7 @@ function storeToDatabase(databaseName, object) {
   */
 function UpdateToDatabase(databaseName, object) {
     return new Promise(function (resolve, reject) {
-        console.log("this is wriring to the database", object);
+        // console.log("this is wriring to the database", object);
         openDatabase(databaseName).then((db) => {
             let transaction = db.transaction(databaseName, "readwrite");
             let objStore = transaction.objectStore(databaseName);
@@ -14364,7 +14446,7 @@ function CreateTheConceptLocal(referent_1, typecharacter_1, userId_1, categoryId
             }
             //let id = -Math.floor(Math.random() * 100000000);
             let id = yield _DataStructures_Local_LocalId__WEBPACK_IMPORTED_MODULE_3__.LocalId.getConceptId();
-            console.log("this is the getting id type connection", id);
+            // console.log("this is the getting id type connection", id);
             let isNew = true;
             let created_on = new Date();
             let updated_on = new Date();
@@ -18390,7 +18472,7 @@ class BuilderStatefulWidget extends _StatefulWidget__WEBPACK_IMPORTED_MODULE_0__
      * This function will be called after the component mounts.
      */
     componentDidMount() {
-        return __awaiter(this, arguments, void 0, function* (onmountVal = "") {
+        return __awaiter(this, void 0, void 0, function* () {
             //console.log("onmountVal", onmountVal);
             const AsyncFunction = Object.getPrototypeOf(function () {
                 return __awaiter(this, void 0, void 0, function* () { });
@@ -18404,6 +18486,13 @@ class BuilderStatefulWidget extends _StatefulWidget__WEBPACK_IMPORTED_MODULE_0__
             const AsyncFunction = Object.getPrototypeOf(function () {
                 return __awaiter(this, void 0, void 0, function* () { });
             }).constructor;
+            // const dynamicAsyncFunction = new Function("tsccs",`
+            //   return (async function() {
+            //     ${this.addEventFunction}
+            //   }).call(this);
+            // `).bind(this);
+            // console.log("This is the async function", dynamicAsyncFunction);
+            // dynamicAsyncFunction(tsccs);
             const renderOnmount = AsyncFunction("tsccs", this.addEventFunction);
             renderOnmount.call(this, _app__WEBPACK_IMPORTED_MODULE_1__);
         });
@@ -20171,6 +20260,7 @@ function init() {
                     // else if (enableSW.path && enableSW.path.length > 2 && !enableSW.path.includes('serviceWorker.bundle.js')) serviceWorkerPath = enableSW.path + './serviceWorker.bundle.js'
                     yield new Promise((resolve, reject) => {
                         var _a, _b;
+                        let success = false;
                         navigator.serviceWorker
                             .register((_a = enableSW.pathToSW) !== null && _a !== void 0 ? _a : "./serviceWorker.bundle.js", {
                             // type: "module",
@@ -20193,43 +20283,59 @@ function init() {
                                 resolve();
                             }
                             else {
-                                let success = false;
-                                // Listen for updates to the service worker
-                                console.log("update listen start");
-                                registration.onupdatefound = () => {
-                                    const newWorker = registration.installing;
-                                    console.log("new worker", newWorker);
-                                    if (newWorker) {
-                                        newWorker.onstatechange = () => __awaiter(this, void 0, void 0, function* () {
-                                            console.log("on state change triggered");
-                                            // if (newWorker.state === 'activated' && navigator.serviceWorker.controller) {
-                                            if (newWorker.state === "activated" || newWorker.state === 'redundant') {
-                                                // && navigator.serviceWorker.controller) {
-                                                console.log("New Service Worker is active", registration);
-                                                serviceWorker = newWorker;
-                                                // serviceWorker = registration.active;
-                                                // Send init message now that it's active
-                                                yield sendMessage("init", {
-                                                    url,
-                                                    aiurl,
-                                                    accessToken,
-                                                    nodeUrl,
-                                                    enableAi,
-                                                    applicationName,
-                                                    isTest,
-                                                });
-                                                success = true;
-                                                resolve();
-                                            }
-                                        });
-                                    }
-                                };
                                 // Handle if on state change didn't trigger
                                 setTimeout(() => {
                                     if (!success)
                                         reject("Not Completed Initialization");
-                                }, 3000);
+                                }, 5000);
                             }
+                            // Listen for updates to the service worker
+                            console.log("update listen start");
+                            registration.onupdatefound = () => {
+                                const newWorker = registration.installing;
+                                console.log("new worker", newWorker);
+                                if (newWorker) {
+                                    newWorker.onstatechange = () => __awaiter(this, void 0, void 0, function* () {
+                                        console.log("on state change triggered");
+                                        // if (newWorker.state === 'activated' && navigator.serviceWorker.controller) {
+                                        if ((newWorker.state === "installed" || newWorker.state === "activated" || newWorker.state === 'redundant') && navigator.serviceWorker.controller) {
+                                            // && navigator.serviceWorker.controller) {
+                                            console.log("New Service Worker is active", registration);
+                                            serviceWorker = newWorker;
+                                            // serviceWorker = registration.active;
+                                            // Send init message now that it's active
+                                            yield sendMessage("init", {
+                                                url,
+                                                aiurl,
+                                                accessToken,
+                                                nodeUrl,
+                                                enableAi,
+                                                applicationName,
+                                                isTest,
+                                            });
+                                            success = true;
+                                            resolve();
+                                        }
+                                    });
+                                }
+                            };
+                            // Listen for the activation of the new service worker
+                            registration.addEventListener('controllerchange', () => __awaiter(this, void 0, void 0, function* () {
+                                if (navigator.serviceWorker.controller) {
+                                    console.log('Service worker has been activated');
+                                    yield sendMessage("init", {
+                                        url,
+                                        aiurl,
+                                        accessToken,
+                                        nodeUrl,
+                                        enableAi,
+                                        applicationName,
+                                        isTest,
+                                    });
+                                    // The new service worker is now controlling the page
+                                    // You can reload the page if necessary or handle the update process here
+                                }
+                            }));
                         }))
                             .catch((error) => __awaiter(this, void 0, void 0, function* () {
                             yield initConceptConnection();
@@ -20300,13 +20406,13 @@ function sendMessage(type, payload) {
                         console.log('not ready', type);
                         reject("Service worker not ready");
                     }
-                }, 30000); // 30 seconds
+                }, 60000); // 60 seconds
             }
             // Timeout for waiting for the response (e.g., 5 seconds)
             setTimeout(() => {
                 reject("No response from service worker after timeout");
                 navigator.serviceWorker.removeEventListener("message", responseHandler);
-            }, 30000); // 30 sec
+            }, 60000); // 60 sec
             // })
             // .catch(err => reject(err))
             // .finally(() => console.log('finally'))