sdc_client 0.58.6 → 0.158.0

package/src/simpleDomControl/sdc_controller.js

@@ -1,42 +1,45 @@
-import {promiseDummyFactory, tagNameToCamelCase, agileAggregation} from "./sdc_utils.js";
 import {
-    CONTROLLER_CLASS,
-    getController,
-    loadFilesFromController,
-    refresh,
-    runControllerFillContent
+  promiseDummyFactory,
+  tagNameToCamelCase,
+  agileAggregation,
+} from "./sdc_utils.js";
+import {
+  CONTROLLER_CLASS,
+  getController,
+  loadFilesFromController,
+  refresh,
+  runControllerFillContent,
 } from "./sdc_view.js";
 
-import {runOnInitWithParameter} from "./sdc_params.js";
-import {setControllerEvents} from "./sdc_dom_events.js";
-import {app} from "./sdc_main.js";
+import { runOnInitWithParameter } from "./sdc_params.js";
+import { setControllerEvents } from "./sdc_dom_events.js";
+import { app } from "./sdc_main.js";
 
 export let Global = [];
 export let controllerList = {};
 
 export function tagList() {
-    return Object.keys(controllerList);
+  return Object.keys(controllerList);
 }
 
-
 function prepareMixins(superTagNameList, tagName) {
-    superTagNameList = superTagNameList.concat(controllerList[tagName][1]);
-    superTagNameList = superTagNameList.filter((value, index, self) => {
-        return self.indexOf(value) === index;
-    });
-    let hasAdded = true;
-    while (hasAdded) {
-        hasAdded = false;
-        for (let tag of superTagNameList) {
-            for (let newTag of controllerList[tag][1]) {
-                if (!superTagNameList.includes(newTag)) {
-                    superTagNameList.push(newTag);
-                    hasAdded = true;
-                }
-            }
+  superTagNameList = superTagNameList.concat(controllerList[tagName][1]);
+  superTagNameList = superTagNameList.filter((value, index, self) => {
+    return self.indexOf(value) === index;
+  });
+  let hasAdded = true;
+  while (hasAdded) {
+    hasAdded = false;
+    for (let tag of superTagNameList) {
+      for (let newTag of controllerList[tag][1]) {
+        if (!superTagNameList.includes(newTag)) {
+          superTagNameList.push(newTag);
+          hasAdded = true;
         }
+      }
     }
-    return superTagNameList;
+  }
+  return superTagNameList;
 }
 
 /**
@@ -49,16 +52,16 @@ function prepareMixins(superTagNameList, tagName) {
  * @return {AbstractSDC} - parentController
  */
 function setParentController(parentController, controller) {
-    if (parentController) {
-        let controllerName = tagNameToCamelCase(controller._tagName);
-        if (!parentController._childController[controllerName]) {
-            parentController._childController[controllerName] = [];
-        }
-
-        parentController._childController[controllerName].push(controller);
+  if (parentController) {
+    let controllerName = tagNameToCamelCase(controller._tagName);
+    if (!parentController._childController[controllerName]) {
+      parentController._childController[controllerName] = [];
     }
 
-    return (controller._parentController = parentController)
+    parentController._childController[controllerName].push(controller);
+  }
+
+  return (controller._parentController = parentController);
 }
 
 /**
@@ -67,14 +70,14 @@ function setParentController(parentController, controller) {
  * @param {AbstractSDC} parentController
  */
 export function resetChildren(parentController) {
-    parentController._childController = {};
-    parentController.find(`.${CONTROLLER_CLASS}`).each(function () {
-        const $this = $(this);
-        const cController = getController($this);
-        if (cController === parentController) {
-            setParentController(parentController, cController);
-        }
-    });
+  parentController._childController = {};
+  parentController.find(`.${CONTROLLER_CLASS}`).each(function () {
+    const $this = $(this);
+    const cController = getController($this);
+    if (cController === parentController) {
+      setParentController(parentController, cController);
+    }
+  });
 }
 
 /**
@@ -92,24 +95,30 @@ export function resetChildren(parentController) {
  * @param {Array<string>} superTagNameList - tag names of super controller
  * @return {AbstractSDC} -  new Controller
  */
-function controllerFactoryInstance(parentController, $element, tagName, superTagNameList) {
-
-    let mixinControllerClass = [];
-    superTagNameList = prepareMixins(superTagNameList, tagName);
-    for (let superTagName of superTagNameList) {
-        mixinControllerClass.push(controllerList[superTagName][0]);
-    }
-
-    let controllerClass = controllerList[tagName][0];
-    let controller = new (agileAggregation(controllerClass, ...mixinControllerClass))();
-    controller._tagName = tagName;
-
-    setParentController(parentController, controller);
-    controller.$container = $element;
-    runOnInitWithParameter($element, controller);
-
-
-    return controller;
+function controllerFactoryInstance(
+  parentController,
+  $element,
+  tagName,
+  superTagNameList,
+) {
+  let mixinControllerClass = [];
+  superTagNameList = prepareMixins(superTagNameList, tagName);
+  for (let superTagName of superTagNameList) {
+    mixinControllerClass.push(controllerList[superTagName][0]);
+  }
+
+  let controllerClass = controllerList[tagName][0];
+  let controller = new (agileAggregation(
+    controllerClass,
+    ...mixinControllerClass,
+  ))();
+  controller._tagName = tagName;
+
+  setParentController(parentController, controller);
+  controller.$container = $element;
+  runOnInitWithParameter($element, controller);
+
+  return controller;
 }
 
 /**
@@ -125,19 +134,33 @@ function controllerFactoryInstance(parentController, $element, tagName, superTag
  * @param {Array<string>} superTagNameList - tag names of super controller
  * @return {AbstractSDC} -  new Controller
  */
-export function controllerFactory(parentController, $element, tagName, superTagNameList) {
-
-    if (Global.includes(tagName)) {
-        let gTagName = tagNameToCamelCase(tagName);
-        if (!window[gTagName]) {
-            window[gTagName] = controllerFactoryInstance(parentController, $element, tagName, superTagNameList);
-        }
-
-        window[gTagName].$container = $element;
-        return window[gTagName];
+export function controllerFactory(
+  parentController,
+  $element,
+  tagName,
+  superTagNameList,
+) {
+  if (Global.includes(tagName)) {
+    let gTagName = tagNameToCamelCase(tagName);
+    if (!window[gTagName]) {
+      window[gTagName] = controllerFactoryInstance(
+        parentController,
+        $element,
+        tagName,
+        superTagNameList,
+      );
     }
 
-    return controllerFactoryInstance(parentController, $element, tagName, superTagNameList);
+    window[gTagName].$container = $element;
+    return window[gTagName];
+  }
+
+  return controllerFactoryInstance(
+    parentController,
+    $element,
+    tagName,
+    superTagNameList,
+  );
 }
 
 /**
@@ -150,22 +173,21 @@ export function controllerFactory(parentController, $element, tagName, superTagN
  * @return {Promise<*>} - return of the onLoad function
  */
 function runControllerShow(controller, $html) {
-    return runControllerFillContent(controller, $html).then(function (args) {
-        args = args || true;
-        if (controller.willShow) {
-            let loadPromiseOrContent = controller.willShow();
-            if (loadPromiseOrContent instanceof Promise) {
-                return loadPromiseOrContent.then(function () {
-                    return args;
-                });
-            }
-        }
+  return runControllerFillContent(controller, $html).then(function (args) {
+    args = args || true;
+    if (controller.willShow) {
+      let loadPromiseOrContent = controller.willShow();
+      if (loadPromiseOrContent instanceof Promise) {
+        return loadPromiseOrContent.then(function () {
+          return args;
+        });
+      }
+    }
 
-        return args;
-    });
+    return args;
+  });
 }
 
-
 /**
  * runControllerLoad Calls the onLoad function of the controller.
  * This function is called before the HTML is set to the page.
@@ -175,17 +197,17 @@ function runControllerShow(controller, $html) {
  * @return {Promise<*>} - return of the onLoad function
  */
 function runControllerLoad(controller) {
-    return loadFilesFromController(controller).then((html) => {
-        if (!controller.onLoad || controller._onLoadDone) {
-            return html;
-        }
+  return loadFilesFromController(controller).then((html) => {
+    if (!controller.onLoad || controller._onLoadDone) {
+      return html;
+    }
 
-        controller._onLoadDone = true;
-        let loadPromise = controller.onLoad(html);
-        return (loadPromise || promiseDummyFactory()).then(() => {
-            return html;
-        });
+    controller._onLoadDone = true;
+    let loadPromise = controller.onLoad(html);
+    return (loadPromise || promiseDummyFactory()).then(() => {
+      return html;
     });
+  });
 }
 
 /**
@@ -198,21 +220,23 @@ function runControllerLoad(controller) {
  * @param controller
  * @param {Object} process - Process object containing the refresh process
  */
-export function runControlFlowFunctions(controller, process ) {
-    const prom_controller = runControllerLoad(controller)
-        .then(function ($html) {
-            return runControllerShow(controller, $html);
-        }).then(() => {
-            return runRefresh(controller, process);
-        }).catch(function ($html) {
-            return runControllerFillContent(controller, $html);
-        });
+export function runControlFlowFunctions(controller, process) {
+  const prom_controller = runControllerLoad(controller)
+    .then(function ($html) {
+      return runControllerShow(controller, $html);
+    })
+    .then(() => {
+      return runRefresh(controller, process);
+    })
+    .catch(function ($html) {
+      return runControllerFillContent(controller, $html);
+    });
 
-    if (controller.load_async) {
-        return Promise.resolve();
-    }
+  if (controller.load_async) {
+    return Promise.resolve();
+  }
 
-    return prom_controller;
+  return prom_controller;
 }
 
 /**
@@ -221,17 +245,17 @@ export function runControlFlowFunctions(controller, process ) {
  * @param {Object} process - Process object containing the refresh process
  */
 export function runRefresh(controller, process) {
-    return refresh(null, controller, process);
+  return refresh(null, controller, process);
 }
 
 function getParentList(controller) {
-    let controllerList = [];
-    while (controller) {
-        controller._isEventsSet = false;
-        controllerList.unshift(controller);
-        controller = controller._parentController;
-    }
-    return controllerList
+  let controllerList = [];
+  while (controller) {
+    controller._isEventsSet = false;
+    controllerList.unshift(controller);
+    controller = controller._parentController;
+  }
+  return controllerList;
 }
 
 /**
@@ -239,26 +263,27 @@ function getParentList(controller) {
  * @param {Object} process - Process object containing the refresh process
  */
 export function updateEventAndTriggerOnRefresh(process) {
-    const parentList = getParentList(process.controller[0]);
-    const controllerList = parentList.concat(process.controller.slice(1));
+  const parentList = getParentList(process.controller[0]);
+  const controllerList = parentList.concat(process.controller.slice(1));
 
-    for (let con of controllerList) {
-        setControllerEvents(con);
-        con.onRefresh(process.controller[0]);
-    }
+  for (let con of controllerList) {
+    setControllerEvents(con);
+    con.onRefresh(process.controller[0]);
+  }
 }
 
-
 export function prepareRefreshProcess(refreshProcess, controller) {
-    let isRunningProcess = Boolean(refreshProcess);
-
-    if (!isRunningProcess) {
-      refreshProcess = {uuids: new Set([controller._uuid]), controller: [controller]};
-    } else if (!refreshProcess.uuids.has(controller._uuid)) {
-      refreshProcess.uuids.add(controller._uuid);
-      refreshProcess.controller.push(controller);
-    }
-
-    return {isRunningProcess, refreshProcess};
+  let isRunningProcess = Boolean(refreshProcess);
+
+  if (!isRunningProcess) {
+    refreshProcess = {
+      uuids: new Set([controller._uuid]),
+      controller: [controller],
+    };
+  } else if (!refreshProcess.uuids.has(controller._uuid)) {
+    refreshProcess.uuids.add(controller._uuid);
+    refreshProcess.controller.push(controller);
+  }
+
+  return { isRunningProcess, refreshProcess };
 }
-

package/src/simpleDomControl/sdc_dom_events.js

@@ -1,116 +1,127 @@
-import {getController} from './sdc_view.js';
+import { getController } from "./sdc_view.js";
 
-export const STD_EVENT_BLACK_LIST = ['onbeforeunload', 'onunload'];
-export const STD_EVENT_LIST = Object.keys(window).filter(key => /^on/.test(key) && !STD_EVENT_BLACK_LIST.includes(key)).map(x => x.slice(2));
+export const STD_EVENT_BLACK_LIST = ["onbeforeunload", "onunload"];
+export const STD_EVENT_LIST = Object.keys(window)
+  .filter((key) => /^on/.test(key) && !STD_EVENT_BLACK_LIST.includes(key))
+  .map((x) => x.slice(2));
 
 function checkIfEventFits(ev_type, e, target) {
-    let elementUnderMouse;
-    switch (ev_type) {
-        case "mouseleave":
-        case "mouseout":
-            elementUnderMouse = document.elementFromPoint(e.clientX, e.clientY);
-            return target !== elementUnderMouse && !target.contains(elementUnderMouse);
-        case "mouseenter":
-        case "mousein":
-            elementUnderMouse = document.elementFromPoint(e.clientX, e.clientY);
-            return target !== elementUnderMouse && !target.contains(elementUnderMouse);
-        default:
-            return true;
-    };
+  let elementUnderMouse;
+  switch (ev_type) {
+    case "mouseleave":
+    case "mouseout":
+      elementUnderMouse = document.elementFromPoint(e.clientX, e.clientY);
+      return (
+        target !== elementUnderMouse && !target.contains(elementUnderMouse)
+      );
+    case "mouseenter":
+    case "mousein":
+      elementUnderMouse = document.elementFromPoint(e.clientX, e.clientY);
+      return (
+        target !== elementUnderMouse && !target.contains(elementUnderMouse)
+      );
+    default:
+      return true;
+  }
 }
 
 export function windowEventHandler(event) {
-    let ev_type = event.type;
-    if (event.hasOwnProperty('namespace') && event.namespace && event.namespace.length) ev_type += `.${event.namespace}`;
+  let ev_type = event.type;
+  if (
+    event.hasOwnProperty("namespace") &&
+    event.namespace &&
+    event.namespace.length
+  )
+    ev_type += `.${event.namespace}`;
 
-    let $elm = $(event.target);
-    let controller = null;
-    let is_done = false;
-    let is_last_elem = false;
-    event.stopImmediatePropagation = () => is_last_elem = true;
-    event.stopPropagation = () => is_last_elem = is_done = true;
-    while ($elm.length) {
-        let attrs = $elm.attr(`sdc_${ev_type}`);
-        if (attrs && checkIfEventFits(ev_type, event, $elm[0])) {
-            if (!controller) {
-                controller = getController($elm);
-                if (!controller) return;
+  let $elm = $(event.target);
+  let controller = null;
+  let is_done = false;
+  let is_last_elem = false;
+  event.stopImmediatePropagation = () => (is_last_elem = true);
+  event.stopPropagation = () => (is_last_elem = is_done = true);
+  while ($elm.length) {
+    let attrs = $elm.attr(`sdc_${ev_type}`);
+    if (attrs && checkIfEventFits(ev_type, event, $elm[0])) {
+      if (!controller) {
+        controller = getController($elm);
+        if (!controller) return;
+      }
+      while (controller) {
+        attrs.split(" ").forEach((attr) => {
+          if (is_done) return;
+          let handler = null;
+          if (typeof attr === "function") {
+            handler = attr;
+          } else if (typeof controller[attr] === "function") {
+            handler = controller[attr];
+          } else if (
+            typeof attr === "string" &&
+            attr.startsWith("this.event_")
+          ) {
+            handler = controller.getEvents()[ev_type];
+            if (!handler) {
+              return;
             }
-            while (controller) {
-                attrs.split(' ').forEach((attr) => {
-                    if (is_done) return;
-                    let handler = null;
-                    if (typeof attr === 'function') {
-                        handler = attr;
-                    } else if (typeof controller[attr] === 'function') {
-                        handler = controller[attr];
-                    } else if (typeof attr === 'string' && attr.startsWith('this.event_')) {
-                        handler = controller.getEvents()[ev_type];
-                        if (!handler) {
-                            return;
-                        }
-                        handler = handler[attr.slice('this.event_'.length)];
-                        if (!handler) {
-                            return;
-                        }
-                    }
-
-                    handler && handler.call(controller, $elm, event);
-                });
-                if (is_last_elem) return;
-                controller = controller._parentController
+            handler = handler[attr.slice("this.event_".length)];
+            if (!handler) {
+              return;
             }
-        }
-        if (is_done) return;
-        $elm = $elm.parent();
+          }
+
+          handler && handler.call(controller, $elm, event);
+        });
+        if (is_last_elem) return;
+        controller = controller._parentController;
+      }
     }
+    if (is_done) return;
+    $elm = $elm.parent();
+  }
 
-    return {res: true};
+  return { res: true };
 }
 
 /**
  *
  */
 export function initEvents() {
-    const $window = $(window);
-    STD_EVENT_LIST.forEach(ev_type => {
-        $window.off(ev_type).on(ev_type, windowEventHandler);
-    });
+  const $window = $(window);
+  STD_EVENT_LIST.forEach((ev_type) => {
+    $window.off(ev_type).on(ev_type, windowEventHandler);
+  });
 }
 
-
 /**
  *
  * @param {AbstractSDC} controller
  */
 export function setControllerEvents(controller) {
+  if (controller._isEventsSet) {
+    return;
+  }
 
-    if (controller._isEventsSet) {
-        return;
-    }
-
-    const events = controller.getEvents();
-    for (let ev_type in events) {
-        if (events.hasOwnProperty(ev_type)) {
-            let eventList = events[ev_type];
-            for (let domSelector in eventList) {
-                if (eventList.hasOwnProperty(domSelector)) {
-                    controller.find(domSelector).each(function () {
-                        let $elements = $(this);
-                        let event_list = $elements.attr(`sdc_${ev_type}`) || null;
-                        if (!event_list) event_list = [];
-                        else event_list = event_list.split(' ');
-                        const new_key = `this.event_${domSelector}`;
-                        if (event_list.indexOf(new_key) === -1) {
-                            event_list.push(new_key);
-                            $elements.attr(`sdc_${ev_type}`, event_list.join(' '))
-                        }
-
-                    });
-                }
+  const events = controller.getEvents();
+  for (let ev_type in events) {
+    if (events.hasOwnProperty(ev_type)) {
+      let eventList = events[ev_type];
+      for (let domSelector in eventList) {
+        if (eventList.hasOwnProperty(domSelector)) {
+          controller.find(domSelector).each(function () {
+            let $elements = $(this);
+            let event_list = $elements.attr(`sdc_${ev_type}`) || null;
+            if (!event_list) event_list = [];
+            else event_list = event_list.split(" ");
+            const new_key = `this.event_${domSelector}`;
+            if (event_list.indexOf(new_key) === -1) {
+              event_list.push(new_key);
+              $elements.attr(`sdc_${ev_type}`, event_list.join(" "));
             }
+          });
         }
+      }
     }
-    // TODO: Is it needed
-    //controller._isEventsSet = true;
-}
+  }
+  // TODO: Is it needed
+  //controller._isEventsSet = true;
+}