sdc_client 0.58.6 → 0.158.1

package/src/simpleDomControl/sdc_params.js

@@ -1,26 +1,34 @@
-import {getParamsNameOfFunction, checkIfParamNumberBoolOrString} from "./sdc_utils.js";
-import {DATA_CONTROLLER_KEY} from "./sdc_view.js";
-
+import {
+  getParamsNameOfFunction,
+  checkIfParamNumberBoolOrString,
+} from "./sdc_utils.js";
+import { DATA_CONTROLLER_KEY } from "./sdc_view.js";
 
 export function prepareData(data, paramNameList = []) {
-  const data_json_key = 'SDC_JSON_MODEL=['
+  const data_json_key = "SDC_JSON_MODEL=[";
   return Object.fromEntries(
-    Object.entries(data).filter(([key, element]) => {
-      return key !== DATA_CONTROLLER_KEY && !paramNameList.includes(key);
-    }).map(([key, element]) => {
-      if (typeof element === 'string' && element.startsWith(data_json_key)) {
-        try {
-          const {pk, fields} = JSON.parse(element.slice(data_json_key.length, -1));
-          return [key, {
-            ...fields,
-            id: pk,
-            pk
-          }];
-        } catch {
+    Object.entries(data)
+      .filter(([key, element]) => {
+        return key !== DATA_CONTROLLER_KEY && !paramNameList.includes(key);
+      })
+      .map(([key, element]) => {
+        if (typeof element === "string" && element.startsWith(data_json_key)) {
+          try {
+            const { pk, fields } = JSON.parse(
+              element.slice(data_json_key.length, -1),
+            );
+            return [
+              key,
+              {
+                ...fields,
+                id: pk,
+                pk,
+              },
+            ];
+          } catch {}
         }
-      }
-      return [key, element];
-    })
+        return [key, element];
+      }),
   );
 }
 
@@ -40,11 +48,11 @@ function getParamList(paramNameList, $element) {
     if (data.hasOwnProperty(data_name)) {
       returnList.push(data[data_name]);
     } else {
-      returnList.push('undefined');
+      returnList.push("undefined");
     }
   }
 
-  returnList.push(restData)
+  returnList.push(restData);
   return returnList;
 }
 
@@ -73,23 +81,30 @@ function getDomTagParamsWithList(paramNameList, $element, controller = null) {
  */
 function reg_runOnInitWithParameter(controller, $element, applyController) {
   if (!controller) {
-    return false
-  } else if (typeof controller.onInit !== 'function') {
-    return false
+    return false;
+  } else if (typeof controller.onInit !== "function") {
+    return false;
   }
   let paramNameList;
-  if (typeof controller._on_init_params === 'function') {
+  if (typeof controller._on_init_params === "function") {
     paramNameList = controller._on_init_params();
   } else {
     paramNameList = getParamsNameOfFunction(controller.onInit);
   }
 
-
-  let initParams = getDomTagParamsWithList(paramNameList, $element, applyController._parentController);
+  let initParams = getDomTagParamsWithList(
+    paramNameList,
+    $element,
+    applyController._parentController,
+  );
   controller.onInit.apply(applyController, initParams);
   if (applyController === controller) {
     for (let mixinKey in controller._mixins) {
-      reg_runOnInitWithParameter(controller._mixins[mixinKey], $element, applyController);
+      reg_runOnInitWithParameter(
+        controller._mixins[mixinKey],
+        $element,
+        applyController,
+      );
     }
   }
 }
@@ -100,4 +115,4 @@ export function runOnInitWithParameter($element, controller) {
 
 export function getUrlParam(controller, $element) {
   return getDomTagParamsWithList(controller._urlParams, $element);
-}
+}

package/src/simpleDomControl/sdc_server_call.js

@@ -1,187 +1,186 @@
-import {uuidv4} from "./sdc_utils.js";
-import {trigger} from "./sdc_events.js";
+import { uuidv4 } from "./sdc_utils.js";
+import { trigger } from "./sdc_events.js";
 
 let IS_CONNECTED = false;
 let IS_CONNECTING = false;
-let SDC_SOCKET = null
+let SDC_SOCKET = null;
 let OPEN_REQUESTS = {};
 
 export function callServer(app, controller, parsedContentUrl, funcName, args) {
-    if (window.SERVER_CALL_VIA_WEB_SOCKET) {
-        return socketCallServer(app, controller, funcName, args);
-    } else {
-        return postCallServer(parsedContentUrl, funcName, args);
-    }
-
+  if (window.SERVER_CALL_VIA_WEB_SOCKET) {
+    return socketCallServer(app, controller, funcName, args);
+  } else {
+    return postCallServer(parsedContentUrl, funcName, args);
+  }
 }
 
 export function isConnected() {
-    if (window.SERVER_CALL_VIA_WEB_SOCKET) {
-        return socketIsConnected();
-    } else {
-        return Promise.resolve(true);
-    }
+  if (window.SERVER_CALL_VIA_WEB_SOCKET) {
+    return socketIsConnected();
+  } else {
+    return Promise.resolve(true);
+  }
 }
 
 export function close() {
-    if (window.SERVER_CALL_VIA_WEB_SOCKET) {
-        socketClose();
-    }
+  if (window.SERVER_CALL_VIA_WEB_SOCKET) {
+    socketClose();
+  }
 }
 
 function postCallServer(parsedContentUrl, funcName, args) {
-    if(typeof args !== 'object' && Array.isArray(args) && args === null) {
-        args = {'arg0': args}
-    }
-    args = {
-        'data': JSON.stringify(args),
-        '_sdc_func_name': funcName, '_method': 'sdc_server_call'
-    }
-    return $.post({
-        url: parsedContentUrl,
-        data: args,
-        beforeSend: function (xhr, settings) {
-            xhr.setRequestHeader("X-CSRFToken", window.CSRF_TOKEN);
-        }
-    }).then((res) => {
-        const data = res['_return_data'];
-        _handle_response(data);
-        return data;
-    }).catch((res) => {
-        const data = res.responseJSON;
-        data.is_error = true;
-        _handle_response(data);
-        throw res;
+  if (typeof args !== "object" && Array.isArray(args) && args === null) {
+    args = { arg0: args };
+  }
+  args = {
+    data: JSON.stringify(args),
+    _sdc_func_name: funcName,
+    _method: "sdc_server_call",
+  };
+  return $.post({
+    url: parsedContentUrl,
+    data: args,
+    beforeSend: function (xhr, settings) {
+      xhr.setRequestHeader("X-CSRFToken", window.CSRF_TOKEN);
+    },
+  })
+    .then((res) => {
+      const data = res["_return_data"];
+      _handle_response(data);
+      return data;
+    })
+    .catch((res) => {
+      const data = res.responseJSON;
+      data.is_error = true;
+      _handle_response(data);
+      throw res;
     });
 }
 
 function socketCallServer(app, controller, funcName, args) {
-
-    let id = uuidv4();
-    isConnected().then(() => {
-        SDC_SOCKET.send(JSON.stringify({
-            event: 'sdc_call',
-            id: id,
-            controller: controller,
-            app: app,
-            function: funcName,
-            args: args
-        }));
-    });
-
-    return new Promise((resolve, reject) => {
-        OPEN_REQUESTS[id] = [resolve, reject];
-    });
+  let id = uuidv4();
+  isConnected().then(() => {
+    SDC_SOCKET.send(
+      JSON.stringify({
+        event: "sdc_call",
+        id: id,
+        controller: controller,
+        app: app,
+        function: funcName,
+        args: args,
+      }),
+    );
+  });
+
+  return new Promise((resolve, reject) => {
+    OPEN_REQUESTS[id] = [resolve, reject];
+  });
 }
 
 function _connect() {
-    IS_CONNECTING = true;
-    return new Promise((resolve) => {
-        if (window.location.protocol === "https:") {
-            SDC_SOCKET = new WebSocket(`wss://${window.location.host}/sdc_ws/ws/`);
-        } else {
-            SDC_SOCKET = new WebSocket(`ws://${window.location.host}/sdc_ws/ws/`);
-        }
-
-
-        SDC_SOCKET.onmessage = function (e) {
-            let data = JSON.parse(e.data);
-            _handle_response(data);
-        };
-
-        SDC_SOCKET.onclose = function () {
-            if (IS_CONNECTED) {
-                console.error('SDC Socket closed unexpectedly');
-            }
-            IS_CONNECTED = false;
-            for (const [key, value] of Object.entries(OPEN_REQUESTS)) {
-                value[1]({});
-                delete OPEN_REQUESTS[key];
-            }
-
-            setTimeout(() => {
-                _connect();
-            }, 1000);
-        };
-
-        SDC_SOCKET.onerror = function (err) {
-            console.error('Socket encountered error: ', err.message, 'Closing socket');
-            if (IS_CONNECTED) {
-                try {
-                    SDC_SOCKET.close();
-                } catch (e) {
-
-                }
-            }
-        };
-
-        SDC_SOCKET.onopen = function () {
-            IS_CONNECTED = true;
-            IS_CONNECTING = false;
-            resolve();
-        }
-    })
+  IS_CONNECTING = true;
+  return new Promise((resolve) => {
+    if (window.location.protocol === "https:") {
+      SDC_SOCKET = new WebSocket(`wss://${window.location.host}/sdc_ws/ws/`);
+    } else {
+      SDC_SOCKET = new WebSocket(`ws://${window.location.host}/sdc_ws/ws/`);
+    }
+
+    SDC_SOCKET.onmessage = function (e) {
+      let data = JSON.parse(e.data);
+      _handle_response(data);
+    };
+
+    SDC_SOCKET.onclose = function () {
+      if (IS_CONNECTED) {
+        console.error("SDC Socket closed unexpectedly");
+      }
+      IS_CONNECTED = false;
+      for (const [key, value] of Object.entries(OPEN_REQUESTS)) {
+        value[1]({});
+        delete OPEN_REQUESTS[key];
+      }
+
+      setTimeout(() => {
+        _connect();
+      }, 1000);
+    };
+
+    SDC_SOCKET.onerror = function (err) {
+      console.error(
+        "Socket encountered error: ",
+        err.message,
+        "Closing socket",
+      );
+      if (IS_CONNECTED) {
+        try {
+          SDC_SOCKET.close();
+        } catch (e) {}
+      }
+    };
+
+    SDC_SOCKET.onopen = function () {
+      IS_CONNECTED = true;
+      IS_CONNECTING = false;
+      resolve();
+    };
+  });
 }
 
 function _handle_response(data) {
-    if(!data) {
-        data = {};
+  if (!data) {
+    data = {};
+  }
+  if (data.is_error) {
+    if (data.msg || data.header) {
+      trigger("pushErrorMsg", data.header || "", data.msg || "");
     }
-    if (data.is_error) {
-        if (data.msg || data.header) {
-            trigger('pushErrorMsg', data.header || '', data.msg || '');
-        }
-        if (data.id && OPEN_REQUESTS[data.id]) {
-            OPEN_REQUESTS[data.id][1](data.data || null);
-            delete OPEN_REQUESTS[data.id];
-        }
-    } else {
-        if (data.msg || data.header) {
-            trigger('pushMsg', data.header || '', data.msg || '');
-        }
-
-        if (data.type && data.type === 'sdc_recall') {
-            if (data.id && OPEN_REQUESTS[data.id]) {
-                OPEN_REQUESTS[data.id][0](data.data);
-                delete OPEN_REQUESTS[data.id];
-            }
-        } else if (data.type && data.type === 'sdc_event') {
-            let event = data.event;
-            if (event) {
-                trigger(event, data.payload);
-            }
-
-        } else if (data.type && data.type === 'sdc_redirect') {
-            trigger('onNavLink', data.link);
-        }
+    if (data.id && OPEN_REQUESTS[data.id]) {
+      OPEN_REQUESTS[data.id][1](data.data || null);
+      delete OPEN_REQUESTS[data.id];
+    }
+  } else {
+    if (data.msg || data.header) {
+      trigger("pushMsg", data.header || "", data.msg || "");
+    }
+
+    if (data.type && data.type === "sdc_recall") {
+      if (data.id && OPEN_REQUESTS[data.id]) {
+        OPEN_REQUESTS[data.id][0](data.data);
+        delete OPEN_REQUESTS[data.id];
+      }
+    } else if (data.type && data.type === "sdc_event") {
+      let event = data.event;
+      if (event) {
+        trigger(event, data.payload);
+      }
+    } else if (data.type && data.type === "sdc_redirect") {
+      trigger("onNavLink", data.link);
     }
+  }
 }
 
 function socketClose() {
-    if (IS_CONNECTED) {
-        IS_CONNECTED = false;
-        try {
-            SDC_SOCKET.close();
-        } catch (e) {
-
-        }
-
-    }
+  if (IS_CONNECTED) {
+    IS_CONNECTED = false;
+    try {
+      SDC_SOCKET.close();
+    } catch (e) {}
+  }
 }
 
 function socketIsConnected() {
-
-    return new Promise((resolve) => {
-        if (IS_CONNECTED) {
-            return resolve();
-        } else if (IS_CONNECTING) {
-            setTimeout(() => {
-                isConnected().then(() => {
-                    resolve();
-                });
-            }, 200);
-        } else {
-            return resolve(_connect());
-        }
-    });
-}
+  return new Promise((resolve) => {
+    if (IS_CONNECTED) {
+      return resolve();
+    } else if (IS_CONNECTING) {
+      setTimeout(() => {
+        isConnected().then(() => {
+          resolve();
+        });
+      }, 200);
+    } else {
+      return resolve(_connect());
+    }
+  });
+}