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

package/.gitattributes

@@ -0,0 +1,26 @@
+
+# Set the default behavior, in case people don't have core.autocrlf set.
+* text=auto
+
+# Explicitly declare text files you want to always be normalized and converted
+# to native line endings on checkout.
+*.json text
+*.js text
+*.jsx text
+*.txt text
+*.md text
+*.bld text
+*.tsk text
+*.css text
+*.html text
+
+
+# Declare files that will always have CRLF line endings on checkout.
+#*.sln text eol=crlf
+
+# Declare files that will always have LF line endings on checkout.
+#*.txt text eol=lf
+
+# Denote all files that are truly binary and should not be modified.
+*.png binary
+*.jpg binary

package/LICENSE.txt

@@ -0,0 +1,96 @@
+
+LICENSE AGREEMENT
+
+Effective: 1st of November 2020
+This License Agreement is between Licensee and Hagnell Konsulting AB (a company incorporated in Sweden with
+company registration number: 559476-0570) (“Hagnell Konsulting”) and governs the use by Licensee of ActorJs
+(as defined below).
+By installing the Software (as defined below), Licensee agrees to be bound by the terms of this License Agreement.
+
+DEFENITIONS
+ActorJs The test tool developed by Hagnell Konsulting, utilizing the Patent and the Software.
+Derivative Works Any work, whether in source or object code, which is based on the Software and which
+does not constitute a new and independent work pursuant to paragraph 2 of article 4 of
+the Swedish Act (1960:729) on Copyright in Literary and Artistic Works.
+Documentation The manuals and instruction materials furnished by Hagnell Konsulting in connection
+with ActorJs.
+Licensee The physical or legal person to which the License hereunder has been granted by
+Hagnell Konsulting.
+Patent The patent application for a system and method for testing of systems under test, patent
+application number:19218798.7 (European Patent Office).
+Software The software developed and owned by Hagnell Konsulting, identified as ActorJs.
+
+§ 1 - LICENSE
+Licensee is hereby granted a limited, non-exclusive and non-transferable license to use ActorJs (including any
+Derivative Works created by Licensee hereunder) (the “License”). The License is granted subject to the terms and
+conditions set forth below.
+The Software is licensed to Licensee on an open source basis. The License includes the right to create Derivative
+Works pursuant to sub-clause 3 below.
+ActorJs may be used only by Licensee himself/herself/itself, or (if, for instance, Licensee is a company), by the
+employees and consultants of Licensee.
+The License does not include any updates to the Software, or any support services. Notwithstanding the foregoing,
+should Hagnell Konsulting furnish any updates to Licensee, such updates shall be subject to the License granted hereunder.
+As regards the Documentation provided by Hagnell Konsulting, Licensee may use this Documentation for the purpose of
+ the License hereunder (only). Licensee shall not be entitled to distribute copies of the Documentation, or electronically
+ communicate the Documentation, to recipients who are not employees or consultants of Licensee.
+
+§ 2 - LICENSE RESTRICTIONS
+Licensee may not:
+i) Rent, lease, lend, sell, distribute, transfer or otherwise make available ActorJs (and/or a Derivative Work)
+(whether for value or otherwise) to third parties without Hagnell Konsulting´s written approval. Any such approval
+will be subject to the third party acknowledging in writing (vis-à-vis Hagnell Konsulting) that its use of ActorJs
+(and/or the Derivative Work) shall be subject to the terms and conditions of this Agreement.
+
+ii) Distribute copies of the Software (and/or a Derivate Work), or electronically communicate the Software
+(and/or a Derivative Work), to recipients who are not employees or consultants of Licensee.
+
+§ 3 – DERITATIVE WORKS
+Should Licensee, or (if applicable) any of its employees or consultants, create a Derivative Work, Licensee shall
+inform Hagnell Konsulting thereof in writing (an e-mail shall be sufficient). Licensee may use the Derivative Work to the
+same extent as it may use the Software hereunder, but Hagnell Konsulting shall be the sole and exclusive owner of any
+and all rights in the Derivative Work, including the copyright. At the request of Hagnell Konsulting, Licensee and
+Hagnell Konsulting shall formalize the rights transfer in a written contract, which shall, inter alia, confirm that all rights
+in the Derivative Work have been irrevocably transferred to Hagnell Konsulting, that Hagnell Konsulting is be entitled to
+exploit the Derivative Work without limitation in time or any other kind of limitation, that Hagnell Konsulting may transfer
+its rights to the Derivative Work to third parties and that the rights transfer from Licensee to Hagnell Konsulting shall be
+free of charge.
+
+§ 4 – IMPROVEMENTS TO THE PATENT
+Any improvement to the Patent, whether patentable or not, which Licensee, or (if applicable) any of its employees or
+consultants, may discover, create or develop or otherwise have at its disposal, directly or indirectly, without restraints
+as to the use thereof (“Improvements”), shall be disclosed promptly to Hagnell Konsulting and Hagnell Konsulting shall
+have the exclusive right of perpetual duration to use the Improvements as well as to grant the use thereof to other licensees
+in the whole world without compensation to Licensee, except that Licensee shall during the life of this Agreement have
+the non-exclusive right to use such Improvements including corresponding patents, if any, in accordance with the
+provisions of this Agreement. If Licensee decides not to apply for a patent relating to an Improvement made by
+Licensee or if Licensee no longer wishes to maintain such a patent or patent application then Hagnell Konsulting may in its
+sole discretion and at its own expense apply for such a patent or maintain such a patent or patent application (as the
+case may be).
+
+§ 5 - COPYRIGHT AND INTELLECTUAL PROPERTY RIGHTS
+The Software, the Patent and the Documentation are protected by copyright and patent laws and international
+copyright and patent treaties, as well other intellectual property laws and treaties. Any such intellectual property
+rights are owned and especially reserved by Hagnell Konsulting, without limitation. For the avoidance of doubt, no
+ownership rights are transferred to Licensee hereunder.
+“ActorJs” is a registered trademark of Hagnell Konsulting. This Agreement does not include a license to use the
+trademark “ActorJs”.
+
+§ 6 - LIMITITATION ON LIABILITY
+ActorJs is licensed to Licensee “as is”. Hagnell Konsulting gives no guarantees as regards the use, functionality
+or performance of ActorJs and assumes no liability (whatsoever) as regards any defaults in ActorJs or any possible
+infringements on third party statutory or contractual rights. Hagnell Konsulting expressly disclaims any and all warranties
+not expressly given in this Agreement, including any implied warranties of merchantability, satisfactory quality, fitness
+for a particular purpose, title and non-infringement. Thus, the entire risk arising out of any use of ActorJs hereunder
+remains with Licensee.
+The limitation of liability hereunder shall be to the maximum extent permitted by applicable law. Under no
+circumstances shall Hagnell Konsulting be liable for any cost of substitute products or services, for any indirect losses or
+for any consequential damages (including any loss of profits, interruptions or loss of business information).
+
+§ 7 - MISCELLANEOUS
+Licensee may not, either wholly or partly, assign or pledge its rights or obligations under this Agreement to any third
+party without the prior written consent of Hagnell Konsulting.
+
+§ 8 - DISPUTES
+This agreement shall be governed by Swedish law. Any dispute, controversy or claim arising out of or in connection
+with this contract, or the breach, termination or invalidity thereof, shall be settled by the general courts of Sweden,
+with the district court of Stockholm in the first instance. 

package/README.md

@@ -0,0 +1,5 @@
+# README #
+
+# ActorJs
+
+**Library used by @actorjs/actorjs**

package/npm-shrinkwrap.json

@@ -0,0 +1,13 @@
+{
+  "name": "@aj-shadow/z-abs-corelayer-cs",
+  "version": "0.0.0-aj-beta.221",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@aj-shadow/z-abs-corelayer-cs",
+      "version": "0.0.0-aj-beta.221",
+      "license": "SEE LICENSE IN LICENSE.txt"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@aj-shadow/z-abs-corelayer-cs",
+  "version": "0.0.0-aj-beta.221",
+  "release-step": "delivery",
+  "description": "Library used by @actorjs/actorjs",
+  "author": "ActorJs",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "repository": "https://gitlab.com/actorjs-shadow-delivery-public/z-abs-corelayer-cs.git",
+  "dependencies": {}
+}

package/project/clientServer/_build/Bundle-CoreLayer-cs.bld

@@ -0,0 +1,25 @@
+{
+  "layer": "Core",
+  "part": "cs",
+  "source": {
+    "path": "./build/z-abs-corelayer-cs/clientServer",
+	  "filters": ["js"]
+  },
+  "dest": "./dist/scripts",
+  "_bundle": true,
+  "ignores": [
+    "cli-color",
+    "path"
+  ],
+  "externals": [
+    "os",
+    "_process"
+  ],
+  "externalGlobs": null,
+  "exports": null,
+  "exportSource": true,
+  "dependencyNames": [
+    "Client:CoreLayer/cs",
+    "Client:3ppLayer/Nodejs-client"
+  ]
+}

package/project/clientServer/_build/Client-CoreLayer-cs.bld

@@ -0,0 +1,10 @@
+{
+  "layer": "Core",
+  "part": "cs",
+  "source": {
+    "path": "./project/clientServer",
+    "filters": ["js"]
+  },
+  "dest": "./build/z-abs-corelayer-cs/clientServer",
+  "dependencyNames": []
+}

package/project/clientServer/_build/Server-CoreLayer-cs.bld

@@ -0,0 +1,12 @@
+{
+  "layer": "Core",
+  "part": "cs",
+  "source": {
+     "path": "./project/clientServer",
+	 "filters": ["js"]
+  },
+  "dest": "./dist/Layers/z-abs-corelayer-cs/clientServer",
+  "replaceCondition": null,
+  "replaceHandle": null,
+  "dependencyNames": []
+}

package/project/clientServer/_build/z-abs-corelayer-cs.prj

@@ -0,0 +1,28 @@
+{
+  "builds": [
+    {
+      "name": "Server:CoreLayer/cs",
+      "type": "server",
+      "fileName": "Server-CoreLayer-cs",
+      "requireName": "build-server-js",
+      "repo": "z-abs-corelayer-cs",
+      "repoPath": "."
+    },
+    {
+      "name": "Client:CoreLayer/cs",
+      "type": "client",
+      "fileName": "Client-CoreLayer-cs",
+      "requireName": "build-client-js",
+      "repo": "z-abs-corelayer-cs",
+      "repoPath": "."
+    },
+    {
+      "name": "Bundle:CoreLayer/cs",
+      "type": "client",
+      "fileName": "Bundle-CoreLayer-cs",
+      "requireName": "build-client-bundle",
+      "repo": null,
+      "repoPath": "."
+    }
+  ]
+}

package/project/clientServer/cache/cache-array.js

@@ -0,0 +1,38 @@
+
+'use strict';
+
+
+class CacheArray {
+  constructor() {
+    this.cacheArray = [];
+  }
+  
+  get() {
+    if(0 !== this.cacheArray.length) {
+      return this.cacheArray.pop();
+    }
+    else {
+      return new Array(4);
+    }
+  }
+  
+  put(array) {
+    array.length = 4;
+    this.cacheArray.push(array);
+  }
+  
+  setValue(array, index, value) {
+    if(index < array.length) {
+      array[index] = value;
+    }
+    else {
+      while(array.length <= index) {
+        array.push(null);
+      }
+      array.push(value);
+    }
+  }
+}
+
+
+module.exports = CacheArray;

package/project/clientServer/cache/cache-map.js

@@ -0,0 +1,26 @@
+
+'use strict';
+
+
+class CacheMap {
+  constructor() {
+    this.cacheMap = [];
+  }
+  
+  get() {
+    if(0 !== this.cacheMap.length) {
+      return this.cacheMap.pop();
+    }
+    else {
+      return new Map();
+    }
+  }
+  
+  put(map) {
+    map.clear();
+    this.cacheMap.push(map);
+  }
+}
+
+
+module.exports = CacheMap;

package/project/clientServer/cache/cache-set.js

@@ -0,0 +1,24 @@
+
+'use strict';
+
+
+class CacheSet {
+  static cache = [];
+  
+  static get() {
+    if(0 !== CacheSet.cache.length) {
+      return CacheSet.cache.pop();
+    }
+    else {
+      return new Set();
+    }
+  }
+  
+  static put(set) {
+    set.clear();
+    CacheSet.cache.push(set);
+  }
+}
+
+
+module.exports = CacheSet;

package/project/clientServer/communication/action-request.js

@@ -0,0 +1,34 @@
+
+'use strict';
+
+const CoreProtocolConst = require('./core-protocol/core-protocol-const');
+
+
+class ActionRequest {
+  constructor(requests = []) {
+    this.msgId = CoreProtocolConst.REQUEST;
+    this.id = '';
+    this.requests = requests;
+    this.isServiceAction = false;
+  }
+  
+  setIds(requestId, sessionId) {
+    this.id = requestId;
+    this.requests.forEach((request) => {
+      request.sessionId = sessionId;
+    });
+  }
+  
+  add(name, index, ...params) {
+    this.requests.push({
+      name: name,
+      index: index,
+      sessionId: undefined,
+      params: [...params]
+    });
+    return this;
+  }
+}
+
+
+module.exports = ActionRequest;

package/project/clientServer/communication/action-response-error.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+
+class ActionResponseError {
+  constructor(name, index, msg) {
+    this.name = name;
+    this.index = index;
+    this.isServiceAction = false;
+    this.result = {
+      code: 'error',
+      msg: msg
+    };
+  }
+}
+
+
+module.exports = ActionResponseError;

package/project/clientServer/communication/action-response-success.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+
+class ActionResponseSuccess {
+  constructor(name, index, data) {
+    this.name = name;
+    this.index = index;
+    this.data = data;
+    this.isServiceAction = false;
+    this.result = {
+      code: 'success'
+    };
+  }
+}
+
+
+module.exports = ActionResponseSuccess;

package/project/clientServer/communication/app-protocol/app-deserializer.js

@@ -0,0 +1,74 @@
+
+'use strict';
+
+
+class AppDeserializer {
+  constructor(decoder, decoderCahced) {
+    this.decoder = decoder;
+    this.decoderCahced = decoderCahced;
+    this.dataDecoders = new Map();
+  }
+  
+  do(msgId, buffer, dataBuffers, isServiceAction) {
+    return this._do(msgId, buffer, dataBuffers, isServiceAction);
+  }
+  
+  clear() {
+    this.decoder.clear();
+  }
+  
+  _do(msgId, buffer, dataBuffers, isServiceAction) {
+    const deserializerData = this.dataDecoders.get(msgId);
+    if(!deserializerData) {
+      return null;
+    }
+    else {
+      this.decoder.add(buffer);
+      if(this.decoder.has(buffer.byteLength)) {
+        const msg = deserializerData.deserializer.do(msgId, deserializerData.onRealtimeName, this.decoder, isServiceAction);
+        if(msg) {
+          this.decoder.got();
+          return msg;
+        }
+      }
+      return null;
+    } 
+  }
+  
+  doMsg(msg) {
+    const deserializerData = this.dataDecoders.get(msg.msgId);
+    if(deserializerData) {
+      msg.onRealtimeName = deserializerData.onRealtimeName;
+    }
+  }
+  
+  doCachedText(cachedTextBuffer) {
+    const decoder = this.decoderCahced;
+    decoder.add(cachedTextBuffer);
+    decoder.has(cachedTextBuffer.byteLength);
+    const nbrOfCachedTexts = decoder.getUint8();
+    for(let i = 0; i < nbrOfCachedTexts; ++i) {
+      const ct = decoder.getCt();
+      const text = decoder.getString();
+      this.decoder.textCache.set(ct, text);
+    }
+    decoder.got();
+  }
+  
+  register(id, name, deserializer) {
+    if(!this.dataDecoders.has(id)) {
+      this.dataDecoders.set(id, {
+        onRealtimeName: name ? `onRealtime${name}` : null,
+        name: deserializer ? deserializer.constructor.name : (name ? name : 'unknown'),
+        deserializer: deserializer
+      });
+    }
+    else {
+      const deserializerData = this.dataDecoders.get(id);
+      ddb.error(`App deserializer: ${deserializerData.name} have already registered the id: ${id}`);
+    }
+  }
+}
+
+
+module.exports = AppDeserializer;

package/project/clientServer/communication/app-protocol/app-serializer.js

@@ -0,0 +1,55 @@
+
+'use strict';
+
+
+class AppSerializer {
+  constructor() {
+    this.appSerializers = new Map();
+    this.encoder = null;
+  }
+  
+  init(encoder) {
+    this.encoder = encoder;
+  }
+  
+  do(msgId, msg, cachedTexts) {
+    const buffer = this._do(msgId, msg, cachedTexts);
+    this.encoder.clear();
+    return buffer;
+  }
+  
+  clear() {
+    this.textCache.clear();
+  }
+  
+  _do(msgId, msg, cachedTexts) {
+    const serializerData = this.appSerializers.get(msgId);
+    if(serializerData) {
+      return serializerData.appSerializer.do(msg, cachedTexts);
+    }
+    else {
+      return null;
+    } 
+  }
+  
+  _register(msgId, appSerializer) {
+    appSerializer.init(this.encoder);
+    this.appSerializers.set(msgId, {
+      name: appSerializer ? appSerializer.constructor.name : 'null',
+      appSerializer: appSerializer
+    });
+  }
+  
+  register(msgId, appSerializer) {
+    if(!this.appSerializers.has(msgId)) {
+      this._register(msgId, appSerializer);
+    }
+    else {
+      const serializerData = this.appSerializers.get(msgId);
+      ddb.error(`App serializer: ${serializerData.name} have already registered the msgId: ${msgId}`);
+    }
+  }
+}
+
+
+module.exports = AppSerializer;

package/project/clientServer/communication/cache/text-cache.js

@@ -0,0 +1,77 @@
+
+'use strict';
+
+
+class TextCache {
+  constructor(name, pid=null) {
+    this.name = name;
+    this.pid = pid;
+    this.externalId = 0;
+    this.externalText = new Map([['', 0]]);
+    this.externalNumber = [''];
+    this.internalId = 0;
+    this.internalText = new Map([['', 0]]);
+    this.internalNumber = [''];
+  }
+  
+  getText(id) {
+    if(id >= 0) {
+      return this.externalNumber[id];
+    }
+    else {
+      return this.internalNumber[id];
+    }
+  }
+  
+  set(id, text) {
+    this.externalText.set(text, id);
+    this.externalNumber.push(text);
+  }
+  
+  setExternal(text, cachedTexts) {
+    if(this.externalText.has(text)) {
+      const id = this.externalText.get(text);
+      return id;
+    }
+    else {
+      const id = ++this.externalId;
+      this.externalText.set(text, id);
+      this.externalNumber.push(text);
+      ++cachedTexts.nbr;
+      cachedTexts.texts.push({
+        id: id, 
+        text: text
+      });
+      return id;
+    }
+  }
+  
+  setInternal(text) {
+    if(this.externalText.has(text)) {
+      const id = this.externalText.get(text);
+      return id;
+    }
+    else if(this.internalText.has(text)) {
+      const id = this.internalText.get(text);
+      return id;
+    }
+    else {
+      const id = --this.internalId;
+      this.internalText.set(text, id);
+      this.internalNumber.push(text);
+      return id;
+    }
+  }
+  
+  clear() {
+    this.externalId = 0;
+    this.externalText.clear();
+    this.externalNumber = [];
+    this.internalId = 0;
+    this.internalText.clear();
+    this.internalNumber = [];
+  }
+}
+
+
+module.exports = TextCache;

package/project/clientServer/communication/core-protocol/core-message.js

@@ -0,0 +1,22 @@
+
+'use strict';
+
+
+class CoreMessage {
+  constructor(msgId, hasEnvelope, isBinary, hasBuffers, hasTextCache, isServiceAction, envelope, msg, bin, cachedTextBuffer, dataBuffers) {
+    this.msgId = msgId;
+    this.hasEnvelope = hasEnvelope;
+    this.isBinary = isBinary;
+    this.hasBuffers = hasBuffers;
+    this.hasTextCache = hasTextCache;
+    this.isServiceAction = isServiceAction;
+    this.envelope = envelope;
+    this.msg = msg;
+    this.bin = bin;
+    this.cachedTextBuffer = cachedTextBuffer;
+    this.dataBuffers = dataBuffers;
+  }
+}
+
+
+module.exports = CoreMessage;

package/project/clientServer/communication/core-protocol/core-protocol-const.js

@@ -0,0 +1,21 @@
+
+'use strict';
+
+
+class CoreProtocolConst {
+  static REQUEST = 1;
+  static RESPONSE = 2;
+  static WORKER_INIT_REQUEST = 3;
+  static WORKER_INIT_RESPONSE = 4;
+  static PERSISTENT_INIT_REQUEST = 5;
+  static PERSISTENT_INIT_RESPONSE = 6;
+  static PERSISTENT_PUBLISH = 7;
+  static SERVICE_INIT_REQUEST = 8;
+  static SERVICE_INIT_RESPONSE = 9;
+  static SERVICE_OFFER_ON = 10;
+  static SERVICE_OFFER_OFF = 11;
+  static APP = 999;
+}
+
+
+module.exports = CoreProtocolConst;

package/project/clientServer/communication/core-protocol/deserializer-message-persistent-init-request.js

@@ -0,0 +1,12 @@
+
+'use strict';
+
+
+class DeserializerMessagePersistentInitRequest {
+  constructor() {
+    
+  }
+}
+
+
+module.exports = DeserializerMessagePersistentInitRequest;

package/project/clientServer/communication/core-protocol/deserializer-message-persistent-init-response.js

@@ -0,0 +1,12 @@
+
+'use strict';
+
+
+class DeserializerMessagePersistentInitResponse {
+  constructor() {
+    
+  }
+}
+
+
+module.exports = DeserializerMessagePersistentInitResponse;