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

package/project/client/communication/core-protocol/pooled-encoder.js

@@ -0,0 +1,505 @@
+
+'use strict';
+
+import PooledBuffers from './pooled-buffers';
+import EncoderConst from 'z-abs-corelayer-cs/clientServer/communication/core-protocol/Encoder-const';
+
+
+class PooledEncoder {
+  static GuidSize = EncoderConst.GuidSize;
+  static Int8Size = EncoderConst.Int8Size;
+  static Int16Size = EncoderConst.Int16Size;
+  static Int32Size = EncoderConst.Int32Size;
+  static Int64Size = EncoderConst.Int64Size;
+  static Uint8Size = EncoderConst.Uint8Size;
+  static Uint16Size = EncoderConst.Uint16Size;
+  static Uint32Size = EncoderConst.Uint32Size;
+  static Uint64Size = EncoderConst.Uint64Size;
+  static Float32Size = EncoderConst.Float32Size;
+  static Float64Size = EncoderConst.Float64Size;
+  static CtSize = EncoderConst.CtSize;
+  
+  static textEncoder = new TextEncoder();
+  static ASCII = [
+    -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1,
+     0,  1,  2,  3,  4,  5,  6,  7,
+     8,  9, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, 10, 11, 12, 13, 14, 15, -1
+  ];
+  
+#BUILD_DEBUG_START
+  static ddmGroup = null;
+  
+  static {
+    PooledEncoder.ddmGroup = ddm.addGroup('PooledEncoder.dataView');
+  }
+#BUILD_DEBUG_STOP
+  
+  constructor(textCache) {
+    this.textCache = textCache;
+    this.offset = 0;
+    this.dataView = null;
+    this.pooledBuffers = null;
+  }
+  
+  init(pooledBuffers) {
+    this.pooledBuffers = pooledBuffers;
+  }
+  
+  createBuffer(size, offset) {
+#BUILD_DEBUG_START
+    ddm.register(this.dataView, PooledEncoder.ddmGroup);
+#BUILD_DEBUG_STOP
+    const bufferData = this.pooledBuffers.getBuffer(size);
+    this.dataView = this.pooledBuffers.dataViews[bufferData.buffersIndex];
+    this.offset = bufferData.offset + offset;
+    return bufferData;
+  }
+  
+  attach(bufferData, offset) {
+    this.dataView = this.pooledBuffers.dataViews[bufferData.buffersIndex];
+    this.offset = bufferData.offset + offset;
+  }
+  
+  release() {
+    this.dataView = null;
+  }
+      
+  static calculateBytesFromString(s) {
+    if(!s) {
+      return 0;
+    }
+    const length = s.length;
+    let stringBytes = 0;
+    let ch = null;
+    let notFirst = false;
+    for(let i = 0; i < length; ++i) {
+      ch = s.charCodeAt(i);
+      if(ch >= 0xdc00 && ch <= 0xdfff) {
+        if(notFirst && (ch >= 0xd800 && ch <= 0xdbff)) {
+          ++stringBytes;
+        }
+        else {
+          stringBytes += 3;
+        }
+      }
+      else if(ch <= 0x7f) {
+        stringBytes += 1;
+      }
+      else if(ch >= 0x80 && ch <= 0x7ff) {
+        stringBytes += 2;
+      }
+      else if(ch >= 0x800 && ch <= 0xffff) {
+        stringBytes += 3;
+      }
+      notFirst = true;
+    }
+    return stringBytes;
+  }
+  
+  calculateBytesFromString(s) {
+    return PooledEncoder.calculateBytesFromString(s);
+  }
+  
+  static calculateBytesFromBin(b) {
+    return b.byteLength;
+  }
+  
+  calculateBytesFromBin(b) {
+    return b.byteLength;
+  }
+  
+  static calculateDynamicBytes(size) {
+    if(size <= 253) {
+      return 1;
+    }
+    else if(size <= 65535) {
+      return 3;
+    }
+    else {
+      return 5;
+    }
+  }
+  
+  calculateDynamicBytes(size) {
+    return PooledEncoder.calculateDynamicBytes(size);
+  }
+  
+  static getStringBytes(s) {
+    const stringBytes = PooledEncoder.calculateBytesFromString(s);
+    return stringBytes + PooledEncoder.calculateDynamicBytes(stringBytes);
+  }
+    
+  getStringBytes(s) {
+    return PooledEncoder.getStringBytes(s);
+  }
+  
+  static getStringArrayBytes(array) {
+    let size = PooledEncoder.calculateDynamicBytes(array.length);
+    for(let i = 0; i < array.length; ++i) {
+      size += PooledEncoder.getStringBytes(array[i]);
+    }
+    return size;
+  }
+  
+  getStringArrayBytes(array) {
+    return PooledEncoder.getStringArrayBytes(array);
+  }
+  
+  static getGuidArrayBytes(array) {
+    return PooledEncoder.calculateDynamicBytes(array.length) + (array.length * EncoderConst.GuidSize);
+  }
+  
+  getGuidArrayBytes(array) {
+    return PooledEncoder.getGuidArrayBytes(array);
+  }
+  
+  setDynamicBytes(size) {
+    const sizeBytes = this.calculateDynamicBytes(size);
+    if(1 === sizeBytes) {
+      this.setUint8(size);
+    }
+    else if(3 === sizeBytes) {
+      this.setUint8(254);
+      this.setUint16(size);
+    }
+    else {
+      this.setUint8(255);
+      this.setUint32(size);
+    }
+  }
+  
+  setInt8(value) {
+    this.dataView.setInt8(this.offset, value);
+    this.offset += PooledEncoder.Int8Size;
+  }
+  
+  setInt16(value) {
+    this.dataView.setInt16(this.offset, value);
+    this.offset += PooledEncoder.Int16Size;
+  }
+  
+  setInt32(value) {
+    this.dataView.setInt32(this.offset, value);
+    this.offset += PooledEncoder.Int32Size;
+  }
+  
+  setBigInt64(value) {
+    this.dataView.setBigInt64(this.offset, value);
+    this.offset += PooledEncoder.Int64Size;
+  }
+  
+  setUint1_0(value, ready) {
+    const v = 0x7f & this.dataView.getUint8(this.offset);
+    this.dataView.setUint8(this.offset, v + ((0x1 & value) << 7));
+    if(ready) {
+      this.offset += PooledEncoder.Int8Size;
+    }
+  }
+  
+  setUint1_1(value, ready) {
+    const v = 0xbf & this.dataView.getUint8(this.offset);
+    this.dataView.setUint8(this.offset, v + ((0x1 & value) << 6));
+    if(ready) {
+      this.offset += PooledEncoder.Int8Size;
+    }
+  }
+  
+   setUint1_2(value, ready) {
+    const v = 0xdf & this.dataView.getUint8(this.offset);
+    this.dataView.setUint8(this.offset, v + ((0x1 & value) << 5));
+    if(ready) {
+      this.offset += PooledEncoder.Int8Size;
+    }
+  }
+  
+  setUint1_3(value, ready) {
+    const v = 0xef & this.dataView.getUint8(this.offset);
+    this.dataView.setUint8(this.offset, v + ((0x1 & value) << 4));
+    if(ready) {
+      this.offset += PooledEncoder.Int8Size;
+    }
+  }
+  
+  setUint1_4(value, ready) {
+    const v = 0xf7 & this.dataView.getUint8(this.offset);
+    this.dataView.setUint8(this.offset, v + ((0x1 & value) << 3));
+    if(ready) {
+      this.offset += PooledEncoder.Int8Size;
+    }
+  }
+  
+  setUint1_5(value, ready) {
+    const v = 0xfb & this.dataView.getUint8(this.offset);
+    this.dataView.setUint8(this.offset, v + ((0x1 & value) << 2));
+    if(ready) {
+      this.offset += PooledEncoder.Int8Size;
+    }
+  }
+  
+  setUint1_6(value, ready) {
+    const v = 0xfd & this.dataView.getUint8(this.offset);
+    this.dataView.setUint8(this.offset, v + ((0x1 & value) << 1));
+    if(ready) {
+      this.offset += PooledEncoder.Int8Size;
+    }
+  }
+  
+  setUint1_7(value, ready) {
+    const v = 0xfe & this.dataView.getUint8(this.offset);
+    this.dataView.setUint8(this.offset, v + ((0x1 & value)));
+    if(ready) {
+      this.offset += PooledEncoder.Int8Size;
+    }
+  }
+  
+  setUint2_0(value, ready) {
+    const v = 0x3f & this.dataView.getUint8(this.offset);
+    this.dataView.setUint8(this.offset, v + ((0x3 & value) << 6));
+    if(ready) {
+      this.offset += PooledEncoder.Int8Size;
+    }
+  }
+  
+  setUint2_1(value, ready) {
+    const v = 0xcf & this.dataView.getUint8(this.offset);
+    this.dataView.setUint8(this.offset, v + ((0x3 & value) << 4));
+    if(ready) {
+      this.offset += PooledEncoder.Int8Size;
+    }
+  }
+  
+  setUint2_2(value, ready) {
+    const v = 0xf3 & this.dataView.getUint8(this.offset);
+    this.dataView.setUint8(this.offset, v + ((0x3 & value) << 2));
+    if(ready) {
+      this.offset += PooledEncoder.Int8Size;
+    }
+  }
+  
+  setUint2_3(value, ready) {
+    const v = 0xfc & this.dataView.getUint8(this.offset);
+    this.dataView.setUint8(this.offset, v + (0x3 & value));
+    if(ready) {
+      this.offset += PooledEncoder.Int8Size;
+    }
+  }
+  
+  setUint4_0(value, ready) {
+    if(!this.doCalculate) {
+      const v = 0xf & this.dataView.getUint8(this.offset);
+      this.dataView.setUint8(this.offset, v + ((0xf & value) << 4));
+    }
+    if(ready) {
+      this.offset += PooledEncoder.Int8Size;
+    }
+  }
+  
+  setUint4_1(value, ready) {
+    const v = 0xf0 & this.dataView.getUint8(this.offset);
+    this.dataView.setUint8(this.offset, v + (0xf & value));
+    if(ready) {
+      this.offset += PooledEncoder.Int8Size;
+    }
+  }
+  
+  setUint8(value) {
+    this.dataView.setUint8(this.offset, value);
+    this.offset += PooledEncoder.Uint8Size;
+  }
+  
+  setUint16(value) {
+    this.dataView.setUint16(this.offset, value);
+    this.offset += PooledEncoder.Uint16Size;
+  }
+  
+  setUint32(value) {
+    this.dataView.setUint32(this.offset, value);
+    this.offset += PooledEncoder.Uint32Size;
+  }
+  
+ setBigUint64(value) {
+    this.dataView.setBigUint64(this.offset, value);
+    this.offset += PooledEncoder.Uint64Size;
+  }
+  
+  setFloat32(value) {
+    this.dataView.setFloat32(this.offset, value);
+    this.offset += PooledEncoder.Float32Size;
+  }
+  
+  setFloat64(value) {
+    this.dataView.setFloat64(this.offset, value);
+    this.offset += PooledEncoder.Float64Size;
+  }
+  
+  setBool1_0(value, ready) {
+    this.setUint1_0(value ? 1 : 0, ready);
+  }
+  
+  setBool1_1(value, ready) {
+    this.setUint1_1(value ? 1 : 0, ready);
+  }
+  
+  setBool1_2(value, ready) {
+    this.setUint1_2(value ? 1 : 0, ready);
+  }
+  
+  setBool1_3(value, ready) {
+    this.setUint1_3(value ? 1 : 0, ready);
+  }
+  
+  setBool1_4(value, ready) {
+    this.setUint1_4(value ? 1 : 0, ready);
+  }
+  
+  setBool1_5(value, ready) {
+    this.setUint1_5(value ? 1 : 0, ready);
+  }
+  
+  setBool1_6(value, ready) {
+    this.setUint1_6(value ? 1 : 0, ready);
+  }
+  
+  setBool1_7(value, ready) {
+    this.setUint1_7(value ? 1 : 0, ready);
+  }
+  
+  _setCt(value) {
+    this.dataView.setInt16(this.offset, value);
+    this.offset += PooledEncoder.CtSize;
+  }
+  
+  setCtString(text, cachedTexts) {
+    if(!text) {
+      text = '';
+    }
+    const ctId = this.textCache.setExternal(text, cachedTexts);
+    this._setCt(ctId);
+  }
+  
+  setCtStringArray(array, cachedTexts) {
+    this.setUint16(array.length);
+    for(let i = 0; i < array.length; ++i) {
+      this.setCtString(array[i], cachedTexts);
+    }
+  }
+  
+  setCtStringInternal(text) {
+    const ctId = this.textCache.setInternal(text);
+    this._setCt(ctId);
+  }
+  
+  setCtStringArrayInternal(array) {
+    this.setUint16(array.length);
+    for(let i = 0; i < array.length; ++i) {
+      this.setCtStringInternal(array[i]);
+    }
+  }
+  
+  setRawString(value, size) {
+    if(0 !== size) {
+      const result = PooledEncoder.textEncoder.encodeInto(value, new Uint8Array(this.dataView.buffer, this.dataView.byteOffset +  this.offset, size));
+    }
+    this.offset += size;
+  }
+  
+  setString(value) {
+    const stringBytes = this.calculateBytesFromString(value);
+    this.setDynamicBytes(stringBytes);
+    this.setRawString(value, stringBytes);
+  }
+  
+  setStringArray(array) {
+    this.setDynamicBytes(array.length);
+    for(let i = 0; i < array.length; ++i) {
+      this.setString(array[i]);
+    }
+  }
+  
+  setRawBinary(value, size) {
+    let srcArray = null;
+    let srcDataView = null;
+    if(value instanceof ArrayBuffer) {
+      srcDataView = new DataView(value);
+    }
+    else {
+      srcDataView = new DataView(value.buffer, value.byteOffset);
+    }
+    srcArray = new Uint8Array(srcDataView.buffer, srcDataView.byteOffset);
+    const dstArray = new Uint8Array(this.dataView.buffer, this.dataView.byteOffset + this.offset, srcArray.byteLength);
+    dstArray.set(srcArray);
+    this.offset += size;
+  }
+  
+  setBinary(value) {
+    const binaryBytes = value.byteLength;
+    this.setDynamicBytes(binaryBytes);
+    this.setRawBinary(value, binaryBytes);
+  }
+  
+  setUint8Array(array) {
+    this.setUint16(array.length);
+    for(let i = 0; i < array.length; ++i) {
+      this.setUint8(array[i]);
+    }
+  }
+      
+  setGuid(value) {
+    this.setUint4_0(PooledEncoder.ASCII[value.charCodeAt(0)], false);
+    this.setUint4_1(PooledEncoder.ASCII[value.charCodeAt(1)], true);
+    this.setUint4_0(PooledEncoder.ASCII[value.charCodeAt(2)], false);
+    this.setUint4_1(PooledEncoder.ASCII[value.charCodeAt(3)], true);
+    this.setUint4_0(PooledEncoder.ASCII[value.charCodeAt(4)], false);
+    this.setUint4_1(PooledEncoder.ASCII[value.charCodeAt(5)], true);
+    this.setUint4_0(PooledEncoder.ASCII[value.charCodeAt(6)], false);
+    this.setUint4_1(PooledEncoder.ASCII[value.charCodeAt(7)], true);
+    
+    this.setUint4_0(PooledEncoder.ASCII[value.charCodeAt(9)], false);
+    this.setUint4_1(PooledEncoder.ASCII[value.charCodeAt(10)], true);
+    this.setUint4_0(PooledEncoder.ASCII[value.charCodeAt(11)], false);
+    this.setUint4_1(PooledEncoder.ASCII[value.charCodeAt(12)], true);
+    
+    this.setUint4_0(PooledEncoder.ASCII[value.charCodeAt(14)], false);
+    this.setUint4_1(PooledEncoder.ASCII[value.charCodeAt(15)], true);
+    this.setUint4_0(PooledEncoder.ASCII[value.charCodeAt(16)], false);
+    this.setUint4_1(PooledEncoder.ASCII[value.charCodeAt(17)], true);
+        
+    this.setUint4_0(PooledEncoder.ASCII[value.charCodeAt(19)], false);
+    this.setUint4_1(PooledEncoder.ASCII[value.charCodeAt(20)], true);
+    this.setUint4_0(PooledEncoder.ASCII[value.charCodeAt(21)], false);
+    this.setUint4_1(PooledEncoder.ASCII[value.charCodeAt(22)], true);
+    
+    this.setUint4_0(PooledEncoder.ASCII[value.charCodeAt(24)], false);
+    this.setUint4_1(PooledEncoder.ASCII[value.charCodeAt(25)], true);
+    this.setUint4_0(PooledEncoder.ASCII[value.charCodeAt(26)], false);
+    this.setUint4_1(PooledEncoder.ASCII[value.charCodeAt(27)], true);
+    this.setUint4_0(PooledEncoder.ASCII[value.charCodeAt(28)], false);
+    this.setUint4_1(PooledEncoder.ASCII[value.charCodeAt(29)], true);
+    this.setUint4_0(PooledEncoder.ASCII[value.charCodeAt(30)], false);
+    this.setUint4_1(PooledEncoder.ASCII[value.charCodeAt(31)], true);
+    this.setUint4_0(PooledEncoder.ASCII[value.charCodeAt(32)], false);
+    this.setUint4_1(PooledEncoder.ASCII[value.charCodeAt(33)], true);
+    this.setUint4_0(PooledEncoder.ASCII[value.charCodeAt(34)], false);
+    this.setUint4_1(PooledEncoder.ASCII[value.charCodeAt(35)], true);
+  }
+  
+  setGuidArray(array) {
+    this.setDynamicBytes(array.length);
+    for(let i = 0; i < array.length; ++i) {
+      this.setGuid(array[i]);
+    }
+  }
+}
+
+
+module.exports = PooledEncoder;

package/project/client/communication/data-action-multi.js

@@ -0,0 +1,11 @@
+
+'use strict';
+
+import DataAction from './data-action';
+
+
+export default class DataActionMulti extends DataAction {
+  constructor() {
+    super();
+  }
+}

package/project/client/communication/data-action.js

@@ -0,0 +1,37 @@
+
+'use strict';
+
+import ActionRequest from 'z-abs-corelayer-cs/clientServer/communication/action-request';
+
+
+export default class DataAction {
+  constructor() {
+    this.actionRequest = new ActionRequest();
+    this.actions = new Map();
+  }
+  
+  addRequest(action, ...params) {
+    this.actions.set(`${action._name}_0`, action);
+    this.actionRequest.add(action._name, 0, ...params);
+  }
+  
+  addRequestIndex(action, index, ...params) {
+    this.actions.set(`${action._name}_${index}`, action);
+    this.actionRequest.add(action._name, index, ...params);
+  }
+  
+  setIds(requestId, sessionId) {
+    this.actionRequest.setIds(requestId, sessionId);
+  }
+  
+  setResponses(responses) {
+    if(null !== responses) {
+      responses.forEach((response) => {
+        const action = this.actions.get(`${response.name}_${response.index}`);
+        if(action) {
+          action.setResponse(response);
+        }
+      });
+    }
+  }
+}

package/project/client/communication/data-config.js

@@ -0,0 +1,36 @@
+
+'use strict';
+
+
+class DataConfig {
+  constructor() {
+    this.wsServers = new Map();
+    this.loggedIn = false;
+    this.loginCbs = [];
+  }
+  
+  setWs(wsServers) {
+    if(wsServers) {
+      wsServers.forEach((wsServer) => {
+        this.wsServers.set(wsServer.name, wsServer);
+      });
+    }
+    this.loggedIn = true;
+    this.loginCbs.forEach((cb) => {
+      cb();
+    });
+    this.loginCbs = [];
+  }
+  
+  login(cb) {
+    if(this.loggedIn) {
+      cb();
+    }
+    else {
+      this.loginCbs.push(cb);
+    }
+  }
+}
+
+
+module.exports = new DataConfig();

package/project/client/communication/data-fetcher-thread.js

@@ -0,0 +1,46 @@
+
+'use strict';
+
+const WorkerThread = require('../worker/worker-thread');
+
+
+class DataFetcherThread extends WorkerThread{
+  constructor(id) {
+    super(id);
+    this.headers = {
+      'Accept': 'application/json',
+      'Content-Type': 'application/json; charset=utf-8'
+    };
+  }
+  
+  onMessage(origin, actionRequest) {
+    const requestNames = actionRequest.requests.map((request) => {
+      return request.name;
+    });
+    const requestPath = requestNames.join('/');
+    fetch(origin + '/abs-data/' + requestPath, {
+      method: 'post',
+      headers: this.headers,
+      body: JSON.stringify(actionRequest, (key, value) => {
+        if(key.startsWith('_') && '_commentOut_' !== key) {
+          return undefined;
+        }
+        return value;
+      })
+    }).then((response) => {
+      return response.json();
+    }).then((data) => {
+      if(data) {
+        this.postMessage(actionRequest.id, data.responses);
+      }
+      else {
+        this.postMessage(actionRequest.id, null);
+      }
+    }).catch((err) => {
+      this.postMessage(actionRequest.id, null);
+    });
+  }
+}
+
+
+module.exports = DataFetcherThread;

package/project/client/communication/data-fetcher.js

@@ -0,0 +1,58 @@
+
+'use strict';
+
+import WorkerMain from '../worker/worker-main';
+const DataFetcherThread = requireAsBundle('./data-fetcher-thread');
+import DataAction from './data-action';
+import GuidGenerator from 'z-abs-corelayer-cs/clientServer/guid-generator';
+
+
+class DataFetcher {
+  constructor() {
+    this.requests = new Map();
+    this.workerMain = new WorkerMain(this, 'DataFetcherThread', DataFetcherThread);
+    this.workerMain.start();
+    this.init = false;
+    this.initQueue = [];
+  }
+  
+  send(dataAction, store, cb) {
+    const guid = GuidGenerator.create();
+    dataAction.setIds(guid);
+    this.requests.set(guid, {
+      dataAction: dataAction,
+      store: store,
+      cb: cb
+    });
+    if(this.init) {
+      this.workerMain.postMessage(location.origin, dataAction.actionRequest);
+    }
+    else {
+      this.initQueue.push([location.origin, dataAction.actionRequest]);
+    }
+  }
+  
+  onStarted(...params) {
+    this.init = true;
+    this.initQueue.forEach((params) => {
+      this.workerMain.postMessage(...params);
+    });
+    this.initQueue = [];
+  }
+  
+  onMessage(guid, responses) {
+    if(null !== responses) {
+      const cbData = this.requests.get(guid);
+      if(cbData) {
+        cbData.dataAction.setResponses(responses);
+        cbData.store.dispatchDataAction(cbData.dataAction, cbData.cb);
+      }
+    }
+    this.requests.delete(guid);
+  }
+}
+
+DataFetcher.self = new DataFetcher();
+
+
+module.exports = DataFetcher.self;

package/project/client/communication/messages/messages-c-to-s/message-persistent-init-request.js

@@ -0,0 +1,16 @@
+
+'use strict';
+
+const CoreProtocolConst = require('z-abs-corelayer-cs/clientServer/communication/core-protocol/core-protocol-const');
+
+
+class MessagePersistentInitRequest {
+  constructor(name, subscribeServices) {
+    this.msgId = CoreProtocolConst.PERSISTENT_INIT_REQUEST;
+    this.name = name;
+    this.subscribeServices = subscribeServices;
+  }
+}
+
+
+module.exports = MessagePersistentInitRequest;