@aj-shadow/z-abs-funclayer-engine-cs 0.0.0-aj-beta.221

package/project/clientServer/execution/actor-state-const.js

@@ -0,0 +1,28 @@
+
+'use strict';
+
+
+class ActorStateConst {
+  static DATA = 0;
+  static INIT_SERVER = 1;
+  static INIT_CLIENT = 2;
+  static RUN = 3;
+  static EXIT = 4;
+  static DONE = 5;
+  
+  static actorStateNames = [
+    'data',
+    'initServer',
+    'initClient',
+    'run',
+    'exit',
+    'done'
+  ];
+  
+  static getName(actorStateId) {
+    return ActorStateConst.actorStateNames[actorStateId];
+  }
+}
+
+
+module.exports = ActorStateConst;

package/project/clientServer/execution/actor-type-const.js

@@ -0,0 +1,84 @@
+	
+'use strict';
+
+
+class ActorTypeConst {
+  static LOCAL = 0;
+  static COND = 1;
+  static ORIG = 2;
+  static REAL_SUT = 3;
+  static SUT = 4;
+  static PROXY = 5;
+  static TERM = 6;
+  static INTER = 7;
+  
+  static NAME_LOCAL = 'local';
+  static NAME_COND = 'cond';
+  static NAME_ORIG = 'orig';
+  static NAME_REAL_SUT = 'real_sut';
+  static NAME_SUT = 'sut';
+  static NAME_PROXY = 'proxy';
+  static NAME_TERM = 'term';
+  static NAME_INTER = 'inter';
+  
+  static FULL_NAME_LOCAL = 'Local';
+  static FULL_NAME_COND = 'Condition';
+  static FULL_NAME_ORIG = 'Originating';
+  static FULL_NAME_REAL_SUT = 'RealSut';
+  static FULL_NAME_SUT = 'Sut';
+  static FULL_NAME_PROXY = 'Proxy';
+  static FULL_NAME_TERM = 'Terminating';
+  static FULL_NAME_INTER = 'Intercepting';
+  
+  static names = [
+    ActorTypeConst.NAME_LOCAL,
+    ActorTypeConst.NAME_COND,
+    ActorTypeConst.NAME_ORIG,
+    ActorTypeConst.NAME_REAL_SUT,
+    ActorTypeConst.NAME_SUT,
+    ActorTypeConst.NAME_PROXY,
+    ActorTypeConst.NAME_TERM,
+    ActorTypeConst.NAME_INTER
+  ];
+  
+  static ids = new Map(
+    [
+      [ActorTypeConst.NAME_LOCAL, ActorTypeConst.LOCAL],
+      [ActorTypeConst.NAME_COND, ActorTypeConst.COND],
+      [ActorTypeConst.NAME_ORIG, ActorTypeConst.ORIG],
+      [ActorTypeConst.NAME_REAL_SUT, ActorTypeConst.REAL_SUT],
+      [ActorTypeConst.NAME_SUT, ActorTypeConst.SUT],
+      [ActorTypeConst.NAME_PROXY, ActorTypeConst.PROXY],
+      [ActorTypeConst.NAME_TERM, ActorTypeConst.TERM],
+      [ActorTypeConst.NAME_INTER, ActorTypeConst.INTER]
+    ]
+  );
+  
+  static fullNameIds = new Map(
+    [
+      [ActorTypeConst.FULL_NAME_LOCAL, ActorTypeConst.LOCAL],
+      [ActorTypeConst.FULL_NAME_COND, ActorTypeConst.COND],
+      [ActorTypeConst.FULL_NAME_ORIG, ActorTypeConst.ORIG],
+      [ActorTypeConst.FULL_NAME_REAL_SUT, ActorTypeConst.REAL_SUT],
+      [ActorTypeConst.FULL_NAME_SUT, ActorTypeConst.SUT],
+      [ActorTypeConst.FULL_NAME_PROXY, ActorTypeConst.PROXY],
+      [ActorTypeConst.FULL_NAME_TERM, ActorTypeConst.TERM],
+      [ActorTypeConst.FULL_NAME_INTER, ActorTypeConst.INTER]
+    ]
+  );
+
+  static getName(id) {
+    return ActorTypeConst.names[id];
+  }
+  
+  static getId(name) {
+    return ActorTypeConst.ids.get(name);
+  }
+  
+  static getPriority(id) {
+    
+  }
+}
+
+
+module.exports = ActorTypeConst;

package/project/clientServer/log/log-data-action.js

@@ -0,0 +1,62 @@
+
+'use strict';
+
+class LogDataAction {
+  static length = 0;
+  static STARTING = LogDataAction.length++;
+  static STARTED = LogDataAction.length++;
+  static ATTACHED = LogDataAction.length++;
+  static STOPPING = LogDataAction.length++;
+  static STOPPED = LogDataAction.length++;
+  static DETACHED = LogDataAction.length++;
+  static NOT_STARTED = LogDataAction.length++;
+  static NOT_ATTACHED = LogDataAction.length++;
+  static SEND = LogDataAction.length++;
+  static RECEIVE = LogDataAction.length++;
+  static CONNECTING = LogDataAction.length++;
+  static CONNECTED = LogDataAction.length++;
+  static DNS_FAILURE = LogDataAction.length++;
+  static NOT_CONNECTED = LogDataAction.length++;
+  static UPGRADING = LogDataAction.length++;
+  static UPGRADED = LogDataAction.length++;
+  static NOT_UPGRADED = LogDataAction.length++;
+  static ACCEPTING = LogDataAction.length++;
+  static ACCEPTED = LogDataAction.length++;
+  static HALF_CLOSING = LogDataAction.length++;
+  static HALF_CLOSED = LogDataAction.length++;
+  static CLOSING = LogDataAction.length++;
+  static CLOSED = LogDataAction.length++;
+  static GUI = LogDataAction.length++;
+  static STACK = LogDataAction.length++;
+  
+  static LOG = [
+    'STARTING',
+    'STARTED',
+    'ATTACHED',
+    'STOPPING',
+    'STOPPED',
+    'DETACHED',
+    'NOT_STARTED',
+    'NOT_ATTACHED',
+    'SEND',
+    'RECEIVE',
+    'CONNECTING',
+    'CONNECTED',
+    'DNS_FAILURE',
+    'NOT_CONNECTED',
+    'UPGRADING',
+    'UPGRADED',
+    'NOT_UPGRADED',
+    'ACCEPTING',
+    'ACCEPTED',
+    'HALF_CLOSING',
+    'HALF_CLOSED',
+    'CLOSING',
+    'CLOSED',
+    'GUI',
+    'STACK'
+  ];
+}
+
+
+module.exports = LogDataAction;

package/project/clientServer/log/log-data-gui-sub-type.js

@@ -0,0 +1,36 @@
+
+'use strict';
+
+
+class LogDataGuiSubType {
+  static SUB_TYPE_OBJECT = 0;
+  static SUB_TYPE_ACTION = 1;
+  static SUB_TYPE_FUNCTION = 2;
+    
+  static subTypes = [
+    LogDataGuiSubType.SUB_TYPE_OBJECT,
+    LogDataGuiSubType.SUB_TYPE_OBJECT,
+    LogDataGuiSubType.SUB_TYPE_OBJECT,
+    LogDataGuiSubType.SUB_TYPE_OBJECT,
+    LogDataGuiSubType.SUB_TYPE_ACTION,
+    LogDataGuiSubType.SUB_TYPE_ACTION,
+    LogDataGuiSubType.SUB_TYPE_FUNCTION
+  ];
+  
+  static SUB_TYPE_TEXT_OBJECT = 'object';
+  static SUB_TYPE_TEXT_ACTION = 'action';
+  static SUB_TYPE_TEXT_FUNCTION = 'function';
+  
+  static subTypeNames = [
+    LogDataGuiSubType.SUB_TYPE_TEXT_OBJECT,
+    LogDataGuiSubType.SUB_TYPE_TEXT_OBJECT,
+    LogDataGuiSubType.SUB_TYPE_TEXT_OBJECT,
+    LogDataGuiSubType.SUB_TYPE_TEXT_OBJECT,
+    LogDataGuiSubType.SUB_TYPE_TEXT_ACTION,
+    LogDataGuiSubType.SUB_TYPE_TEXT_ACTION,
+    LogDataGuiSubType.SUB_TYPE_TEXT_FUNCTION
+  ];
+}
+
+
+module.exports = LogDataGuiSubType;

package/project/clientServer/log/log-data-gui-type.js

@@ -0,0 +1,44 @@
+
+'use strict';
+
+
+class LogDataGuiType {
+  static NEW_BROWSER = 0;
+  static USE_BROWSER = 1;
+  static NEW_PAGE = 2;
+  static USE_PAGE = 3;
+  static ACTION_CLICK = 4;
+  static ACTION_TYPE = 5;
+  static FUNCTION_CALL = 6;
+  
+  static TEXT_NEW_BROWSER = 'new browser';
+  static TEXT_USE_BROWSER = 'use browser';
+  static TEXT_NEW_PAGE = 'new page';
+  static TEXT_USE_PAGE = 'use page';
+  static TEXT_ACTION_CLICK = 'click';
+  static TEXT_ACTION_TYPE = 'type';
+  static TEXT_FUNCTION_CALL = 'function';
+  
+  static results = [
+    LogDataGuiType.TEXT_NEW_BROWSER,
+    LogDataGuiType.TEXT_USE_BROWSER,
+    LogDataGuiType.TEXT_NEW_PAGE,
+    LogDataGuiType.TEXT_USE_PAGE,
+    LogDataGuiType.TEXT_ACTION_CLICK,
+    LogDataGuiType.TEXT_ACTION_TYPE,
+    LogDataGuiType.TEXT_FUNCTION_CALL
+  ];
+  
+  static resultClasses = [
+    'gui_seq_dia_browser_svg',
+    'gui_seq_dia_browser_svg',
+    'gui_seq_dia_page_svg',
+    'gui_seq_dia_page_svg',
+    'gui_seq_dia_click_svg',
+    'gui_seq_dia_type_svg',
+    'gui_seq_dia_not_impl_svg'
+  ];
+}
+
+
+module.exports = LogDataGuiType;

package/project/clientServer/log/log-data-stack-type.js

@@ -0,0 +1,30 @@
+
+'use strict';
+
+
+class LogDataStackType {
+  static NEW = 0;
+  static SHARED = 1;
+  static USE = 2;
+  static STORE = 3;
+  static DEL = 4;
+  
+  static results = [
+    'new stack',
+    'shared stack',
+    'use stack',
+    'store stack',
+    'del stack'
+  ];
+  
+  static templateWidths = [
+    50,
+    60,
+    47,
+    55,
+    45
+  ];
+}
+
+
+module.exports = LogDataStackType;

package/project/clientServer/log/log-inner.js

@@ -0,0 +1,79 @@
+
+'use strict';
+
+const LogPartText = require('./log-part-text');
+
+
+class LogInner {
+  static TYPE_PARTS = 0;
+  static TYPE_BUFFER = 1;
+  static TYPE_BUFFER_INNER = 2;
+  
+  constructor(logParts, inner) {
+    if(logParts) {
+      if(Array.isArray(logParts)) {
+        this.logParts = logParts;
+      }
+      else {
+        if('string' === typeof logParts) {
+          this.logParts = [new LogPartText(logParts)];
+        }
+        else {
+          this.logParts = [logParts];
+        }
+      }
+    }
+    else {
+      this.logParts = [];
+    }
+    if(inner) {
+      if(Array.isArray(inner)) {
+        this.inners = inner;
+      }
+      else {
+        this.inners = [inner];
+      }
+    }
+    else {
+      this.inners = [];
+    }
+    this.type = LogInner.TYPE_PARTS;
+  }
+  
+  add(inner) {
+    if(inner) {
+      if(Array.isArray(inner)) {
+        this.inners = this.inners.concat(inner);
+      }
+      else {
+        this.inners.push(inner);
+      }
+    }
+    else {
+      inner = new LogInner();
+      this.inners.push(inner);
+    }
+    return inner;
+  }
+  
+  addLogPart(logParts) {
+    if(Array.isArray(logParts)) {
+      this.logParts = this.logParts.concat(logParts);
+    }
+    else {
+      if('string' === typeof logParts) {
+        this.logParts.push(new LogPartText(logParts));
+      }
+      else {
+        this.logParts.push(logParts);
+      }
+    }
+  }
+  
+  setType(type) {
+    this.type = type;
+  }
+}
+
+
+module.exports = LogInner;

package/project/clientServer/log/log-message.js

@@ -0,0 +1,16 @@
+
+'use strict';
+
+
+class LogMessage {
+  constructor(message, inners, data, dataBuffers) {
+    this.message = 'string' === typeof message ? message : message();
+    this.inners = inners;
+    this.data = data;
+    this.dataBuffers = dataBuffers;
+  }
+}
+
+
+module.exports = LogMessage;
+

package/project/clientServer/log/log-object-ip.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+
+class LogObjectIp {
+  constructor(actionId, stackId, stackName, secure, caption, local, remote) {
+    this.actionId = actionId;
+    this.stackId = stackId;
+    this.stack = stackName;
+    this.secure = secure;
+    this.caption = caption;
+    this.local = local;
+    this.remote = remote;
+  }
+}
+
+
+module.exports = LogObjectIp;

package/project/clientServer/log/log-part-buffer-cached.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+const LogPartType = require('./log-part-type');
+
+
+class LogPartBufferCached {
+  constructor(url) {
+    this.type = LogPartType.BUFFER_CACHED;
+    this.url = url;
+  }
+}
+
+
+module.exports = LogPartBufferCached;

package/project/clientServer/log/log-part-buffer.js

@@ -0,0 +1,17 @@
+
+'use strict';
+
+const LogPartType = require('./log-part-type');
+
+
+class LogPartBuffer {
+  constructor(contentType, contentEncoding, transferEncoding) {
+    this.type = LogPartType.BUFFER;
+    this.contentType = contentType;
+    this.contentEncoding = contentEncoding;
+    this.transferEncoding = transferEncoding;
+  }
+}
+
+
+module.exports = LogPartBuffer;

package/project/clientServer/log/log-part-error.js

@@ -0,0 +1,19 @@
+
+'use strict';
+
+const LogPartType = require('./log-part-type');
+
+
+class LogPartError {
+  constructor(text, file, line, column, sourceType) {
+    this.type = LogPartType.ERROR;
+    this.text = text;
+    this.file = file;
+    this.line = line;
+    this.column = column;
+    this.sourceType = sourceType;
+  }
+}
+
+
+module.exports = LogPartError;

package/project/clientServer/log/log-part-ref.js

@@ -0,0 +1,16 @@
+
+'use strict';
+
+const LogPartType = require('./log-part-type');
+
+
+class LogPartRef {
+  constructor(text, ref) {
+    this.type = LogPartType.REF;
+    this.text = text;
+    this.ref = ref;
+  }
+}
+
+
+module.exports = LogPartRef;

package/project/clientServer/log/log-part-text.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+const LogPartType = require('./log-part-type');
+
+
+class LogPartText {
+  constructor(text) {
+    this.type = LogPartType.TEXT
+    this.text = text;
+  }
+}
+
+
+module.exports = LogPartText;

package/project/clientServer/log/log-part-type.js

@@ -0,0 +1,26 @@
+
+'use strict';
+
+
+class LogPartType {
+  static TEXT = 0;
+  static REF = 1;
+  static BIN = 2;
+  static VALUE = 3;
+  static ERROR = 4;
+  static BUFFER = 5;
+  static BUFFER_CACHED = 6;
+  
+  static names = [
+    'text',
+    'ref',
+    'bin',
+    'value',
+    'error',
+    'buffer',
+    'buffer-cached'
+  ];
+}
+
+
+module.exports = LogPartType;

package/project/clientServer/log/log-source-type.js

@@ -0,0 +1,16 @@
+
+'use strict';
+
+
+let id = -1;
+class LogSourceType {
+  static UNKNOWN = ++id;
+  static SERVER = ++id;
+  static STACK = ++id;
+  static ACTOR = ++id;
+  static NODE = ++id;
+  static ANONYMOUS = ++id;
+}
+
+
+module.exports = LogSourceType;

package/project/clientServer/log/log-type.js

@@ -0,0 +1,88 @@
+
+'use strict';
+
+
+class LogType {
+  // DOUBLE-CODE: z-abs-corelayer-cs
+  static length = 0;
+  static ENGINE = LogType.length++;
+  static DEBUG = LogType.length++;
+  static ERROR = LogType.length++;
+  static WARNING = LogType.length++;
+  static IP = LogType.length++;
+  static GUI = LogType.length++;
+  static VERIFY_SUCCESS = LogType.length++;
+  static VERIFY_FAILURE = LogType.length++;
+  static TEST_DATA = LogType.length++;
+  static BROWSER_LOG = LogType.length++;
+  static BROWSER_ERR = LogType.length++;
+  
+  static names = [
+    'Engine  ',
+    'Debug   ',
+    'Error   ',
+    'Warning ',
+    'IP      ',
+    'GUI     ',
+    'Success ',
+    'Failure ',
+    'TestData',
+    'B-Log   ',
+    'B-Err   '
+  ];
+  
+  static pureNames = [
+    'Engine',
+    'Debug',
+    'Error',
+    'Warning',
+    'IP',
+    'GUI',
+    'Success',
+    'Failure',
+    'TestData',
+    'BrowserLog',
+    'BrowserErr'
+  ];
+  
+  static csses = [
+    'log_engine',
+    'log_debug',
+    'log_error',
+    'log_warning',
+    'log_ip',
+    'log_gui',
+    'log_verify_success',
+    'log_verify_failure',
+    'log_test_data',
+    'log_browser_log',
+    'log_browser_err'
+  ];
+  
+  static hasInner = [
+    false,
+    false,
+    true,
+    false,
+    true,
+    false,
+    false,
+    false,
+    false,
+    false,
+    false
+  ];
+  
+  static getClassFromName(resultName) {
+    const foundIndex = LogType.pureNames.indexOf(resultName);
+    if(-1 !== foundIndex) {
+      return LogType.csses[foundIndex];
+    }
+    else {
+      return '';
+    }
+  }
+}
+
+
+module.exports = LogType;

package/project/clientServer/log/msg/log-msg-client.js

@@ -0,0 +1,16 @@
+
+'use strict';
+
+
+class LogMsgClient {
+  constructor(actionId, stackName, local, remote, reverse) {
+    this.actionId = actionId;
+    this.stack = stackName;
+    this.local = local;
+    this.remote = remote;
+    this.reverse = reverse;
+  }
+}
+
+
+module.exports = LogMsgClient;

package/project/clientServer/log/msg/log-msg-message.js

@@ -0,0 +1,16 @@
+
+'use strict';
+
+
+class LogMsgMessage {
+  constructor(actionId, stackName, local, remote, caption) {
+    this.actionId = actionId;
+    this.stack = stackName;
+    this.local = local;
+    this.remote = remote;
+    this.caption = caption;
+  }
+}
+
+
+module.exports = LogMsgMessage;

package/project/clientServer/log/msg/log-msg-server.js

@@ -0,0 +1,16 @@
+
+'use strict';
+
+const LogDataAction = require('../log-data-action');
+
+
+class LogMsgServer {
+  constructor(actionId, stackName, local) {
+    this.actionId = actionId;
+    this.stack = stackName;
+    this.local = local;
+  }
+}
+
+
+module.exports = LogMsgServer;

package/project/clientServer/log/msg/log-msg-stack.js

@@ -0,0 +1,19 @@
+
+'use strict';
+
+const LogDataAction = require('../log-data-action');
+
+
+class LogMsgStack {
+  constructor(columnIndex, logDataStackType, stackId, stackType, stack) {
+    this.actionId = LogDataAction.STACK;
+    this.actorIndex = columnIndex;
+    this.type = logDataStackType;
+    this.stackId = stackId;
+    this.stackType = stackType;
+    this.stack = stack;
+  }
+}
+
+
+module.exports = LogMsgStack;