mirror of
https://github.com/esiur/esiur-js.git
synced 2025-05-06 04:22:58 +00:00
9639 lines
421 KiB
Plaintext
9639 lines
421 KiB
Plaintext
(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
module.exports = function () {
|
|
throw new Error(
|
|
'ws does not work in the browser. Browser clients must use the native ' +
|
|
'WebSocket object'
|
|
);
|
|
};
|
|
|
|
},{}],2:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 25/07/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _AsyncReply2 = _interopRequireDefault(require("./AsyncReply.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
var AsyncBag = /*#__PURE__*/function (_AsyncReply) {
|
|
_inherits(AsyncBag, _AsyncReply);
|
|
|
|
var _super = _createSuper(AsyncBag);
|
|
|
|
function AsyncBag() {
|
|
var _this;
|
|
|
|
_classCallCheck(this, AsyncBag);
|
|
|
|
_this = _super.call(this);
|
|
_this.replies = [];
|
|
_this.results = [];
|
|
_this.count = 0;
|
|
_this.sealedBag = false;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(AsyncBag, [{
|
|
key: "seal",
|
|
value: function seal() {
|
|
this.sealedBag = true;
|
|
if (this.results.length == 0) this.trigger([]);
|
|
var self = this;
|
|
|
|
var singleTaskCompleted = function singleTaskCompleted(taskIndex) {
|
|
return function (results, reply) {
|
|
self.results[taskIndex] = results;
|
|
self.count++;
|
|
if (self.count == self.results.length) self.trigger(self.results);
|
|
};
|
|
};
|
|
|
|
for (var i = 0; i < this.results.length; i++) {
|
|
this.replies[i].then(singleTaskCompleted(i));
|
|
}
|
|
/*
|
|
this.replies[i].then(function(r, reply){
|
|
self.results[self.replies.indexOf(reply)] = r;
|
|
self.count++;
|
|
if (self.count == self.results.length)
|
|
self.trigger(self.results);
|
|
});
|
|
*/
|
|
|
|
}
|
|
}, {
|
|
key: "add",
|
|
value: function add(reply) {
|
|
if (!this.sealedBag) {
|
|
this.replies.push(reply);
|
|
this.results.push(null);
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return AsyncBag;
|
|
}(_AsyncReply2["default"]);
|
|
|
|
exports["default"] = AsyncBag;
|
|
|
|
},{"./AsyncReply.js":5}],3:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 18/11/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _ExceptionCode = _interopRequireDefault(require("./ExceptionCode.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
|
|
|
|
function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
var AsyncException = /*#__PURE__*/function (_Error) {
|
|
_inherits(AsyncException, _Error);
|
|
|
|
var _super = _createSuper(AsyncException);
|
|
|
|
function AsyncException(type, code, message) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, AsyncException);
|
|
|
|
_this = _super.call(this);
|
|
|
|
if (type instanceof AsyncException) {
|
|
_this.raise(type.type, type.code, type.message);
|
|
} else if (type instanceof Error) {
|
|
_this.raise(1, 0, type.message);
|
|
} else if (type != undefined) {
|
|
_this.raise(type, code, message);
|
|
} else {
|
|
_this.raised = false;
|
|
}
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(AsyncException, [{
|
|
key: "raise",
|
|
value: function raise(type, code, message) {
|
|
this.type = type;
|
|
this.code = code;
|
|
|
|
if (type == 0) {
|
|
for (var i in _ExceptionCode["default"]) {
|
|
if (_ExceptionCode["default"][i] == code) {
|
|
this.message = i;
|
|
break;
|
|
}
|
|
}
|
|
} else this.message = message;
|
|
|
|
this.raised = true;
|
|
}
|
|
}, {
|
|
key: "toString",
|
|
value: function toString() {
|
|
return (this.type == 0 ? "Management" : "Exception") + " (" + this.code + ") : " + this.message;
|
|
}
|
|
}]);
|
|
|
|
return AsyncException;
|
|
}( /*#__PURE__*/_wrapNativeSuper(Error));
|
|
|
|
exports["default"] = AsyncException;
|
|
|
|
},{"./ExceptionCode.js":7}],4:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 25/07/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _AsyncReply2 = _interopRequireDefault(require("./AsyncReply.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
var AsyncQueue = /*#__PURE__*/function (_AsyncReply) {
|
|
_inherits(AsyncQueue, _AsyncReply);
|
|
|
|
var _super = _createSuper(AsyncQueue);
|
|
|
|
function AsyncQueue() {
|
|
var _this;
|
|
|
|
_classCallCheck(this, AsyncQueue);
|
|
|
|
_this = _super.call(this);
|
|
_this.list = [];
|
|
|
|
var self = _assertThisInitialized(_this);
|
|
|
|
_this.processQueue = function () {
|
|
for (var i = 0; i < self.list.length; i++) {
|
|
if (self.list[i].ready) {
|
|
self.trigger(self.list[i].result);
|
|
self.ready = false; //self.list.splice(i, 1);
|
|
|
|
self.list.shift();
|
|
i--;
|
|
} else if (self.list[i].failed) {
|
|
self.ready = false;
|
|
self.list.shift();
|
|
i--;
|
|
console.log("AsyncQueue (Reply Failed)");
|
|
} else break;
|
|
}
|
|
|
|
self.ready = self.list.length == 0;
|
|
};
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(AsyncQueue, [{
|
|
key: "add",
|
|
value: function add(reply) {
|
|
this.list.push(reply);
|
|
this.ready = false;
|
|
reply.then(this.processQueue).error(this.processQueue);
|
|
}
|
|
}, {
|
|
key: "remove",
|
|
value: function remove(reply) {
|
|
this.list.splice(this.list.indexOf(reply), 1);
|
|
this.processQueue();
|
|
}
|
|
}]);
|
|
|
|
return AsyncQueue;
|
|
}(_AsyncReply2["default"]);
|
|
|
|
exports["default"] = AsyncQueue;
|
|
|
|
},{"./AsyncReply.js":5}],5:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 25/07/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _AsyncException = _interopRequireDefault(require("./AsyncException.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
|
|
|
|
function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
var AsyncReply = /*#__PURE__*/function (_Promise) {
|
|
_inherits(AsyncReply, _Promise);
|
|
|
|
var _super = _createSuper(AsyncReply);
|
|
|
|
function AsyncReply(result) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, AsyncReply);
|
|
|
|
if (result instanceof Function) {
|
|
_this = _super.call(this, result);
|
|
_this.awaiter = result;
|
|
} else _this = _super.call(this, function () {});
|
|
|
|
_this.callbacks = [];
|
|
_this.errorCallbacks = [];
|
|
_this.progressCallbacks = [];
|
|
_this.chunkCallbacks = [];
|
|
_this.exception = new _AsyncException["default"](); // null;
|
|
//var self = this;
|
|
|
|
if (result !== undefined && !(result instanceof Function)) {
|
|
_this.result = result;
|
|
_this.ready = true;
|
|
} else {
|
|
_this.ready = false;
|
|
_this.result = null;
|
|
}
|
|
|
|
return _possibleConstructorReturn(_this);
|
|
}
|
|
|
|
_createClass(AsyncReply, [{
|
|
key: "then",
|
|
value: function then(callback, onError) {
|
|
if (callback != undefined) {
|
|
this.callbacks.push(callback);
|
|
if (this.ready) callback(this.result, this);
|
|
}
|
|
|
|
if (onError != undefined) {
|
|
this.error(onError);
|
|
}
|
|
|
|
return this;
|
|
} // Alias for then()
|
|
|
|
}, {
|
|
key: "done",
|
|
value: function done(callback) {
|
|
this.then(callback);
|
|
}
|
|
}, {
|
|
key: "error",
|
|
value: function error(callback) {
|
|
this.errorCallbacks.push(callback);
|
|
|
|
if (this.exception.raised) {
|
|
callback(this.exception);
|
|
}
|
|
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "progress",
|
|
value: function progress(callback) {
|
|
this.progressCallbacks.push(callback);
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "chunk",
|
|
value: function chunk(callback) {
|
|
this.chunkCallbacks.push(callback);
|
|
return this;
|
|
} // Alias for chunk()
|
|
|
|
}, {
|
|
key: "next",
|
|
value: function next(callback) {
|
|
this.chunk(callback);
|
|
}
|
|
}, {
|
|
key: "trigger",
|
|
value: function trigger(result) {
|
|
if (this.ready) return;
|
|
this.result = result;
|
|
this.ready = true;
|
|
|
|
for (var i = 0; i < this.callbacks.length; i++) {
|
|
this.callbacks[i](result, this);
|
|
}
|
|
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "triggerError",
|
|
value: function triggerError(type, code, message) {
|
|
if (this.ready) return this;
|
|
if (type instanceof _AsyncException["default"]) this.exception.raise(type.type, type.code, type.message);else this.exception.raise(type, code, message);
|
|
if (this.errorCallbacks.length == 0) throw this.exception;else for (var i = 0; i < this.errorCallbacks.length; i++) {
|
|
this.errorCallbacks[i](this.exception, this);
|
|
}
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "triggerProgress",
|
|
value: function triggerProgress(type, value, max) {
|
|
for (var i = 0; i < this.progressCallbacks.length; i++) {
|
|
this.progressCallbacks[i](type, value, max, this);
|
|
}
|
|
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "triggerChunk",
|
|
value: function triggerChunk(value) {
|
|
for (var i = 0; i < this.chunkCallbacks.length; i++) {
|
|
this.chunkCallbacks[i](value, this);
|
|
}
|
|
|
|
return this;
|
|
}
|
|
}]);
|
|
|
|
return AsyncReply;
|
|
}( /*#__PURE__*/_wrapNativeSuper(Promise));
|
|
|
|
exports["default"] = AsyncReply;
|
|
|
|
},{"./AsyncException.js":3}],6:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
var _default = {
|
|
Management: 0,
|
|
Exception: 1
|
|
};
|
|
exports["default"] = _default;
|
|
|
|
},{}],7:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
var _default = //const ExceptionCode =
|
|
{
|
|
HostNotReachable: 0,
|
|
AccessDenied: 1,
|
|
UserOrTokenNotFound: 2,
|
|
ChallengeFailed: 3,
|
|
ResourceNotFound: 4,
|
|
AttachDenied: 5,
|
|
InvalidMethod: 6,
|
|
InvokeDenied: 7,
|
|
CreateDenied: 8,
|
|
AddParentDenied: 9,
|
|
AddChildDenied: 10,
|
|
ViewAttributeDenied: 11,
|
|
UpdateAttributeDenied: 12,
|
|
StoreNotFound: 13,
|
|
ParentNotFound: 14,
|
|
ChildNotFound: 15,
|
|
ResourceIsNotStore: 16,
|
|
DeleteDenied: 17,
|
|
DeleteFailed: 18,
|
|
UpdateAttributeFailed: 19,
|
|
GetAttributesFailed: 20,
|
|
ClearAttributesFailed: 21,
|
|
TemplateNotFound: 22,
|
|
RenameDenied: 23,
|
|
ClassNotFound: 24,
|
|
MethodNotFound: 25,
|
|
PropertyNotFound: 26,
|
|
SetPropertyDenied: 27,
|
|
ReadOnlyProperty: 28,
|
|
GeneralFailure: 29,
|
|
AddToStoreFailed: 30,
|
|
NotAttached: 31,
|
|
AlreadyListened: 32,
|
|
AlreadyUnlistened: 33,
|
|
NotListenable: 34
|
|
};
|
|
exports["default"] = _default;
|
|
|
|
},{}],8:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 31/08/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _IEventHandler2 = _interopRequireDefault(require("./IEventHandler.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
var IDestructible = /*#__PURE__*/function (_IEventHandler) {
|
|
_inherits(IDestructible, _IEventHandler);
|
|
|
|
var _super = _createSuper(IDestructible);
|
|
|
|
function IDestructible() {
|
|
_classCallCheck(this, IDestructible);
|
|
|
|
return _super.call(this);
|
|
}
|
|
|
|
_createClass(IDestructible, [{
|
|
key: "destroy",
|
|
value: function destroy() {
|
|
this._emit("destroy", this);
|
|
}
|
|
}]);
|
|
|
|
return IDestructible;
|
|
}(_IEventHandler2["default"]);
|
|
|
|
exports["default"] = IDestructible;
|
|
|
|
},{"./IEventHandler.js":9}],9:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 30/08/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
var IEventHandler = /*#__PURE__*/function () {
|
|
function IEventHandler() {
|
|
_classCallCheck(this, IEventHandler);
|
|
|
|
this._events = {};
|
|
}
|
|
|
|
_createClass(IEventHandler, [{
|
|
key: "_register",
|
|
value: function _register(event) {
|
|
this._events[event] = [];
|
|
}
|
|
}, {
|
|
key: "_emit",
|
|
value: function _emit(event) {
|
|
event = event.toLowerCase();
|
|
var args = Array.prototype.slice.call(arguments, 1);
|
|
if (this._events[event]) for (var i = 0; i < this._events[event].length; i++) {
|
|
if (this._events[event][i].f.apply(this._events[event][i].i, args)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "_emitArgs",
|
|
value: function _emitArgs(event, args) {
|
|
event = event.toLowerCase();
|
|
if (this._events[event]) for (var i = 0; i < this._events[event].length; i++) {
|
|
if (this._events[event][i].f.apply(this._events[event][i].i, args)) return true;
|
|
}
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "on",
|
|
value: function on(event, fn, issuer) {
|
|
if (!(fn instanceof Function)) return this;
|
|
event = event.toLowerCase(); // add
|
|
|
|
if (!this._events[event]) this._events[event] = [];
|
|
|
|
this._events[event].push({
|
|
f: fn,
|
|
i: issuer == null ? this : issuer
|
|
});
|
|
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "off",
|
|
value: function off(event, fn) {
|
|
event = event.toLowerCase();
|
|
|
|
if (this._events[event]) {
|
|
if (fn) {
|
|
for (var i = 0; i < this._events[event].length; i++) {
|
|
if (this._events[event][i].f == fn) this._events[event].splice(i--, 1);
|
|
} //var index = this._events[event].indexOf(fn);
|
|
//if (index > -1)
|
|
//this._events[event].splice(index, 1);
|
|
|
|
} else {
|
|
this._events[event] = [];
|
|
}
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return IEventHandler;
|
|
}();
|
|
|
|
exports["default"] = IEventHandler;
|
|
|
|
},{}],10:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
var _default = {
|
|
Execution: 0,
|
|
Network: 1
|
|
};
|
|
exports["default"] = _default;
|
|
|
|
},{}],11:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 05/09/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _IEventHandler2 = _interopRequireDefault(require("../Core/IEventHandler.js"));
|
|
|
|
var _IDestructible = _interopRequireDefault(require("../Core/IDestructible.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
|
|
|
|
function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
|
|
|
|
function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
|
|
|
|
var _item_destroyed = /*#__PURE__*/new WeakMap();
|
|
|
|
var AutoList = /*#__PURE__*/function (_IEventHandler) {
|
|
_inherits(AutoList, _IEventHandler);
|
|
|
|
var _super = _createSuper(AutoList);
|
|
|
|
function AutoList() {
|
|
var _this;
|
|
|
|
_classCallCheck(this, AutoList);
|
|
|
|
_this = _super.call(this);
|
|
|
|
_item_destroyed.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: function value(sender) {
|
|
this.remove(sender);
|
|
}
|
|
});
|
|
|
|
_this.list = [];
|
|
return _this;
|
|
}
|
|
|
|
_createClass(AutoList, [{
|
|
key: "length",
|
|
get: function get() {
|
|
return this.list.length;
|
|
}
|
|
}, {
|
|
key: "add",
|
|
value: function add(value) {
|
|
if (value instanceof _IDestructible["default"]) value.on("destroy", _classPrivateFieldGet(this, _item_destroyed), this);
|
|
this.list.push(value);
|
|
|
|
this._emit("add", value);
|
|
}
|
|
}, {
|
|
key: "set",
|
|
value: function set(index, value) {
|
|
if (index >= this.list.length || index < 0) return;
|
|
if (value instanceof _IDestructible["default"]) value.on("destroy", _classPrivateFieldGet(this, _item_destroyed), this);
|
|
if (this.list[index] instanceof _IDestructible["default"]) this.list[index].off("destroy", _classPrivateFieldGet(this, _item_destroyed));
|
|
this.list[index] = value;
|
|
}
|
|
}, {
|
|
key: "at",
|
|
value: function at(index) {
|
|
return this.list[index];
|
|
}
|
|
}, {
|
|
key: "item",
|
|
value: function item(index) {
|
|
return this.list[index];
|
|
}
|
|
}, {
|
|
key: "remove",
|
|
value: function remove(value) {
|
|
this.removeAt(this.list.indexOf(value));
|
|
}
|
|
}, {
|
|
key: "contains",
|
|
value: function contains(value) {
|
|
return this.list.indexOf(value) > -1;
|
|
}
|
|
}, {
|
|
key: "toArray",
|
|
value: function toArray() {
|
|
return this.list.slice(0);
|
|
}
|
|
}, {
|
|
key: "removeAt",
|
|
value: function removeAt(index) {
|
|
if (index >= this.list.length || index < 0) return;
|
|
var item = this.list[index];
|
|
if (item instanceof _IDestructible["default"]) item.off("destroy", _classPrivateFieldGet(this, _item_destroyed));
|
|
this.list.splice(index, 1);
|
|
|
|
this._emit("remove", item);
|
|
}
|
|
}]);
|
|
|
|
return AutoList;
|
|
}(_IEventHandler2["default"]);
|
|
|
|
exports["default"] = AutoList;
|
|
|
|
},{"../Core/IDestructible.js":8,"../Core/IEventHandler.js":9}],12:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 05/09/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _IEventHandler2 = _interopRequireDefault(require("../Core/IEventHandler.js"));
|
|
|
|
var _IDestructible = _interopRequireDefault(require("../Core/IDestructible.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
|
|
|
|
function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
|
|
|
|
function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
|
|
|
|
var _item_destroyed = /*#__PURE__*/new WeakMap();
|
|
|
|
var AutoMap = /*#__PURE__*/function (_IEventHandler) {
|
|
_inherits(AutoMap, _IEventHandler);
|
|
|
|
var _super = _createSuper(AutoMap);
|
|
|
|
function AutoMap() {
|
|
var _this;
|
|
|
|
_classCallCheck(this, AutoMap);
|
|
|
|
_this = _super.call(this);
|
|
|
|
_item_destroyed.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: function value(sender) {
|
|
this.remove(sender);
|
|
}
|
|
});
|
|
|
|
_this.dic = {};
|
|
return _this;
|
|
}
|
|
|
|
_createClass(AutoMap, [{
|
|
key: "add",
|
|
value: function add(key, value) {
|
|
if (value instanceof _IDestructible["default"]) value.on("destroy", _classPrivateFieldGet(this, _item_destroyed));
|
|
this.dic[key] = value;
|
|
|
|
this._emit("add", key, value);
|
|
}
|
|
}, {
|
|
key: "set",
|
|
value: function set(key, value) {
|
|
if (this.dic[key] !== undefined) this.remove(key);
|
|
this.add(key, value);
|
|
}
|
|
}, {
|
|
key: "remove",
|
|
value: function remove(key) {
|
|
if (this.dic[key] !== undefined) {
|
|
if (this.dic[key] instanceof _IDestructible["default"]) this.dic[key].off("destroy", _classPrivateFieldGet(this, _item_destroyed));
|
|
delete this.dic[key];
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return AutoMap;
|
|
}(_IEventHandler2["default"]);
|
|
|
|
exports["default"] = AutoMap;
|
|
|
|
},{"../Core/IDestructible.js":8,"../Core/IEventHandler.js":9}],13:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 25/08/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _DC = _interopRequireDefault(require("./DC.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
|
|
|
|
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
|
|
|
|
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
|
|
|
|
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
|
|
|
|
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
|
|
|
|
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
var BinaryList = /*#__PURE__*/function () {
|
|
function BinaryList() {
|
|
_classCallCheck(this, BinaryList);
|
|
|
|
this.list = []; //this.data = [];
|
|
}
|
|
|
|
_createClass(BinaryList, [{
|
|
key: "addDateTime",
|
|
value: function addDateTime(value, endian) {
|
|
this.addDC(_DC["default"].dateTimeToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "insertDateTime",
|
|
value: function insertDateTime(position, value, endian) {
|
|
this.insertDC(position, _DC["default"].dateTimeToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "addDateTimeArray",
|
|
value: function addDateTimeArray(value, endian) {
|
|
this.addDC(_DC["default"].dateTimeArrayToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "insertDateTimeArray",
|
|
value: function insertDateTimeArray(position, value, endian) {
|
|
this.insertDC(position, _DC["default"].dateTimeArrayToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "addGuid",
|
|
value: function addGuid(value) {
|
|
this.addDC(_DC["default"].guidToBytes(value));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "insertGuid",
|
|
value: function insertGuid(position, value) {
|
|
this.insertDC(position, _DC["default"].guidToBytes(value));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "addUint8Array",
|
|
value: function addUint8Array(value) {
|
|
this.addDC(value);
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "addDC",
|
|
value: function addDC(value) {
|
|
var _this$list;
|
|
|
|
(_this$list = this.list).push.apply(_this$list, _toConsumableArray(value));
|
|
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "insertUint8Array",
|
|
value: function insertUint8Array(position, value) {
|
|
this.insertDC(position, value);
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "addString",
|
|
value: function addString(value) {
|
|
this.addDC(_DC["default"].stringToBytes(value));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "insertString",
|
|
value: function insertString(position, value) {
|
|
this.insertDC(position, _DC["default"].stringToBytes(value));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "insertUint8",
|
|
value: function insertUint8(position, value) {
|
|
this.list.splice(position, 0, value);
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "addUint8",
|
|
value: function addUint8(value) {
|
|
this.list.push(value);
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "addInt8",
|
|
value: function addInt8(value) {
|
|
this.list.push(value);
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "insertInt8",
|
|
value: function insertInt8(position, value) {
|
|
this.list.splice(position, 0, value);
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "addChar",
|
|
value: function addChar(value) {
|
|
this.addDC(_DC["default"].charToBytes(value));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "insertChar",
|
|
value: function insertChar(position, value) {
|
|
this.insertDC(position, _DC["default"].charToBytes(value));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "addBoolean",
|
|
value: function addBoolean(value) {
|
|
this.addDC(_DC["default"].boolToBytes(value));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "insertBoolean",
|
|
value: function insertBoolean(position, value) {
|
|
this.insertDC(position, _DC["default"].boolToBytes(value));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "addUint16",
|
|
value: function addUint16(value, endian) {
|
|
this.addDC(_DC["default"].uint16ToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "insertUint16",
|
|
value: function insertUint16(position, value, endian) {
|
|
this.insertDC(position, _DC["default"].uint16ToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "addInt16",
|
|
value: function addInt16(value, endian) {
|
|
this.addDC(_DC["default"].int16ToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "insertInt16",
|
|
value: function insertInt16(position, value, endian) {
|
|
this.insertDC(position, _DC["default"].int16ToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "addUint32",
|
|
value: function addUint32(value, endian) {
|
|
this.addDC(_DC["default"].uint32ToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "insertUint32",
|
|
value: function insertUint32(position, value, endian) {
|
|
this.insertDC(position, _DC["default"].uint32ToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "addInt32",
|
|
value: function addInt32(value, endian) {
|
|
this.addDC(_DC["default"].int32ToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "insertInt32",
|
|
value: function insertInt32(position, value, endian) {
|
|
this.insertDC(position, _DC["default"].int32ToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "addUint64",
|
|
value: function addUint64(value, endian) {
|
|
this.addDC(_DC["default"].uint64ToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "insertUint64",
|
|
value: function insertUint64(position, value, endian) {
|
|
this.insertDC(position, _DC["default"].uint64ToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "addInt64",
|
|
value: function addInt64(value, endian) {
|
|
this.addDC(_DC["default"].int64ToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "insertInt64",
|
|
value: function insertInt64(position, value, endian) {
|
|
this.insertDC(position, _DC["default"].int64ToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "addFloat32",
|
|
value: function addFloat32(value, endian) {
|
|
this.addDC(_DC["default"].float32ToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "insertFloat32",
|
|
value: function insertFloat32(position, value, endian) {
|
|
this.insertDC(position, _DC["default"].float32ToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "addFloat64",
|
|
value: function addFloat64(value, endian) {
|
|
this.addDC(_DC["default"].float64ToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "insertFloat64",
|
|
value: function insertFloat64(position, value, endian) {
|
|
this.insertDC(position, _DC["default"].float64ToBytes(value, endian));
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "length",
|
|
get: function get() {
|
|
return this.list.length;
|
|
}
|
|
}, {
|
|
key: "toArray",
|
|
value: function toArray() {
|
|
return new Uint8Array(this.list);
|
|
}
|
|
}, {
|
|
key: "toDC",
|
|
value: function toDC() {
|
|
return new _DC["default"](this.list);
|
|
}
|
|
}]);
|
|
|
|
return BinaryList;
|
|
}();
|
|
|
|
exports["default"] = BinaryList;
|
|
|
|
},{"./DC.js":15}],14:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 25/07/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = exports.CodecParseResults = exports.CodecComposeResults = void 0;
|
|
|
|
var _DataType = _interopRequireDefault(require("./DataType.js"));
|
|
|
|
var _ResourceComparisonResult = _interopRequireDefault(require("./ResourceComparisonResult.js"));
|
|
|
|
var _StructureComparisonResult = _interopRequireDefault(require("./StructureComparisonResult.js"));
|
|
|
|
var _AsyncBag = _interopRequireDefault(require("../Core/AsyncBag.js"));
|
|
|
|
var _AsyncReply = _interopRequireDefault(require("../Core/AsyncReply.js"));
|
|
|
|
var _Structure = _interopRequireDefault(require("./Structure.js"));
|
|
|
|
var _PropertyValue = _interopRequireDefault(require("./PropertyValue.js"));
|
|
|
|
var _DC = require("./DC.js");
|
|
|
|
var _BinaryList = _interopRequireDefault(require("./BinaryList.js"));
|
|
|
|
var _DistributedPropertyContext = _interopRequireDefault(require("../Net/IIP/DistributedPropertyContext.js"));
|
|
|
|
var _DistributedResource = _interopRequireDefault(require("../Net/IIP/DistributedResource.js"));
|
|
|
|
var _IResource = _interopRequireDefault(require("../Resource/IResource.js"));
|
|
|
|
var _RecordComparisonResult = _interopRequireDefault(require("./RecordComparisonResult.js"));
|
|
|
|
var _IRecord = _interopRequireDefault(require("./IRecord.js"));
|
|
|
|
var _Record = _interopRequireDefault(require("./Record.js"));
|
|
|
|
var _ResourceArrayType = _interopRequireDefault(require("./ResourceArrayType.js"));
|
|
|
|
var _Warehouse = _interopRequireDefault(require("../Resource/Warehouse.js"));
|
|
|
|
var _TemplateType = _interopRequireDefault(require("../Resource/Template/TemplateType.js"));
|
|
|
|
var _NotModified = _interopRequireDefault(require("./NotModified.js"));
|
|
|
|
var _KeyList = _interopRequireDefault(require("./KeyList.js"));
|
|
|
|
var _StructureArray = _interopRequireDefault(require("./StructureArray.js"));
|
|
|
|
var _DataSerializer = _interopRequireDefault(require("./DataSerializer.js"));
|
|
|
|
var _DataDeserializer = _interopRequireDefault(require("./DataDeserializer.js"));
|
|
|
|
var _TypedList = _interopRequireDefault(require("./TypedList.js"));
|
|
|
|
var _TypedMap = _interopRequireDefault(require("./TypedMap.js"));
|
|
|
|
var _IEnum = _interopRequireDefault(require("./IEnum.js"));
|
|
|
|
var _TransmissionType = require("./TransmissionType.js");
|
|
|
|
var _ExtendedTypes = require("./ExtendedTypes.js");
|
|
|
|
var _PropertyValueArray = _interopRequireDefault(require("./PropertyValueArray.js"));
|
|
|
|
var _RecordArray = _interopRequireDefault(require("./RecordArray.js"));
|
|
|
|
var _ResourceArray = _interopRequireDefault(require("./ResourceArray.js"));
|
|
|
|
var _Tuple = _interopRequireDefault(require("./Tuple.js"));
|
|
|
|
var _defineProperty2;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
// export default class Codec {
|
|
// static parse(data, offset, sizeObject, connection, dataType = DataType.Unspecified) {
|
|
// var size;
|
|
// //var reply = new AsyncReply();
|
|
// var isArray;
|
|
// var t;
|
|
// if (dataType == DataType.Unspecified) {
|
|
// size = 1;
|
|
// dataType = data[offset++];
|
|
// }
|
|
// else
|
|
// size = 0;
|
|
// t = dataType & 0x7F;
|
|
// isArray = (dataType & 0x80) == 0x80;
|
|
// var payloadSize = DataType.sizeOf(dataType);
|
|
// var contentLength = 0;
|
|
// // check if we have the enough data
|
|
// if (payloadSize == -1) {
|
|
// contentLength = data.getUint32(offset);
|
|
// offset += 4;
|
|
// size += 4 + contentLength;
|
|
// }
|
|
// else
|
|
// size += payloadSize;
|
|
// sizeObject.size = size;
|
|
// if (isArray) {
|
|
// switch (t) {
|
|
// // VarArray ?
|
|
// case DataType.Void:
|
|
// return Codec.parseVarArray(data, offset, contentLength, connection);
|
|
// case DataType.Bool:
|
|
// return new AsyncReply(data.getBooleanArray(offset, contentLength));
|
|
// case DataType.UInt8:
|
|
// return new AsyncReply(data.getUint8Array(offset, contentLength));
|
|
// case DataType.Int8:
|
|
// return new AsyncReply(data.getInt8Array(offset, contentLength));
|
|
// case DataType.Char:
|
|
// return new AsyncReply(data.getCharArray(offset, contentLength));
|
|
// case DataType.Int16:
|
|
// return new AsyncReply(data.getInt16Array(offset, contentLength));
|
|
// case DataType.UInt16:
|
|
// return new AsyncReply(data.getUint16Array(offset, contentLength));
|
|
// case DataType.Int32:
|
|
// return new AsyncReply(data.getInt32Array(offset, contentLength));
|
|
// case DataType.UInt32:
|
|
// return new AsyncReply(data.getUint32Array(offset, contentLength));
|
|
// case DataType.Int64:
|
|
// return new AsyncReply(data.getInt64Array(offset, contentLength));
|
|
// case DataType.UInt64:
|
|
// return new AsyncReply(data.getUint64Array(offset, contentLength));
|
|
// case DataType.Float32:
|
|
// return new AsyncReply(data.getFloat32Array(offset, contentLength));
|
|
// case DataType.Float64:
|
|
// return new AsyncReply(data.getFloat64Array(offset, contentLength));
|
|
// case DataType.String:
|
|
// return new AsyncReply(data.getStringArray(offset, contentLength));
|
|
// case DataType.Resource:
|
|
// case DataType.DistributedResource:
|
|
// return Codec.parseResourceArray(data, offset, contentLength, connection);
|
|
// case DataType.DateTime:
|
|
// return new AsyncReply(data.getDateTimeArray(offset, contentLength));
|
|
// case DataType.Structure:
|
|
// return Codec.parseStructureArray(data, offset, contentLength, connection);
|
|
// case DataType.Record:
|
|
// return Codec.parseRecordArray(data, offset, contentLength, connection);
|
|
// }
|
|
// }
|
|
// else {
|
|
// switch (t) {
|
|
// case DataType.NotModified:
|
|
// return new AsyncReply(new NotModified());
|
|
// case DataType.Void:
|
|
// return new AsyncReply(null);
|
|
// case DataType.Bool:
|
|
// return new AsyncReply(data.getBoolean(offset));
|
|
// case DataType.UInt8:
|
|
// return new AsyncReply(data[offset]);
|
|
// case DataType.Int8:
|
|
// return new AsyncReply(data.getInt8(offset));
|
|
// case DataType.Char:
|
|
// return new AsyncReply(data.getChar(offset));
|
|
// case DataType.Int16:
|
|
// return new AsyncReply(data.getInt16(offset));
|
|
// case DataType.UInt16:
|
|
// return new AsyncReply(data.getUint16(offset));
|
|
// case DataType.Int32:
|
|
// return new AsyncReply(data.getInt32(offset));
|
|
// case DataType.UInt32:
|
|
// return new AsyncReply(data.getUint32(offset));
|
|
// case DataType.Int64:
|
|
// return new AsyncReply(data.getInt64(offset));
|
|
// case DataType.UInt64:
|
|
// return new AsyncReply(data.getUint64(offset));
|
|
// case DataType.Float32:
|
|
// return new AsyncReply(data.getFloat32(offset));
|
|
// case DataType.Float64:
|
|
// return new AsyncReply(data.getFloat64(offset));
|
|
// case DataType.String:
|
|
// return new AsyncReply(data.getString(offset, contentLength));
|
|
// case DataType.Resource:
|
|
// return Codec.parseResource(data, offset);
|
|
// case DataType.DistributedResource:
|
|
// return Codec.parseDistributedResource(data, offset, connection);
|
|
// case DataType.DateTime:
|
|
// return new AsyncReply(data.getDateTime(offset));
|
|
// case DataType.Structure:
|
|
// return Codec.parseStructure(data, offset, contentLength, connection);
|
|
// case DataType.Record:
|
|
// return Codec.parseRecord(data, offset, contentLength, connection);
|
|
// }
|
|
// }
|
|
// // @TODO: Throw exception
|
|
// return new AsyncReply(null);
|
|
// }
|
|
// static parseResource(data, offset) {
|
|
// return Warehouse.getById(data.getUint32(offset));
|
|
// }
|
|
// static parseDistributedResource(data, offset, connection) {
|
|
// //var g = data.getGuid(offset);
|
|
// //offset += 16;
|
|
// // find the object
|
|
// var iid = data.getUint32(offset);
|
|
// return connection.fetch(iid);// Warehouse.getById(iid);
|
|
// }
|
|
// /// <summary>
|
|
// /// Parse an array of bytes into array of resources
|
|
// /// </summary>
|
|
// /// <param name="data">Array of bytes.</param>
|
|
// /// <param name="length">Number of bytes to parse.</param>
|
|
// /// <param name="offset">Zero-indexed offset.</param>
|
|
// /// <param name="connection">DistributedConnection is required to fetch resources.</param>
|
|
// /// <returns>Array of resources.</returns>
|
|
// static parseResourceArray(data, offset, length, connection)
|
|
// {
|
|
// var reply = new AsyncBag();
|
|
// if (length == 0)
|
|
// {
|
|
// reply.seal();
|
|
// return reply;
|
|
// }
|
|
// var end = offset + length;
|
|
// //
|
|
// //var result = data[offset++];
|
|
// var type = data[offset] & 0xF0;
|
|
// var result = data[offset++] & 0xF;
|
|
// if (type == ResourceArrayType.Wrapper)
|
|
// {
|
|
// let classId = data.getGuid(offset);
|
|
// offset += 16;
|
|
// let tmp = Warehouse.getTemplateByClassId(classId, TemplateType.Resource);
|
|
// // not mine, look if the type is elsewhere
|
|
// if (tmp == null)
|
|
// Warehouse.getTemplateByClassId(classId, TemplateType.Wrapper);
|
|
// reply.arrayType = tmp?.definedType;
|
|
// }
|
|
// else if (type == ResourceArrayType.Static)
|
|
// {
|
|
// let classId = data.getGuid(offset);
|
|
// offset += 16;
|
|
// let tmp = Warehouse.getTemplateByClassId(classId, TemplateType.Wrapper);
|
|
// reply.arrayType = tmp?.definedType;
|
|
// }
|
|
// var previous = null;
|
|
// if (result == ResourceComparisonResult.Empty) {
|
|
// reply.seal();
|
|
// return reply;
|
|
// } else if (result == ResourceComparisonResult.Null) {
|
|
// previous = new AsyncReply(null);
|
|
// } else if (result == ResourceComparisonResult.Local)
|
|
// {
|
|
// previous = Warehouse.getById(data.getUint32(offset));
|
|
// offset += 4;
|
|
// }
|
|
// else if (result == ResourceComparisonResult.Distributed)
|
|
// {
|
|
// previous = connection.fetch(data.getUint32(offset));
|
|
// offset += 4;
|
|
// }
|
|
// reply.add(previous);
|
|
// while (offset < end)
|
|
// {
|
|
// result = data[offset++];
|
|
// var current = null;
|
|
// if (result == ResourceComparisonResult.Null)
|
|
// {
|
|
// current = new AsyncReply(null);
|
|
// }
|
|
// else if (result == ResourceComparisonResult.Same)
|
|
// {
|
|
// current = previous;
|
|
// }
|
|
// else if (result == ResourceComparisonResult.Local)
|
|
// {
|
|
// current = Warehouse.getById(data.getUint32(offset));
|
|
// offset += 4;
|
|
// }
|
|
// else if (result == ResourceComparisonResult.Distributed)
|
|
// {
|
|
// current = connection.fetch(data.getUint32(offset));
|
|
// offset += 4;
|
|
// }
|
|
// reply.add(current);
|
|
// previous = current;
|
|
// }
|
|
// reply.seal();
|
|
// return reply;
|
|
// }
|
|
// /// <summary>
|
|
// /// Compose an array of property values.
|
|
// /// </summary>
|
|
// /// <param name="array">PropertyValue array.</param>
|
|
// /// <param name="connection">DistributedConnection is required to check locality.</param>
|
|
// /// <param name="prependLength">If True, prepend the length as UInt32 at the beginning of the output.</param>
|
|
// /// <returns>Array of bytes in the network byte order.</returns>
|
|
// static composePropertyValueArray(array, connection, prependLength = false)
|
|
// {
|
|
// var rt = BL();
|
|
// for (var i = 0; i < array.length; i++)
|
|
// rt.addUint8Array(Codec.composePropertyValue(array[i], connection));
|
|
// if (prependLength)
|
|
// rt.addUint32(rt.length, 0);
|
|
// return rt.toArray();
|
|
// }
|
|
// /// <summary>
|
|
// /// Compose a property value.
|
|
// /// </summary>
|
|
// /// <param name="propertyValue">Property value</param>
|
|
// /// <param name="connection">DistributedConnection is required to check locality.</param>
|
|
// /// <returns>Array of bytes in the network byte order.</returns>
|
|
// static composePropertyValue(propertyValue, connection)
|
|
// {
|
|
// // age, date, value
|
|
// return BL().addUint64(propertyValue.age)
|
|
// .addDateTime(propertyValue.date)
|
|
// .addUint8Array(Codec.compose(propertyValue.value, connection))
|
|
// .toArray();
|
|
// }
|
|
// /// <summary>
|
|
// /// Parse property value.
|
|
// /// </summary>
|
|
// /// <param name="data">Array of bytes.</param>
|
|
// /// <param name="offset">Zero-indexed offset.</param>
|
|
// /// <param name="connection">DistributedConnection is required to fetch resources.</param>
|
|
// /// <param name="cs">Output content size.</param>
|
|
// /// <returns>PropertyValue.</returns>
|
|
// static parsePropertyValue(data, offset, sizeObject, connection)
|
|
// {
|
|
// var reply = new AsyncReply();
|
|
// var age = data.getUint64(offset);
|
|
// offset += 8;
|
|
// var date = data.getDateTime(offset);
|
|
// offset += 8;
|
|
// var cs = {};
|
|
// Codec.parse(data, offset, cs, connection).then(function(value)
|
|
// {
|
|
// reply.trigger(new PropertyValue(value, age, date));
|
|
// });
|
|
// sizeObject.size = 16 + cs.size;
|
|
// return reply;
|
|
// }
|
|
// /// <summary>
|
|
// /// Parse resource history
|
|
// /// </summary>
|
|
// /// <param name="data">Array of bytes.</param>
|
|
// /// <param name="offset">Zero-indexed offset.</param>
|
|
// /// <param name="length">Number of bytes to parse.</param>
|
|
// /// <param name="resource">Resource</param>
|
|
// /// <param name="fromAge">Starting age.</param>
|
|
// /// <param name="toAge">Ending age.</param>
|
|
// /// <param name="connection">DistributedConnection is required to fetch resources.</param>
|
|
// /// <returns></returns>
|
|
// static parseHistory(data, offset, length, resource, connection)
|
|
// {
|
|
// var list = new KeyList();
|
|
// var reply = new AsyncReply();
|
|
// var bagOfBags = new AsyncBag();
|
|
// var ends = offset + length;
|
|
// while (offset < ends)
|
|
// {
|
|
// var index = data[offset++];
|
|
// var pt = resource.instance.template.getPropertyTemplateByIndex(index);
|
|
// list.add(pt, null);
|
|
// var cs = data.getUint32(offset);
|
|
// offset += 4;
|
|
// bagOfBags.add(Codec.parsePropertyValueArray(data, offset, cs, connection));
|
|
// offset += cs;
|
|
// }
|
|
// bagOfBags.seal();
|
|
// bagOfBags.then(x =>
|
|
// {
|
|
// for(var i = 0; i < list.length; i++)
|
|
// list.values[i] = x[i];
|
|
// reply.trigger(list);
|
|
// });
|
|
// return reply;
|
|
// }
|
|
// /// <summary>
|
|
// /// Compose resource history
|
|
// /// </summary>
|
|
// /// <param name="history">History</param>
|
|
// /// <param name="connection">DistributedConnection is required to fetch resources.</param>
|
|
// /// <returns></returns>
|
|
// static composeHistory(history, connection, prependLength = false)
|
|
// {
|
|
// var rt = new BinaryList();
|
|
// for (var i = 0; i < history.length; i++)
|
|
// rt.addUint8(history.keys[i].index).addUint8Array(Codec.composePropertyValueArray(history.values[i], connection, true));
|
|
// if (prependLength)
|
|
// rt.addUint32(rt.length, 0);
|
|
// return rt.toArray();
|
|
// }
|
|
// /// <summary>
|
|
// /// Parse an array of ProperyValue.
|
|
// /// </summary>
|
|
// /// <param name="data">Array of bytes.</param>
|
|
// /// <param name="offset">Zero-indexed offset.</param>
|
|
// /// <param name="length">Number of bytes to parse.</param>
|
|
// /// <param name="connection">DistributedConnection is required to fetch resources.</param>
|
|
// /// <returns></returns>
|
|
// static parsePropertyValueArray(data, offset, length, connection)
|
|
// {
|
|
// var rt = new AsyncBag();
|
|
// while (length > 0)
|
|
// {
|
|
// var cs = {};
|
|
// rt.add(Codec.parsePropertyValue(data, offset, cs, connection));
|
|
// if (cs.size > 0)
|
|
// {
|
|
// offset += cs.size;
|
|
// length -= cs.size;
|
|
// }
|
|
// else
|
|
// throw new Error("Error while parsing ValueInfo structured data");
|
|
// }
|
|
// rt.seal();
|
|
// return rt;
|
|
// }
|
|
// static parseStructure(data, offset, contentLength, connection, metadata = null, keys = null, types = null)
|
|
// {
|
|
// var reply = new AsyncReply();
|
|
// var bag = new AsyncBag();
|
|
// var keylist = [];
|
|
// var typelist = [];
|
|
// if (keys == null) {
|
|
// while (contentLength > 0) {
|
|
// var len = data[offset++];
|
|
// keylist.push(data.getString(offset, len));
|
|
// offset += len;
|
|
// typelist.push(data[offset]);
|
|
// var rt = {};
|
|
// bag.add(Codec.parse(data, offset, rt, connection));
|
|
// contentLength -= rt.size + len + 1;
|
|
// offset += rt.size;
|
|
// }
|
|
// }
|
|
// else if (types == null) {
|
|
// for (var i = 0; i < keys.length; i++)
|
|
// keylist.push(keys[i]);
|
|
// while (contentLength > 0) {
|
|
// typelist.push(data[offset]);
|
|
// let rt = {};
|
|
// bag.add(Codec.parse(data, offset, rt, connection));
|
|
// contentLength -= rt.size;
|
|
// offset += rt.size;
|
|
// }
|
|
// }
|
|
// else {
|
|
// for (let i = 0; i < keys.length; i++) {
|
|
// keylist.push(keys[i]);
|
|
// typelist.push(types[i]);
|
|
// }
|
|
// let i = 0;
|
|
// while (contentLength > 0) {
|
|
// let rt = {};
|
|
// bag.add(Codec.parse(data, offset, rt, connection, types[i]));
|
|
// contentLength -= rt.size;
|
|
// offset += rt.size;
|
|
// i++;
|
|
// }
|
|
// }
|
|
// bag.seal();
|
|
// bag.then(function (res) {
|
|
// // compose the list
|
|
// var s = new Structure();
|
|
// for (var i = 0; i < keylist.length; i++)
|
|
// s[keylist[i]] = res[i];
|
|
// reply.trigger(s);
|
|
// });
|
|
// if (metadata != null)
|
|
// {
|
|
// metadata.keys = keylist;
|
|
// metadata.types = typelist;
|
|
// }
|
|
// return reply;
|
|
// }
|
|
// static parseVarArray(data, offset, contentLength, connection) {
|
|
// var rt = new AsyncBag();
|
|
// while (contentLength > 0) {
|
|
// var cs = {};
|
|
// rt.add(Codec.parse(data, offset, cs, connection));
|
|
// if (cs.size > 0) {
|
|
// offset += cs.size;
|
|
// contentLength -= cs.size;
|
|
// }
|
|
// else
|
|
// throw new Error("Error while parsing structured data");
|
|
// }
|
|
// rt.seal();
|
|
// return rt;
|
|
// }
|
|
// static compose(value, connection, prependType = true) {
|
|
// if (value instanceof Function)
|
|
// value = value(connection);
|
|
// else if (value instanceof DistributedPropertyContext)
|
|
// value = value.method(this);
|
|
// var type = Codec.getDataType(value, connection);
|
|
// var rt = new BinaryList();
|
|
// switch (type) {
|
|
// case DataType.Void:
|
|
// // nothing to do;
|
|
// break;
|
|
// case DataType.String:
|
|
// var st = DC.stringToBytes(value);
|
|
// rt.addUint32(st.length).addUint8Array(st);
|
|
// break;
|
|
// case DataType.Resource:
|
|
// rt.addUint32(value._p.instanceId);
|
|
// break;
|
|
// case DataType.DistributedResource:
|
|
// // rt.addUint8Array(DC.stringToBytes(value.instance.template.classId)).addUint32(value.instance.id);
|
|
// rt.addUint32(value.instance.id);
|
|
// break;
|
|
// case DataType.Structure:
|
|
// rt.addUint8Array(Codec.composeStructure(value, connection, true, true, true));
|
|
// break;
|
|
// case DataType.VarArray:
|
|
// rt.addUint8Array(Codec.composeVarArray(value, connection, true));
|
|
// break;
|
|
// case DataType.Record:
|
|
// rt.addUint8Array(Codec.composeRecord(value, connection, true, true));
|
|
// break;
|
|
// case DataType.ResourceArray:
|
|
// rt.addUint8Array(Codec.composeResourceArray(value, connection, true));
|
|
// break;
|
|
// case DataType.StructureArray:
|
|
// rt.addUint8Array(Codec.composeStructureArray(value, connection, true));
|
|
// break;
|
|
// case DataType.RecordArray:
|
|
// rt.addUint8Array(Codec.composeRecordArray(value, connection, true));
|
|
// break;
|
|
// default:
|
|
// rt.add({type: type, value: value});
|
|
// if (DataType.isArray(type))
|
|
// rt.addUint32(rt.length, 0);
|
|
// break;
|
|
// }
|
|
// if (prependType)
|
|
// rt.addUint8(type, 0);
|
|
// return rt.toArray();
|
|
// }
|
|
// static composeVarArray(array, connection, prependLength = false) {
|
|
// var rt = new BinaryList();
|
|
// for (var i = 0; i < array.length; i++)
|
|
// rt.addUint8Array(Codec.compose(array[i], connection));
|
|
// if (prependLength)
|
|
// rt.addUint32(rt.length, 0);
|
|
// return rt.toArray();
|
|
// }
|
|
// static composeStructure(value, connection, includeKeys = true, includeTypes = true, prependLength = false) {
|
|
// let rt = new BinaryList();
|
|
// let keys = value.getKeys();
|
|
// if (includeKeys) {
|
|
// for (let i = 0; i < keys.length; i++) {
|
|
// let key = DC.stringToBytes(keys[i]);
|
|
// rt.addUint8(key.length).addUint8Array(key).addUint8Array(Codec.compose(value[keys[i]], connection));
|
|
// }
|
|
// }
|
|
// else {
|
|
// for (let i = 0; i < keys.length; i++)
|
|
// rt.addUint8Array(Codec.compose(value[keys[i]], connection, includeTypes));
|
|
// }
|
|
// if (prependLength)
|
|
// rt.addUint32(rt.length, 0);
|
|
// return rt.toArray();
|
|
// }
|
|
// static composeStructureArray(structures, connection, prependLength = false) {
|
|
// if (structures == null || structures.length == 0 || !(structures instanceof StructureArray))
|
|
// return new DC(0);
|
|
// var rt = new BinaryList();
|
|
// var comparision = StructureComparisonResult.Structure;
|
|
// rt.addUint8(comparision);
|
|
// rt.addUint8Array(Codec.composeStructure(structures[0], connection));
|
|
// for (var i = 1; i < structures.length; i++) {
|
|
// comparision = Codec.compareStructure(structures[i - 1], structures[i], connection);
|
|
// rt.addUint8(comparision);
|
|
// if (comparision == StructureComparisonResult.Structure)
|
|
// rt.addUint8Array(Codec.composeStructure(structures[i], connection));
|
|
// else if (comparision == StructureComparisonResult.StructureSameKeys)
|
|
// rt.addUint8Array(Codec.composeStructure(structures[i], connection, false));
|
|
// else if (comparision == StructureComparisonResult.StructureSameTypes)
|
|
// rt.addUint8Array(Codec.composeStructure(structures[i], connection, false, false));
|
|
// }
|
|
// if (prependLength)
|
|
// rt.addUint32(rt.length, 0);
|
|
// return rt.toArray();
|
|
// }
|
|
// /// <summary>
|
|
// /// Compare two records
|
|
// /// </summary>
|
|
// /// <param name="initial">Initial record to compare with</param>
|
|
// /// <param name="next">Next record to compare with the initial</param>
|
|
// /// <param name="connection">DistributedConnection is required in case a structure holds items at the other end</param>
|
|
// static compareRecords(initial, next)
|
|
// {
|
|
// if (next == null)
|
|
// return RecordComparisonResult.Null;
|
|
// if (initial == null)
|
|
// return RecordComparisonResult.Record;
|
|
// if (next == initial)
|
|
// return RecordComparisonResult.Same;
|
|
// if (next.constructor === initial.constructor)
|
|
// return RecordComparisonResult.RecordSameType;
|
|
// return RecordComparisonResult.Record;
|
|
// }
|
|
// static parseRecordArray(data, offset, length, connection)
|
|
// {
|
|
// var reply = new AsyncBag();
|
|
// if (length == 0)
|
|
// {
|
|
// reply.seal();
|
|
// return reply;
|
|
// }
|
|
// var end = offset + length;
|
|
// var isTyped = (data.getUint8(offset) & 0x10) == 0x10;
|
|
// var result = data.getUint8(offset++) & 0xF;
|
|
// if (isTyped)
|
|
// {
|
|
// var classId = data.getGuid(offset);
|
|
// offset += 16;
|
|
// var template = Warehouse.getTemplateByClassId(classId, TemplateType.Record);
|
|
// reply.arrayType = template?.definedType;
|
|
// var previous = null;
|
|
// if (result == RecordComparisonResult.Empty)
|
|
// {
|
|
// reply.seal();
|
|
// return reply;
|
|
// }
|
|
// else if (result == RecordComparisonResult.Null)
|
|
// {
|
|
// previous = new AsyncReply(null);
|
|
// }
|
|
// else if (result == RecordComparisonResult.Record
|
|
// || result == RecordComparisonResult.RecordSameType)
|
|
// {
|
|
// var cs = data.getUint32(offset);
|
|
// var recordLength = cs;
|
|
// offset += 4;
|
|
// previous = Codec.parseRecord(data, offset, recordLength, connection, classId);
|
|
// offset += recordLength;
|
|
// }
|
|
// reply.add(previous);
|
|
// while (offset < end)
|
|
// {
|
|
// result = data.getUint8(offset++);
|
|
// if (result == RecordComparisonResult.Null)
|
|
// previous = new AsyncReply(null);
|
|
// else if (result == RecordComparisonResult.Record
|
|
// || result == RecordComparisonResult.RecordSameType)
|
|
// {
|
|
// let cs = data.getUint32(offset);
|
|
// offset += 4;
|
|
// previous = Codec.parseRecord(data, offset, cs, connection, classId);
|
|
// offset += cs;
|
|
// }
|
|
// else if (result == RecordComparisonResult.Same)
|
|
// {
|
|
// // do nothing
|
|
// }
|
|
// reply.add(previous);
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// let previous = null;
|
|
// let classId = null;
|
|
// if (result == RecordComparisonResult.Empty)
|
|
// {
|
|
// reply.seal();
|
|
// return reply;
|
|
// }
|
|
// else if (result == RecordComparisonResult.Null)
|
|
// previous = new AsyncReply(null);
|
|
// else if (result == RecordComparisonResult.Record)
|
|
// {
|
|
// let cs = data.getUint32(offset);
|
|
// let recordLength = cs - 16;
|
|
// offset += 4;
|
|
// classId = data.getGuid(offset);
|
|
// offset += 16;
|
|
// previous = Codec.parseRecord(data, offset, recordLength, connection, classId);
|
|
// offset += recordLength;
|
|
// }
|
|
// reply.add(previous);
|
|
// while (offset < end)
|
|
// {
|
|
// result = data.getUint8(offset++);
|
|
// if (result == RecordComparisonResult.Null)
|
|
// previous = new AsyncReply(null);
|
|
// else if (result == RecordComparisonResult.Record)
|
|
// {
|
|
// let cs = data.getUint32(offset);
|
|
// let recordLength = cs - 16;
|
|
// offset += 4;
|
|
// classId = data.getGuid(offset);
|
|
// offset += 16;
|
|
// previous = Codec.parseRecord(data, offset, recordLength, connection, classId);
|
|
// offset += recordLength;
|
|
// }
|
|
// else if (result == RecordComparisonResult.RecordSameType)
|
|
// {
|
|
// let cs = data.getUint32(offset);
|
|
// offset += 4;
|
|
// previous = this.parseRecord(data, offset, cs, connection, classId);
|
|
// offset += cs;
|
|
// }
|
|
// else if (result == RecordComparisonResult.Same)
|
|
// {
|
|
// // do nothing
|
|
// }
|
|
// reply.add(previous);
|
|
// }
|
|
// }
|
|
// reply.seal();
|
|
// return reply;
|
|
// // var reply = new AsyncBag();
|
|
// // if (length == 0)
|
|
// // {
|
|
// // reply.seal();
|
|
// // return reply;
|
|
// // }
|
|
// // var end = offset + length;
|
|
// // var result = data.getUint8(offset++);
|
|
// // var previous = null;
|
|
// // var classId = null;
|
|
// // if (result == RecordComparisonResult.Null)
|
|
// // previous = new AsyncReply(null);
|
|
// // else if (result == RecordComparisonResult.Record)
|
|
// // {
|
|
// // var cs = data.getUint32(offset);
|
|
// // var recordLength = cs - 16;
|
|
// // offset += 4;
|
|
// // classId = data.getGuid(offset);
|
|
// // offset += 16;
|
|
// // previous = Codec.parseRecord(data, offset, recordLength, connection, classId);
|
|
// // offset += recordLength;
|
|
// // }
|
|
// // reply.Add(previous);
|
|
// // while (offset < end)
|
|
// // {
|
|
// // result = data.getUint8(offset++);
|
|
// // if (result == RecordComparisonResult.Null)
|
|
// // previous = new AsyncReply(null);
|
|
// // else if (result == RecordComparisonResult.Record)
|
|
// // {
|
|
// // var cs = data.getUint32(offset);
|
|
// // var recordLength = cs - 16;
|
|
// // offset += 4;
|
|
// // classId = data.getGuid(offset);
|
|
// // offset += 16;
|
|
// // previous = Codec.parseRecord(data, offset, recordLength, connection, classId);
|
|
// // offset += recordLength;
|
|
// // }
|
|
// // else if (result == RecordComparisonResult.RecordSameType)
|
|
// // {
|
|
// // var cs = data.getUint32(offset);
|
|
// // offset += 4;
|
|
// // previous = Codec.parseRecord(data, offset, cs, connection, classId);
|
|
// // offset += cs;
|
|
// // }
|
|
// // else if (result == RecordComparisonResult.Same)
|
|
// // {
|
|
// // // do nothing
|
|
// // }
|
|
// // reply.add(previous);
|
|
// // }
|
|
// // reply.seal();
|
|
// // return reply;
|
|
// }
|
|
// static parseRecord(data, offset, length, connection, classId = null)
|
|
// {
|
|
// var reply = new AsyncReply();
|
|
// if (classId == null)
|
|
// {
|
|
// classId = data.getGuid(offset);
|
|
// offset += 16;
|
|
// length -= 16;
|
|
// }
|
|
// var template = Warehouse.getTemplateByClassId(classId, TemplateType.Record);
|
|
// if (template != null)
|
|
// {
|
|
// Codec.parseVarArray(data, offset, length, connection).then(ar =>
|
|
// {
|
|
// if (template.definedType != null)
|
|
// {
|
|
// let record = new template.definedType();
|
|
// for (let i = 0; i < template.properties.length; i++)
|
|
// record[template.properties[i].name] = ar[i];
|
|
// reply.trigger(record);
|
|
// }
|
|
// else
|
|
// {
|
|
// let record = new Record();
|
|
// for (let i = 0; i < template.properties.length; i++)
|
|
// record[template.properties[i].name] = ar[i];
|
|
// reply.trigger(record);
|
|
// }
|
|
// });
|
|
// }
|
|
// else
|
|
// {
|
|
// connection.getTemplate(classId).then(tmp => {
|
|
// Codec.parseVarArray(data, offset, length, connection).then(ar =>
|
|
// {
|
|
// var record = new Record();
|
|
// for (var i = 0; i < tmp.properties.length; i++)
|
|
// record[tmp.properties[i].name] = ar[i];
|
|
// reply.trigger(record);
|
|
// });
|
|
// }).error(x=>reply.triggerError(x));
|
|
// }
|
|
// return reply;
|
|
// }
|
|
// static composeRecord(record, connection, includeClassId = true, prependLength = false)
|
|
// {
|
|
// var rt = new BinaryList();
|
|
// var template = Warehouse.getTemplateByType(record.constructor);
|
|
// if (includeClassId)
|
|
// rt.addGuid(template.classId);
|
|
// for(var i = 0; i < template.properties.length; i++)
|
|
// {
|
|
// var value = record[template.properties[i].name];
|
|
// rt.addUint8Array(Codec.compose(value, connection));
|
|
// }
|
|
// if (prependLength)
|
|
// rt.insertInt32(0, rt.length);
|
|
// return rt.toArray();
|
|
// }
|
|
// static composeRecordArray(records, connection, prependLength = false)
|
|
// {
|
|
// if (records == null ) //|| records?.length == 0)
|
|
// return prependLength ? new DC(4) : new DC(0);
|
|
// var rt = new BinaryList();
|
|
// //var comparsion = Codec.compareRecords(null, records[0]);
|
|
// var comparsion = records.length == 0 ? RecordComparisonResult.Empty : Codec.compareRecords(null, records[0]);
|
|
// rt.addUint8(comparsion);
|
|
// if (comparsion == RecordComparisonResult.Record)
|
|
// rt.addUint8Array(Codec.composeRecord(records[0], connection, true, true));
|
|
// for (var i = 1; i < records.length; i++)
|
|
// {
|
|
// comparsion = Codec.compareRecords(records[i - 1], records[i]);
|
|
// rt.addUint8(comparsion);
|
|
// if (comparsion == RecordComparisonResult.Record)
|
|
// rt.addUint8Array(Codec.composeRecord(records[i], connection, true, true));
|
|
// else if (comparsion == RecordComparisonResult.RecordSameType)
|
|
// rt.addUint8Array(Codec.composeRecord(records[i], connection, false, true));
|
|
// }
|
|
// if (prependLength)
|
|
// rt.insertInt32(0, rt.length);
|
|
// return rt.toArray();
|
|
// }
|
|
// static compareStructure(previous, next, connection) {
|
|
// if (next == null)
|
|
// return StructureComparisonResult.Null;
|
|
// if (previous == null)
|
|
// return StructureComparisonResult.Structure;
|
|
// if (next == previous)
|
|
// return StructureComparisonResult.Same;
|
|
// if (previous.length != next.length)
|
|
// return StructureComparisonResult.Structure;
|
|
// var previousKeys = previous.getKeys();
|
|
// var nextKeys = next.getKeys();
|
|
// for (let i = 0; i < previousKeys.length; i++)
|
|
// if (previousKeys[i] != nextKeys[i])
|
|
// return StructureComparisonResult.Structure;
|
|
// var previousTypes = Codec.getStructureDateTypes(previous, connection);
|
|
// var nextTypes = Codec.getStructureDateTypes(next, connection);
|
|
// for (let i = 0; i < previousTypes.length; i++)
|
|
// if (previousTypes[i] != nextTypes[i])
|
|
// return StructureComparisonResult.StructureSameKeys;
|
|
// return StructureComparisonResult.StructureSameTypes;
|
|
// }
|
|
// static getStructureDateTypes(structure, connection) {
|
|
// var keys = structure.getKeys();
|
|
// var types = [];
|
|
// for (var i = 0; i < keys.length; i++)
|
|
// types.push(Codec.getDataType(structure[keys[i]], connection));
|
|
// return types;
|
|
// }
|
|
// static isLocalResource(resource, connection) {
|
|
// if (resource instanceof DistributedResource)
|
|
// if (resource._p.connection == connection)
|
|
// return true;
|
|
// return false;
|
|
// }
|
|
// static composeResource(resource, connection) {
|
|
// if (Codec.isLocalResource(resource, connection))
|
|
// return BL().addUint32(resource.id);
|
|
// else {
|
|
// return BL().addUint8Array(resource.instance.template.classId.value).addUint32(resource.instance.id);
|
|
// }
|
|
// }
|
|
// static compareResource(previous, next, connection) {
|
|
// if (next == null)
|
|
// return ResourceComparisonResult.Null;
|
|
// else if (next == previous)
|
|
// return ResourceComparisonResult.Same;
|
|
// else if (Codec.isLocalResource(next, connection))
|
|
// return ResourceComparisonResult.Local;
|
|
// else
|
|
// return ResourceComparisonResult.Distributed;
|
|
// }
|
|
// static composeResourceArray(resources, connection, prependLength = false) {
|
|
// if (resources == null)// || resources.length == 0)// || !(resources instanceof ResourceArray))
|
|
// return prependLength ? new DC(4) : new DC(0);
|
|
// var rt = new BinaryList();
|
|
// var comparsion = resources.length == 0 ? ResourceComparisonResult.Empty : Codec.compareResource(null, resources[0], connection);
|
|
// rt.addUint8(comparsion);
|
|
// if (comparsion == ResourceComparisonResult.Local)
|
|
// rt.addUint32(resources[0]._p.instanceId);
|
|
// else if (comparsion == ResourceComparisonResult.Distributed)
|
|
// rt.addUint32(resources[0].instance.id);
|
|
// for (var i = 1; i < resources.length; i++)
|
|
// {
|
|
// comparsion = Codec.compareResource(resources[i - 1], resources[i], connection);
|
|
// rt.addUint8(comparsion);
|
|
// if (comparsion == ResourceComparisonResult.Local)
|
|
// rt.addUint32(resources[i]._p.instanceId);
|
|
// else if (comparsion == ResourceComparisonResult.Distributed)
|
|
// rt.addUint32(resources[i].instance.id);
|
|
// }
|
|
// if (prependLength)
|
|
// rt.addUint32(rt.length, 0);
|
|
// return rt.toArray();
|
|
// }
|
|
// static getDataType(value, connection) {
|
|
// switch (typeof value) {
|
|
// case "number":
|
|
// // float or ?
|
|
// if (Math.floor(value) == value) {
|
|
// if (value > 0) {
|
|
// // larger than byte ?
|
|
// if (value > 0xFF) {
|
|
// // larger than short ?
|
|
// if (value > 0xFFFF) {
|
|
// // larger than int ?
|
|
// if (value > 0xFFFFFFFF) {
|
|
// return DataType.UInt64;
|
|
// }
|
|
// else {
|
|
// return DataType.UInt32;
|
|
// }
|
|
// }
|
|
// else {
|
|
// return DataType.UInt16;
|
|
// }
|
|
// }
|
|
// else {
|
|
// return DataType.UInt8;
|
|
// }
|
|
// }
|
|
// else {
|
|
// if (value < -128) {
|
|
// if (value < -32768) {
|
|
// if (value < -2147483648) {
|
|
// return DataType.Int64;
|
|
// }
|
|
// else {
|
|
// return DataType.Int32;
|
|
// }
|
|
// }
|
|
// else {
|
|
// return DataType.Int16;
|
|
// }
|
|
// }
|
|
// else {
|
|
// return DataType.Int8;
|
|
// }
|
|
// }
|
|
// }
|
|
// else {
|
|
// // float or double
|
|
// return DataType.Float64;
|
|
// }
|
|
// case "string":
|
|
// return DataType.String;
|
|
// case "boolean":
|
|
// return DataType.Bool;
|
|
// case "object":
|
|
// if (value instanceof Array) {
|
|
// return DataType.VarArray;
|
|
// }
|
|
// else if (value instanceof IResource) {
|
|
// return Codec.isLocalResource(value, connection) ? DataType.Resource : DataType.DistributedResource;
|
|
// }
|
|
// else if (value instanceof Date) {
|
|
// return DataType.DateTime;
|
|
// }
|
|
// else if (value instanceof Uint8Array
|
|
// || value instanceof ArrayBuffer) {
|
|
// return DataType.UInt8Array;
|
|
// }
|
|
// else if (value instanceof Uint16Array)
|
|
// return DataType.UInt16Array;
|
|
// else if (value instanceof Uint32Array)
|
|
// return DataType.UInt32Array;
|
|
// else if (value instanceof Int16Array)
|
|
// return DataType.Int16Array;
|
|
// else if (value instanceof Int32Array)
|
|
// return DataType.Int32Array;
|
|
// else if (value instanceof Float32Array)
|
|
// return DataType.Float32Array;
|
|
// else if (value instanceof Float64Array)
|
|
// return DataType.Float64Array;
|
|
// else if (value instanceof Number) {
|
|
// // JS numbers are always 64-bit float
|
|
// return DataType.Float64;
|
|
// }
|
|
// else if (value instanceof Structure) {
|
|
// return DataType.Structure;
|
|
// }
|
|
// else if (value instanceof IRecord){
|
|
// return DataType.Record;
|
|
// }
|
|
// else {
|
|
// return DataType.Void
|
|
// }
|
|
// default:
|
|
// return DataType.Void;
|
|
// }
|
|
// }
|
|
// /// <summary>
|
|
// /// Parse an array of structures
|
|
// /// </summary>
|
|
// /// <param name="data">Bytes array</param>
|
|
// /// <param name="offset">Zero-indexed offset</param>
|
|
// /// <param name="length">Number of bytes to parse</param>
|
|
// /// <param name="connection">DistributedConnection is required in case a structure in the array holds items at the other end</param>
|
|
// /// <returns>Array of structures</returns>
|
|
// static parseStructureArray(data, offset, length, connection)
|
|
// {
|
|
// var reply = new AsyncBag();
|
|
// if (length == 0)
|
|
// {
|
|
// reply.seal();
|
|
// return reply;
|
|
// }
|
|
// var end = offset + length;
|
|
// var result = data[offset++];
|
|
// var previous = null;
|
|
// //var previousKeys = [];
|
|
// //var previousTypes = [];
|
|
// var metadata = {keys: null, types: null};
|
|
// if (result == StructureComparisonResult.Null)
|
|
// previous = new AsyncReply(null);
|
|
// else if (result == StructureComparisonResult.Structure)
|
|
// {
|
|
// var cs = data.getUint32(offset);
|
|
// offset += 4;
|
|
// previous = Codec.parseStructure(data, offset, cs, connection, metadata);
|
|
// offset += cs;
|
|
// }
|
|
// reply.add(previous);
|
|
// while (offset < end)
|
|
// {
|
|
// result = data[offset++];
|
|
// if (result == StructureComparisonResult.Null)
|
|
// previous = new AsyncReply(null);
|
|
// else if (result == StructureComparisonResult.Structure)
|
|
// {
|
|
// let cs = data.getUint32(offset);
|
|
// offset += 4;
|
|
// previous = Codec.parseStructure(data, offset, cs, connection, metadata);
|
|
// offset += cs;
|
|
// }
|
|
// else if (result == StructureComparisonResult.StructureSameKeys)
|
|
// {
|
|
// let cs = data.getUint32(offset);
|
|
// offset += 4;
|
|
// previous = Codec.parseStructure(data, offset, cs, connection, metadata, metadata.keys);
|
|
// offset += cs;
|
|
// }
|
|
// else if (result == StructureComparisonResult.StructureSameTypes)
|
|
// {
|
|
// let cs = data.getUint32(offset);
|
|
// offset += 4;
|
|
// previous = Codec.parseStructure(data, offset, cs, connection, metadata, metadata.keys, metadata.types);
|
|
// offset += cs;
|
|
// }
|
|
// reply.add(previous);
|
|
// }
|
|
// reply.seal();
|
|
// return reply;
|
|
// }
|
|
// }
|
|
var CodecComposeResults = //final int transmissionTypeIdentifier;
|
|
//final DC data;
|
|
function CodecComposeResults(transmissionTypeIdentifier, data) {
|
|
_classCallCheck(this, CodecComposeResults);
|
|
|
|
this.transmissionTypeIdentifier = transmissionTypeIdentifier;
|
|
this.data = data;
|
|
};
|
|
|
|
exports.CodecComposeResults = CodecComposeResults;
|
|
|
|
var CodecParseResults = //final AsyncReply reply;
|
|
//final int size;
|
|
function CodecParseResults(size, reply) {
|
|
_classCallCheck(this, CodecParseResults);
|
|
|
|
this.size = size;
|
|
this.reply = reply;
|
|
};
|
|
|
|
exports.CodecParseResults = CodecParseResults;
|
|
|
|
var Codec = /*#__PURE__*/function () {
|
|
function Codec() {
|
|
_classCallCheck(this, Codec);
|
|
}
|
|
|
|
_createClass(Codec, null, [{
|
|
key: "parse",
|
|
value: //AsyncReply Parser(byte[] data, uint offset, uint length, DistributedConnection connection);
|
|
/// <summary>
|
|
/// Parse a value
|
|
/// </summary>
|
|
/// <param name="data">Bytes array</param>
|
|
/// <param name="offset">Zero-indexed offset.</param>
|
|
/// <param name="size">Output the number of bytes parsed</param>
|
|
/// <param name="connection">DistributedConnection is required in case a structure in the array holds items at the other end.</param>
|
|
/// <param name="dataType">DataType, in case the data is not prepended with DataType</param>
|
|
/// <returns>Value</returns>
|
|
function parse(data, offset, connection) {
|
|
var dataType = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
|
|
var len = 0;
|
|
|
|
if (dataType == null) {
|
|
var _dataType$offset, _dataType;
|
|
|
|
var parsedDataTyped = _TransmissionType.TransmissionType.parse(data, offset, data.length);
|
|
|
|
len = parsedDataTyped.size;
|
|
dataType = parsedDataTyped.type;
|
|
offset = (_dataType$offset = (_dataType = dataType) === null || _dataType === void 0 ? void 0 : _dataType.offset) !== null && _dataType$offset !== void 0 ? _dataType$offset : 0;
|
|
} else len = dataType.contentLength;
|
|
|
|
if (dataType != null) {
|
|
if (dataType.classType == _TransmissionType.TransmissionTypeClass.Fixed) {
|
|
return new CodecParseResults(len, Codec.fixedParsers[dataType.exponent][dataType.index](data, dataType.offset, dataType.contentLength, connection));
|
|
} else if (dataType.classType == _TransmissionType.TransmissionTypeClass.Dynamic) {
|
|
return new CodecParseResults(len, Codec.dynamicParsers[dataType.index](data, dataType.offset, dataType.contentLength, connection));
|
|
} else //if (tt.Class == TransmissionTypeClass.Typed)
|
|
{
|
|
return new CodecParseResults(len, Codec.typedParsers[dataType.index](data, dataType.offset, dataType.contentLength, connection));
|
|
}
|
|
}
|
|
|
|
throw Error("Can't parse transmission type.");
|
|
}
|
|
}, {
|
|
key: "mapFromObject",
|
|
value: function mapFromObject(map) {
|
|
var rt = new Map();
|
|
|
|
for (var i in map) {
|
|
rt.set(i, map[i]);
|
|
}
|
|
}
|
|
}, {
|
|
key: "getListType",
|
|
value: function getListType(list) {
|
|
if (list instanceof _TypedList["default"]) return _TypedList["default"].getType(list);else return Object;
|
|
}
|
|
}, {
|
|
key: "getMapTypes",
|
|
value: function getMapTypes(map) {
|
|
if (map instanceof _TypedMap["default"]) return _TypedMap["default"].getTypes(map);else return [Object, Object];
|
|
} /// <summary>
|
|
/// Compose a variable
|
|
/// </summary>
|
|
/// <param name="value">Value to compose.</param>
|
|
/// <param name="connection">DistributedConnection is required to check locality.</param>
|
|
/// <param name="prependType">If True, prepend the DataType at the beginning of the output.</param>
|
|
/// <returns>Array of bytes in the network byte order.</returns>
|
|
|
|
}, {
|
|
key: "compose",
|
|
value: function compose(valueOrSource, connection) {
|
|
if (valueOrSource == null) return _TransmissionType.TransmissionType.compose(_TransmissionType.TransmissionTypeIdentifier.Null, new _DC.DC(0));
|
|
var type = valueOrSource.constructor; // if (type.)
|
|
// {
|
|
// var genericType = type.GetGenericTypeDefinition();
|
|
// if (genericType == typeof(DistributedPropertyContext<>))
|
|
// {
|
|
// valueOrSource = ((IDistributedPropertyContext)valueOrSource).GetValue(connection);
|
|
// }
|
|
// else if (genericType == typeof(Func<>))
|
|
// {
|
|
// var args = genericType.GetGenericArguments();
|
|
// if (args.Length == 2 && args[0] == typeof(DistributedConnection))
|
|
// {
|
|
// //Func<DistributedConnection, DistributedConnection> a;
|
|
// //a.Invoke()
|
|
// }
|
|
// }
|
|
// }
|
|
// if (valueOrSource is IUserType)
|
|
// valueOrSource = (valueOrSource as IUserType).Get();
|
|
//if (valueOrSource is Func<DistributedConnection, object>)
|
|
// valueOrSource = (valueOrSource as Func<DistributedConnection, object>)(connection);
|
|
// if (valueOrSource == null)
|
|
// return TransmissionType.Compose(TransmissionTypeIdentifier.Null, null);
|
|
// type = valueOrSource.GetType();
|
|
|
|
if (this.composers[type] != undefined) {
|
|
var results = this.composers[type](valueOrSource, connection);
|
|
return _TransmissionType.TransmissionType.compose(results.identifier, results.data);
|
|
} else {
|
|
if (valueOrSource instanceof _TypedList["default"]) {
|
|
var genericType = this.getListType(valueOrSource);
|
|
|
|
var _results = _DataSerializer["default"].typedListComposer(valueOrSource, genericType, connection);
|
|
|
|
return _TransmissionType.TransmissionType.compose(_results.identifier, _results.data);
|
|
} else if (valueOrSource instanceof _TypedMap["default"]) {
|
|
var genericTypes = _TypedMap["default"].getTypes(valueOrSource);
|
|
|
|
var _results2 = _DataSerializer["default"].typedMapComposer(valueOrSource, genericTypes[0], genericTypes[1], connection);
|
|
|
|
return _TransmissionType.TransmissionType.compose(_results2.identifier, _results2.data);
|
|
} else if (valueOrSource instanceof _IResource["default"]) {
|
|
var _results3 = _DataSerializer["default"].resourceComposer(valueOrSource, connection);
|
|
|
|
return _TransmissionType.TransmissionType.compose(_results3.identifier, _results3.data);
|
|
} else if (valueOrSource instanceof _IRecord["default"]) {
|
|
var _results4 = _DataSerializer["default"].recordComposer(valueOrSource, connection);
|
|
|
|
return _TransmissionType.TransmissionType.compose(_results4.identifier, _results4.data);
|
|
} else if (valueOrSource instanceof _IEnum["default"]) {
|
|
var _results5 = _DataSerializer["default"].enumComposer(valueOrSource, connection);
|
|
|
|
return _TransmissionType.TransmissionType.compose(_results5.identifier, _results5.data);
|
|
} else if (valueOrSource instanceof _Tuple["default"]) {
|
|
var _results6 = _DataSerializer["default"].tupleComposer(valueOrSource, connection);
|
|
|
|
return _TransmissionType.TransmissionType.compose(_results6.identifier, _results6.data);
|
|
}
|
|
}
|
|
|
|
return _TransmissionType.TransmissionType.compose(_TransmissionType.TransmissionTypeIdentifier.Null, new _DC.DC(0));
|
|
} /// <summary>
|
|
/// Check if a resource is local to a given connection.
|
|
/// </summary>
|
|
/// <param name="resource">Resource to check.</param>
|
|
/// <param name="connection">DistributedConnection to check if the resource is local to it.</param>
|
|
/// <returns>True, if the resource owner is the given connection, otherwise False.</returns>
|
|
|
|
}, {
|
|
key: "isLocalResource",
|
|
value: function isLocalResource(resource, connection) {
|
|
if (connection == null) return false;
|
|
|
|
if (resource instanceof _DistributedResource["default"]) {
|
|
if (resource.connection == connection) return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}]);
|
|
|
|
return Codec;
|
|
}();
|
|
|
|
exports["default"] = Codec;
|
|
|
|
_defineProperty(Codec, "fixedParsers", [[_DataDeserializer["default"].nullParser, _DataDeserializer["default"].booleanFalseParser, _DataDeserializer["default"].booleanTrueParser, _DataDeserializer["default"].notModifiedParser], [_DataDeserializer["default"].byteParser, _DataDeserializer["default"].sByteParser, _DataDeserializer["default"].char8Parser], [_DataDeserializer["default"].int16Parser, _DataDeserializer["default"].uInt16Parser, _DataDeserializer["default"].char16Parser], [_DataDeserializer["default"].int32Parser, _DataDeserializer["default"].uInt32Parser, _DataDeserializer["default"].float32Parser, _DataDeserializer["default"].resourceParser, _DataDeserializer["default"].localResourceParser], [_DataDeserializer["default"].int64Parser, _DataDeserializer["default"].uInt64Parser, _DataDeserializer["default"].float64Parser, _DataDeserializer["default"].dateTimeParser], [_DataDeserializer["default"].int128Parser, // int 128
|
|
_DataDeserializer["default"].uInt128Parser, // uint 128
|
|
_DataDeserializer["default"].float128Parser]]);
|
|
|
|
_defineProperty(Codec, "dynamicParsers", [_DataDeserializer["default"].rawDataParser, _DataDeserializer["default"].stringParser, _DataDeserializer["default"].listParser, _DataDeserializer["default"].resourceListParser, _DataDeserializer["default"].recordListParser]);
|
|
|
|
_defineProperty(Codec, "typedParsers", [_DataDeserializer["default"].recordParser, _DataDeserializer["default"].typedListParser, _DataDeserializer["default"].typedMapParser, _DataDeserializer["default"].tupleParser, _DataDeserializer["default"].enumParser, _DataDeserializer["default"].constantParser]);
|
|
|
|
_defineProperty(Codec, "composers", (_defineProperty2 = {}, _defineProperty(_defineProperty2, Boolean, _DataSerializer["default"].boolComposer), _defineProperty(_defineProperty2, _NotModified["default"], _DataSerializer["default"].notModifiedComposer), _defineProperty(_defineProperty2, _ExtendedTypes.Char8, _DataSerializer["default"].char8Composer), _defineProperty(_defineProperty2, _ExtendedTypes.Char16, _DataSerializer["default"].char16Composer), _defineProperty(_defineProperty2, _ExtendedTypes.Int64, _DataSerializer["default"].int64Composer), _defineProperty(_defineProperty2, _ExtendedTypes.UInt64, _DataSerializer["default"].uInt64Composer), _defineProperty(_defineProperty2, _ExtendedTypes.Int32, _DataSerializer["default"].int32Composer), _defineProperty(_defineProperty2, _ExtendedTypes.UInt32, _DataSerializer["default"].uInt32Composer), _defineProperty(_defineProperty2, _ExtendedTypes.Int16, _DataSerializer["default"].int16Composer), _defineProperty(_defineProperty2, _ExtendedTypes.UInt16, _DataSerializer["default"].uInt16Composer), _defineProperty(_defineProperty2, _ExtendedTypes.Int8, _DataSerializer["default"].int8Composer), _defineProperty(_defineProperty2, _ExtendedTypes.UInt8, _DataSerializer["default"].uInt8Composer), _defineProperty(_defineProperty2, _ExtendedTypes.Float32, _DataSerializer["default"].float32Composer), _defineProperty(_defineProperty2, _ExtendedTypes.Float64, _DataSerializer["default"].float64Composer), _defineProperty(_defineProperty2, _ExtendedTypes.Float128, _DataSerializer["default"].float128Composer), _defineProperty(_defineProperty2, Number, _DataSerializer["default"].numberComposer), _defineProperty(_defineProperty2, Date, _DataSerializer["default"].dateTimeComposer), _defineProperty(_defineProperty2, _DC.DC, _DataSerializer["default"].rawDataComposer), _defineProperty(_defineProperty2, Uint8Array, _DataSerializer["default"].rawDataComposer), _defineProperty(_defineProperty2, String, _DataSerializer["default"].stringComposer), _defineProperty(_defineProperty2, Array, _DataSerializer["default"].listComposer), _defineProperty(_defineProperty2, _ResourceArray["default"], _DataSerializer["default"].resourceListComposer), _defineProperty(_defineProperty2, _RecordArray["default"], _DataSerializer["default"].recordListComposer), _defineProperty(_defineProperty2, Map, _DataSerializer["default"].mapComposer), _defineProperty(_defineProperty2, _PropertyValueArray["default"], _DataSerializer["default"].propertyValueArrayComposer), _defineProperty2));
|
|
|
|
},{"../Core/AsyncBag.js":2,"../Core/AsyncReply.js":5,"../Net/IIP/DistributedPropertyContext.js":43,"../Net/IIP/DistributedResource.js":44,"../Resource/IResource.js":70,"../Resource/Template/TemplateType.js":82,"../Resource/Warehouse.js":84,"./BinaryList.js":13,"./DC.js":15,"./DataDeserializer.js":16,"./DataSerializer.js":17,"./DataType.js":18,"./ExtendedTypes.js":19,"./IEnum.js":21,"./IRecord.js":22,"./KeyList.js":23,"./NotModified.js":24,"./PropertyValue.js":26,"./PropertyValueArray.js":27,"./Record.js":28,"./RecordArray.js":29,"./RecordComparisonResult.js":30,"./ResourceArray.js":32,"./ResourceArrayType.js":33,"./ResourceComparisonResult.js":34,"./Structure.js":35,"./StructureArray.js":36,"./StructureComparisonResult.js":37,"./TransmissionType.js":38,"./Tuple.js":39,"./TypedList.js":40,"./TypedMap.js":41}],15:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 25/07/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.BL = BL;
|
|
exports.DC = exports["default"] = exports.Endian = exports.TWO_PWR_32 = exports.UNIX_EPOCH = void 0;
|
|
|
|
var _BinaryList = _interopRequireDefault(require("./BinaryList.js"));
|
|
|
|
var _Guid = _interopRequireDefault(require("./Guid.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
|
|
|
|
function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
var UNIX_EPOCH = 621355968000000000;
|
|
exports.UNIX_EPOCH = UNIX_EPOCH;
|
|
var TWO_PWR_32 = (1 << 16) * (1 << 16);
|
|
exports.TWO_PWR_32 = TWO_PWR_32;
|
|
var Endian = {
|
|
Big: 0,
|
|
Little: 1
|
|
};
|
|
exports.Endian = Endian;
|
|
|
|
var DC = /*#__PURE__*/function (_Uint8Array) {
|
|
_inherits(DC, _Uint8Array);
|
|
|
|
var _super = _createSuper(DC);
|
|
|
|
function DC(bufferOrSize) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, DC);
|
|
|
|
_this = _super.call(this, bufferOrSize); //if (bufferOrSize instanceof ArrayBuffer) {
|
|
// this.buffer = bufferOrSize;
|
|
//}
|
|
//else
|
|
//{
|
|
// this.buffer = new Uint8Array(bufferOrSize);
|
|
//}
|
|
|
|
_this.dv = new DataView(_this.buffer);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(DC, [{
|
|
key: "append",
|
|
value: function append(src, offset, length) {
|
|
if (!(src instanceof DC)) src = new DC(src);
|
|
var appendix = src.clip(offset, length);
|
|
var rt = new DC(this.length + appendix.length);
|
|
rt.set(this, 0);
|
|
rt.set(appendix, this.length);
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "clip",
|
|
value: function clip(offset, length) {
|
|
return this.slice(offset, offset + length);
|
|
}
|
|
}, {
|
|
key: "getInt8",
|
|
value: function getInt8(offset) {
|
|
return this.dv.getUint8(offset);
|
|
}
|
|
}, {
|
|
key: "getUint8",
|
|
value: function getUint8(offset) {
|
|
return this[offset]; // this.dv.getUint8(offset);
|
|
}
|
|
}, {
|
|
key: "getInt16",
|
|
value: function getInt16(offset, endian) {
|
|
return this.dv.getInt16(offset, endian != Endian.Big);
|
|
}
|
|
}, {
|
|
key: "getUint16",
|
|
value: function getUint16(offset, endian) {
|
|
return this.dv.getUint16(offset, endian != Endian.Big);
|
|
}
|
|
}, {
|
|
key: "getInt32",
|
|
value: function getInt32(offset, endian) {
|
|
return this.dv.getInt32(offset, endian != Endian.Big);
|
|
}
|
|
}, {
|
|
key: "getUint32",
|
|
value: function getUint32(offset, endian) {
|
|
return this.dv.getUint32(offset, endian != Endian.Big);
|
|
}
|
|
}, {
|
|
key: "getFloat32",
|
|
value: function getFloat32(offset, endian) {
|
|
return this.dv.getFloat32(offset, endian != Endian.Big);
|
|
}
|
|
}, {
|
|
key: "getFloat64",
|
|
value: function getFloat64(offset, endian) {
|
|
return this.dv.getFloat64(offset, endian != Endian.Big);
|
|
}
|
|
}, {
|
|
key: "setInt8",
|
|
value: function setInt8(offset, value) {
|
|
return this.dv.setInt8(offset, value);
|
|
}
|
|
}, {
|
|
key: "setUint8",
|
|
value: function setUint8(offset, value) {
|
|
return this.dv.setUint8(offset, value);
|
|
}
|
|
}, {
|
|
key: "setInt16",
|
|
value: function setInt16(offset, value, endian) {
|
|
return this.dv.setInt16(offset, value, endian != Endian.Big);
|
|
}
|
|
}, {
|
|
key: "setUint16",
|
|
value: function setUint16(offset, value, endian) {
|
|
return this.dv.setUint16(offset, value, endian != Endian.Big);
|
|
}
|
|
}, {
|
|
key: "setInt32",
|
|
value: function setInt32(offset, value, endian) {
|
|
return this.dv.setInt32(offset, value, endian != Endian.Big);
|
|
}
|
|
}, {
|
|
key: "setUint32",
|
|
value: function setUint32(offset, value, endian) {
|
|
return this.dv.setUint32(offset, value, endian != Endian.Big);
|
|
}
|
|
}, {
|
|
key: "setFloat32",
|
|
value: function setFloat32(offset, value, endian) {
|
|
return this.dv.setFloat32(offset, value, endian != Endian.Big);
|
|
}
|
|
}, {
|
|
key: "setFloat64",
|
|
value: function setFloat64(offset, value, endian) {
|
|
return this.dv.setFloat64(offset, value, endian != Endian.Big);
|
|
}
|
|
}, {
|
|
key: "getInt8Array",
|
|
value: function getInt8Array(offset, length) {
|
|
return new Int8Array(this.buffer, offset, length);
|
|
}
|
|
}, {
|
|
key: "getUint8Array",
|
|
value: function getUint8Array(offset, length) {
|
|
return new Uint8Array(this.buffer, offset, length);
|
|
}
|
|
}, {
|
|
key: "copy",
|
|
value: function copy(offset, length, elementSize, func, dstType, endian) {
|
|
var rt = new dstType(length / elementSize);
|
|
var d = 0,
|
|
end = offset + length;
|
|
|
|
for (var i = offset; i < end; i += elementSize) {
|
|
rt[d++] = func.call(this, i, endian);
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "paste",
|
|
value: function paste(offset, length, elementSize, func) {
|
|
var rt = new dstType(length / elementSize);
|
|
var d = 0,
|
|
end = offset + length;
|
|
|
|
for (var i = offset; i < end; i += elementSize) {
|
|
rt[d++] = func.call(this, i);
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "getInt16Array",
|
|
value: function getInt16Array(offset, length, endian) {
|
|
return this.copy(offset, length, 2, this.getInt16, Int16Array, endian); //return new Int16Array(this.clip(offset, length).buffer);
|
|
}
|
|
}, {
|
|
key: "getUint16Array",
|
|
value: function getUint16Array(offset, length, endian) {
|
|
return this.copy(offset, length, 2, this.getUint16, Uint16Array, endian);
|
|
}
|
|
}, {
|
|
key: "getInt32Array",
|
|
value: function getInt32Array(offset, length, endian) {
|
|
return this.copy(offset, length, 4, this.getInt32, Int32Array, endian);
|
|
}
|
|
}, {
|
|
key: "getUint32Array",
|
|
value: function getUint32Array(offset, length, endian) {
|
|
return this.copy(offset, length, 4, this.getUint32, Uint32Array, endian);
|
|
}
|
|
}, {
|
|
key: "getFloat32Array",
|
|
value: function getFloat32Array(offset, length, endian) {
|
|
return this.copy(offset, length, 4, this.getFloat32, Float32Array, endian);
|
|
}
|
|
}, {
|
|
key: "getFloat64Array",
|
|
value: function getFloat64Array(offset, length, endian) {
|
|
return this.copy(offset, length, 8, this.getFloat64, Float64Array, endian);
|
|
}
|
|
}, {
|
|
key: "getInt64Array",
|
|
value: function getInt64Array(offset, length, endian) {
|
|
return this.copy(offset, length, 8, this.getInt64, Float64Array, endian);
|
|
}
|
|
}, {
|
|
key: "getUint64Array",
|
|
value: function getUint64Array(offset, length, endian) {
|
|
return this.copy(offset, length, 8, this.getUint64, Float64Array, endian);
|
|
}
|
|
}, {
|
|
key: "getBoolean",
|
|
value: function getBoolean(offset) {
|
|
return this.getUint8(offset) > 0;
|
|
}
|
|
}, {
|
|
key: "setBoolean",
|
|
value: function setBoolean(offset, value) {
|
|
this.setUint8(offset, value ? 1 : 0);
|
|
}
|
|
}, {
|
|
key: "getBooleanArray",
|
|
value: function getBooleanArray(offset, length) {
|
|
var rt = [];
|
|
|
|
for (var i = 0; i < length; i++) {
|
|
rt.push(this.getBoolean(offset + i));
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "getChar",
|
|
value: function getChar(offset, endian) {
|
|
return String.fromCharCode(this.getUint16(offset, endian));
|
|
}
|
|
}, {
|
|
key: "setChar",
|
|
value: function setChar(offset, value, endian) {
|
|
this.setUint16(offset, value.charCodeAt(0), endian);
|
|
}
|
|
}, {
|
|
key: "getCharArray",
|
|
value: function getCharArray(offset, length, endian) {
|
|
var rt = [];
|
|
|
|
for (var i = 0; i < length; i += 2) {
|
|
rt.push(this.getChar(offset + i, endian));
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "getHex",
|
|
value: function getHex(offset, length) {
|
|
var rt = "";
|
|
|
|
for (var i = offset; i < offset + length; i++) {
|
|
var h = this[i].toString(16);
|
|
rt += h.length == 1 ? "0" + h : h;
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "getString",
|
|
value: function getString(offset, length) {
|
|
if (typeof StringView != "undefined") return new StringView(this.buffer, "UTF-8", offset, length);else {
|
|
var bytes = this.getUint8Array(offset, length);
|
|
var encodedString = String.fromCharCode.apply(null, bytes),
|
|
decodedString = decodeURIComponent(escape(encodedString));
|
|
return decodedString;
|
|
}
|
|
}
|
|
}, {
|
|
key: "getStringArray",
|
|
value: function getStringArray(offset, length, endian) {
|
|
var rt = [];
|
|
var i = 0;
|
|
|
|
while (i < length) {
|
|
var cl = this.getUint32(offset + i, endian);
|
|
i += 4;
|
|
rt.push(this.getString(offset + i, cl));
|
|
i += cl;
|
|
}
|
|
|
|
return rt;
|
|
} // @TODO: Test numbers with bit 7 of h = 1
|
|
|
|
}, {
|
|
key: "getInt64",
|
|
value: function getInt64(offset, endian) {
|
|
if (endian == Endian.Big) {
|
|
var bi = BigInt(0);
|
|
bi |= BigInt(this[offset++]) << 56n;
|
|
bi |= BigInt(this[offset++]) << 48n;
|
|
bi |= BigInt(this[offset++]) << 40n;
|
|
bi |= BigInt(this[offset++]) << 32n;
|
|
bi |= BigInt(this[offset++]) << 24n;
|
|
bi |= BigInt(this[offset++]) << 16n;
|
|
bi |= BigInt(this[offset++]) << 8n;
|
|
bi |= BigInt(this[offset++]);
|
|
return parseInt(bi);
|
|
} else {
|
|
var _bi = BigInt(0);
|
|
|
|
_bi |= BigInt(this[offset++]);
|
|
_bi |= BigInt(this[offset++]) << 8n;
|
|
_bi |= BigInt(this[offset++]) << 16n;
|
|
_bi |= BigInt(this[offset++]) << 24n;
|
|
_bi |= BigInt(this[offset++]) << 32n;
|
|
_bi |= BigInt(this[offset++]) << 40n;
|
|
_bi |= BigInt(this[offset++]) << 48n;
|
|
_bi |= BigInt(this[offset++]) << 56n;
|
|
return parseInt(_bi);
|
|
} // var h = this.getInt32(offset);
|
|
// var l = this.getInt32(offset + 4);
|
|
// return h * TWO_PWR_32 + ((l >= 0) ? l : TWO_PWR_32 + l);
|
|
|
|
}
|
|
}, {
|
|
key: "getUint64",
|
|
value: function getUint64(offset, endian) {
|
|
if (endian == Endian.Big) {
|
|
var bi = BigInt(0);
|
|
bi |= BigInt(this[offset++]) << 56n;
|
|
bi |= BigInt(this[offset++]) << 48n;
|
|
bi |= BigInt(this[offset++]) << 40n;
|
|
bi |= BigInt(this[offset++]) << 32n;
|
|
bi |= BigInt(this[offset++]) << 24n;
|
|
bi |= BigInt(this[offset++]) << 16n;
|
|
bi |= BigInt(this[offset++]) << 8n;
|
|
bi |= BigInt(this[offset++]);
|
|
return parseInt(bi);
|
|
} else {
|
|
var _bi2 = BigInt(0);
|
|
|
|
_bi2 |= BigInt(this[offset++]);
|
|
_bi2 |= BigInt(this[offset++]) << 8n;
|
|
_bi2 |= BigInt(this[offset++]) << 16n;
|
|
_bi2 |= BigInt(this[offset++]) << 24n;
|
|
_bi2 |= BigInt(this[offset++]) << 32n;
|
|
_bi2 |= BigInt(this[offset++]) << 40n;
|
|
_bi2 |= BigInt(this[offset++]) << 48n;
|
|
_bi2 |= BigInt(this[offset++]) << 56n;
|
|
return parseInt(_bi2);
|
|
} //var h = this.getUint32(offset);
|
|
//var l = this.getUint32(offset + 4);
|
|
//return h * TWO_PWR_32 + ((l >= 0) ? l : TWO_PWR_32 + l);
|
|
|
|
}
|
|
}, {
|
|
key: "setInt64",
|
|
value: function setInt64(offset, value, endian) {
|
|
var bi = BigInt(value);
|
|
|
|
var _byte = BigInt(0xFF);
|
|
|
|
if (endian == Endian.Big) {
|
|
this[offset++] = parseInt(bi >> 56n & _byte);
|
|
this[offset++] = parseInt(bi >> 48n & _byte);
|
|
this[offset++] = parseInt(bi >> 40n & _byte);
|
|
this[offset++] = parseInt(bi >> 32n & _byte);
|
|
this[offset++] = parseInt(bi >> 24n & _byte);
|
|
this[offset++] = parseInt(bi >> 16n & _byte);
|
|
this[offset++] = parseInt(bi >> 8n & _byte);
|
|
this[offset++] = parseInt(bi & _byte);
|
|
} else {
|
|
this[offset++] = parseInt(bi & _byte);
|
|
this[offset++] = parseInt(bi >> 8n & _byte);
|
|
this[offset++] = parseInt(bi >> 16n & _byte);
|
|
this[offset++] = parseInt(bi >> 24n & _byte);
|
|
this[offset++] = parseInt(bi >> 32n & _byte);
|
|
this[offset++] = parseInt(bi >> 40n & _byte);
|
|
this[offset++] = parseInt(bi >> 48n & _byte);
|
|
this[offset++] = parseInt(bi >> 56n & _byte);
|
|
} //var l = (value % TWO_PWR_32) | 0;
|
|
//var h = (value / TWO_PWR_32) | 0;
|
|
//this.setInt32(offset, h);
|
|
//this.setInt32(offset + 4, l);
|
|
|
|
}
|
|
}, {
|
|
key: "setUint64",
|
|
value: function setUint64(offset, value, endian) {
|
|
var bi = BigInt(value);
|
|
|
|
var _byte2 = BigInt(0xFF);
|
|
|
|
if (endian == Endian.Big) {
|
|
this[offset++] = parseInt(bi >> 56n & _byte2);
|
|
this[offset++] = parseInt(bi >> 48n & _byte2);
|
|
this[offset++] = parseInt(bi >> 40n & _byte2);
|
|
this[offset++] = parseInt(bi >> 32n & _byte2);
|
|
this[offset++] = parseInt(bi >> 24n & _byte2);
|
|
this[offset++] = parseInt(bi >> 16n & _byte2);
|
|
this[offset++] = parseInt(bi >> 8n & _byte2);
|
|
this[offset++] = parseInt(bi & _byte2);
|
|
} else {
|
|
this[offset++] = parseInt(bi & _byte2);
|
|
this[offset++] = parseInt(bi >> 8n & _byte2);
|
|
this[offset++] = parseInt(bi >> 16n & _byte2);
|
|
this[offset++] = parseInt(bi >> 24n & _byte2);
|
|
this[offset++] = parseInt(bi >> 32n & _byte2);
|
|
this[offset++] = parseInt(bi >> 40n & _byte2);
|
|
this[offset++] = parseInt(bi >> 48n & _byte2);
|
|
this[offset++] = parseInt(bi >> 56n & _byte2);
|
|
} // var l = (value % TWO_PWR_32) | 0;
|
|
// var h = (value / TWO_PWR_32) | 0;
|
|
// this.setInt32(offset, h);
|
|
// this.setInt32(offset + 4, l);
|
|
|
|
}
|
|
}, {
|
|
key: "setDateTime",
|
|
value: function setDateTime(offset, value, endian) {
|
|
// Unix Epoch
|
|
var ticks = 621355968000000000 + value.getTime() * 10000;
|
|
this.setUint64(offset, ticks, endian);
|
|
}
|
|
}, {
|
|
key: "getDateTime",
|
|
value: function getDateTime(offset, endian) {
|
|
var ticks = this.getUint64(offset, endian);
|
|
return new Date(Math.round((ticks - UNIX_EPOCH) / 10000));
|
|
}
|
|
}, {
|
|
key: "getDateTimeArray",
|
|
value: function getDateTimeArray(offset, endian) {
|
|
var rt = [];
|
|
|
|
for (var i = 0; i < length; i += 8) {
|
|
rt.push(this.getDateTime(offset + i, endian));
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "getGuid",
|
|
value: function getGuid(offset) {
|
|
return new _Guid["default"](this.clip(offset, 16));
|
|
/*
|
|
var d = this.getUint8Array(offset, 16);
|
|
var rt = "";
|
|
for (var i = 0; i < 16; i++) {
|
|
rt += String.fromCharCode(d[i]);
|
|
}
|
|
return btoa(rt);
|
|
*/
|
|
}
|
|
}, {
|
|
key: "getGuidArray",
|
|
value: function getGuidArray(offset, length) {
|
|
var rt = [];
|
|
|
|
for (var i = 0; i < length; i += 16) {
|
|
rt.push(this.getGuid(offset + i));
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "sequenceEqual",
|
|
value: function sequenceEqual(ar) {
|
|
if (ar.length != this.length) return false;else {
|
|
for (var i = 0; i < this.length; i++) {
|
|
if (ar[i] != this[i]) return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}], [{
|
|
key: "boolToBytes",
|
|
value: function boolToBytes(value) {
|
|
var rt = new DC(1);
|
|
rt.setBoolean(0, value);
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "int8ToBytes",
|
|
value: function int8ToBytes(value) {
|
|
var rt = new DC(1);
|
|
rt.setInt8(0, value);
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "fromList",
|
|
value: function fromList(list) {
|
|
return new DC(list);
|
|
}
|
|
}, {
|
|
key: "hexToBytes",
|
|
value: function hexToBytes(value) {
|
|
// convert hex to Uint8Array
|
|
var rt = new DC(value.length / 2);
|
|
|
|
for (var i = 0; i < rt.length; i++) {
|
|
rt[i] = parseInt(value.substr(i * 2, 2), 16);
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "uint8ToBytes",
|
|
value: function uint8ToBytes(value) {
|
|
var rt = new DC(1);
|
|
rt.setUint8(0, value);
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "charToBytes",
|
|
value: function charToBytes(value, endian) {
|
|
var rt = new DC(2);
|
|
rt.setChar(0, value, endian);
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "int16ToBytes",
|
|
value: function int16ToBytes(value, endian) {
|
|
var rt = new DC(2);
|
|
rt.setInt16(0, value, endian);
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "uint16ToBytes",
|
|
value: function uint16ToBytes(value, endian) {
|
|
var rt = new DC(2);
|
|
rt.setUint16(0, value, endian);
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "int32ToBytes",
|
|
value: function int32ToBytes(value, endian) {
|
|
var rt = new DC(4);
|
|
rt.setInt32(0, value, endian);
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "uint32ToBytes",
|
|
value: function uint32ToBytes(value, endian) {
|
|
var rt = new DC(4);
|
|
rt.setUint32(0, value, endian);
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "float32ToBytes",
|
|
value: function float32ToBytes(value, endian) {
|
|
var rt = new DC(4);
|
|
rt.setFloat32(0, value, endian);
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "int64ToBytes",
|
|
value: function int64ToBytes(value, endian) {
|
|
var rt = new DC(8);
|
|
rt.setInt64(0, value, endian);
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "uint64ToBytes",
|
|
value: function uint64ToBytes(value, endian) {
|
|
var rt = new DC(8);
|
|
rt.setUint64(0, value, endian);
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "float64ToBytes",
|
|
value: function float64ToBytes(value, endian) {
|
|
var rt = new DC(8);
|
|
rt.setFloat64(0, value, endian);
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "dateTimeToBytes",
|
|
value: function dateTimeToBytes(value, endian) {
|
|
var rt = new DC(8);
|
|
rt.setDateTime(0, value, endian);
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "stringToBytes",
|
|
value: function stringToBytes(value) {
|
|
var utf8 = unescape(encodeURIComponent(value));
|
|
var rt = [];
|
|
|
|
for (var i = 0; i < utf8.length; i++) {
|
|
rt.push(utf8.charCodeAt(i));
|
|
}
|
|
|
|
return new DC(rt);
|
|
}
|
|
}, {
|
|
key: "stringArrayToBytes",
|
|
value: function stringArrayToBytes(values) {
|
|
var list = new _BinaryList["default"]();
|
|
|
|
for (var i = 0; i < values.length; i++) {
|
|
var s = DC.stringToBytes(values[i]);
|
|
list.addUint32(s.length).addUint8Array(s);
|
|
}
|
|
|
|
return list.toArray();
|
|
}
|
|
}, {
|
|
key: "uint16ArrayToBytes",
|
|
value: function uint16ArrayToBytes(values, endian) {
|
|
var rt = new DC(values.length * 2);
|
|
|
|
for (var i = 0; i < values.length; i++) {
|
|
rt.setUint16(i * 2, values[i], endian);
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "int16ArrayToBytes",
|
|
value: function int16ArrayToBytes(values, endian) {
|
|
var rt = new DC(values.length * 2);
|
|
|
|
for (var i = 0; i < values.length; i++) {
|
|
rt.setInt16(i * 2, values[i], endian);
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "uint32ArrayToBytes",
|
|
value: function uint32ArrayToBytes(values, endian) {
|
|
var rt = new DC(values.length * 4);
|
|
|
|
for (var i = 0; i < values.length; i++) {
|
|
rt.setUint32(i * 4, values[i], endian);
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "int32ArrayToBytes",
|
|
value: function int32ArrayToBytes(values, endian) {
|
|
var rt = new DC(values.length * 4);
|
|
|
|
for (var i = 0; i < values.length; i++) {
|
|
rt.setInt32(i * 4, values[i], endian);
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "int64ArrayToBytes",
|
|
value: function int64ArrayToBytes(values, endian) {
|
|
var rt = new DC(values.length * 8);
|
|
|
|
for (var i = 0; i < values.length; i++) {
|
|
rt.setInt64(i * 8, values[i], endian);
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "uint64ArrayToBytes",
|
|
value: function uint64ArrayToBytes(values, endian) {
|
|
var rt = new DC(values.length * 8);
|
|
|
|
for (var i = 0; i < values.length; i++) {
|
|
rt.setUint64(i * 8, values[i], endian);
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "float32ArrayToBytes",
|
|
value: function float32ArrayToBytes(values, endian) {
|
|
var rt = new DC(values.length * 4);
|
|
|
|
for (var i = 0; i < values.length; i++) {
|
|
rt.setFloat32(i * 4, values[i], endian);
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "float64ArrayToBytes",
|
|
value: function float64ArrayToBytes(values, endian) {
|
|
var rt = new DC(values.length * 8);
|
|
|
|
for (var i = 0; i < values.length; i++) {
|
|
rt.setFloat64(i * 8, values[i], endian);
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "combine",
|
|
value: function combine(a, aOffset, aLength, b, bOffset, bLength) {
|
|
if (!(a instanceof DC)) a = new DC(a);
|
|
if (!(b instanceof DC)) b = new DC(b);
|
|
a = a.clip(aOffset, aLength);
|
|
b = b.clip(bOffset, bLength);
|
|
var rt = new DC(a.length + b.length);
|
|
rt.set(a, 0);
|
|
rt.set(b, a.length);
|
|
return rt;
|
|
}
|
|
}]);
|
|
|
|
return DC;
|
|
}( /*#__PURE__*/_wrapNativeSuper(Uint8Array));
|
|
|
|
exports.DC = exports["default"] = DC;
|
|
|
|
function BL() {
|
|
return new _BinaryList["default"]();
|
|
}
|
|
|
|
;
|
|
|
|
},{"./BinaryList.js":13,"./Guid.js":20}],16:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = exports.PropertyValueParserResults = void 0;
|
|
|
|
var _IEnum = _interopRequireDefault(require("./IEnum.js"));
|
|
|
|
var _Tuple = _interopRequireDefault(require("./Tuple.js"));
|
|
|
|
var _TemplateType = _interopRequireDefault(require("../Resource/Template/TemplateType.js"));
|
|
|
|
var _Warehouse = _interopRequireDefault(require("../Resource/Warehouse.js"));
|
|
|
|
var _AsyncBag = _interopRequireDefault(require("../Core/AsyncBag.js"));
|
|
|
|
var _AsyncReply = _interopRequireDefault(require("../Core/AsyncReply.js"));
|
|
|
|
var _DC = _interopRequireDefault(require("./DC.js"));
|
|
|
|
var _DistributedConnection = _interopRequireDefault(require("../Net/IIP/DistributedConnection.js"));
|
|
|
|
var _NotModified = _interopRequireDefault(require("./NotModified.js"));
|
|
|
|
var _RepresentationType = _interopRequireDefault(require("./RepresentationType.js"));
|
|
|
|
var _Codec = _interopRequireDefault(require("./Codec.js"));
|
|
|
|
var _TypedMap = _interopRequireDefault(require("./TypedMap.js"));
|
|
|
|
var _PropertyValueArray = _interopRequireDefault(require("./PropertyValueArray.js"));
|
|
|
|
var _PropertyValue = _interopRequireDefault(require("./PropertyValue.js"));
|
|
|
|
var _Record = _interopRequireDefault(require("./Record.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
|
|
|
|
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
|
|
|
|
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
|
|
|
|
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
|
|
|
|
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
|
|
|
|
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var PropertyValueParserResults = //final int size;
|
|
///final AsyncReply<PropertyValue> reply;
|
|
function PropertyValueParserResults(size, reply) {
|
|
_classCallCheck(this, PropertyValueParserResults);
|
|
|
|
this.size = size;
|
|
this.reply = reply;
|
|
};
|
|
|
|
exports.PropertyValueParserResults = PropertyValueParserResults;
|
|
|
|
var DataDeserializer = /*#__PURE__*/function () {
|
|
function DataDeserializer() {
|
|
_classCallCheck(this, DataDeserializer);
|
|
}
|
|
|
|
_createClass(DataDeserializer, null, [{
|
|
key: "nullParser",
|
|
value: function nullParser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](null);
|
|
}
|
|
}, {
|
|
key: "booleanTrueParser",
|
|
value: function booleanTrueParser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](true);
|
|
}
|
|
}, {
|
|
key: "booleanFalseParser",
|
|
value: function booleanFalseParser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](false);
|
|
}
|
|
}, {
|
|
key: "notModifiedParser",
|
|
value: function notModifiedParser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"]((0, _NotModified["default"])());
|
|
}
|
|
}, {
|
|
key: "byteParser",
|
|
value: function byteParser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](data[offset]);
|
|
}
|
|
}, {
|
|
key: "sByteParser",
|
|
value: function sByteParser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](data[offset] > 127 ? data[offset] - 256 : data[offset]);
|
|
}
|
|
}, {
|
|
key: "char16Parser",
|
|
value: function char16Parser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](data.getChar(offset));
|
|
}
|
|
}, {
|
|
key: "char8Parser",
|
|
value: function char8Parser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](String.fromCharCode(data[offset]));
|
|
}
|
|
}, {
|
|
key: "int16Parser",
|
|
value: function int16Parser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](data.getInt16(offset));
|
|
}
|
|
}, {
|
|
key: "uInt16Parser",
|
|
value: function uInt16Parser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](data.getUint16(offset));
|
|
}
|
|
}, {
|
|
key: "int32Parser",
|
|
value: function int32Parser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](data.getInt32(offset));
|
|
}
|
|
}, {
|
|
key: "uInt32Parser",
|
|
value: function uInt32Parser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](data.getUint32(offset));
|
|
}
|
|
}, {
|
|
key: "float32Parser",
|
|
value: function float32Parser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](data.getFloat32(offset));
|
|
}
|
|
}, {
|
|
key: "float64Parser",
|
|
value: function float64Parser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](data.getFloat64(offset));
|
|
}
|
|
}, {
|
|
key: "float128Parser",
|
|
value: function float128Parser(data, offset, length, connection) {
|
|
// @TODO
|
|
return new _AsyncReply["default"](data.getFloat64(offset));
|
|
}
|
|
}, {
|
|
key: "int128Parser",
|
|
value: function int128Parser(data, offset, length, connection) {
|
|
// @TODO
|
|
return new _AsyncReply["default"](data.getInt64(offset));
|
|
}
|
|
}, {
|
|
key: "uInt128Parser",
|
|
value: function uInt128Parser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](data.getUint64(offset));
|
|
}
|
|
}, {
|
|
key: "int64Parser",
|
|
value: function int64Parser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](data.getInt64(offset));
|
|
}
|
|
}, {
|
|
key: "uInt64Parser",
|
|
value: function uInt64Parser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](data.getUint64(offset));
|
|
}
|
|
}, {
|
|
key: "dateTimeParser",
|
|
value: function dateTimeParser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](data.getDateTime(offset));
|
|
}
|
|
}, {
|
|
key: "resourceParser",
|
|
value: function resourceParser(data, offset, length, connection) {
|
|
if (connection != null) {
|
|
var id = data.getUint32(offset);
|
|
return connection.fetch(id);
|
|
}
|
|
|
|
throw Error("Can't parse resource with no connection");
|
|
}
|
|
}, {
|
|
key: "localResourceParser",
|
|
value: function localResourceParser(data, offset, length, connection) {
|
|
var id = data.getUint32(offset);
|
|
return _Warehouse["default"].getById(id);
|
|
}
|
|
}, {
|
|
key: "rawDataParser",
|
|
value: function rawDataParser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](data.clip(offset, length));
|
|
}
|
|
}, {
|
|
key: "stringParser",
|
|
value: function stringParser(data, offset, length, connection) {
|
|
return new _AsyncReply["default"](data.getString(offset, length));
|
|
}
|
|
}, {
|
|
key: "recordParser",
|
|
value: function recordParser(data, offset, length, connection) {
|
|
var reply = new _AsyncReply["default"]();
|
|
var classId = data.getGuid(offset);
|
|
offset += 16;
|
|
length -= 16;
|
|
|
|
var template = _Warehouse["default"].getTemplateByClassId(classId, _TemplateType["default"].Record);
|
|
|
|
if (template != null) {
|
|
listParser(data, offset, length, connection).then(function (ar) {
|
|
var record;
|
|
|
|
if (template.definedType != null) {
|
|
record = _Warehouse["default"].createInstance(template.definedType);
|
|
} else {
|
|
record = (0, _Record["default"])();
|
|
}
|
|
|
|
var kv = new Map();
|
|
|
|
for (var i = 0; i < template.properties.length; i++) {
|
|
kv[template.properties[i].name] = ar[i];
|
|
}
|
|
|
|
record.deserialize(kv);
|
|
reply.trigger(record);
|
|
});
|
|
} else {
|
|
if (connection == null) throw Error("Can't parse record with no connection");
|
|
connection.getTemplate(classId).then(function (tmp) {
|
|
if (tmp == null) reply.triggerError(new Error("Couldn't fetch record template."));
|
|
DataDeserializer.listParser(data, offset, length, connection).then(function (ar) {
|
|
var record = new _Record["default"](); //var kv = new Map();
|
|
|
|
for (var i = 0; i < tmp.properties.length; i++) {
|
|
record[tmp.properties[i].name] = ar[i];
|
|
} //record.deserialize(kv);
|
|
|
|
|
|
reply.trigger(record);
|
|
});
|
|
}).error(function (x) {
|
|
return reply.triggerError(x);
|
|
});
|
|
}
|
|
|
|
return reply;
|
|
}
|
|
}, {
|
|
key: "constantParser",
|
|
value: function constantParser(data, offset, length, connection) {
|
|
throw Error("NotImplementedException");
|
|
}
|
|
}, {
|
|
key: "enumParser",
|
|
value: function enumParser(data, offset, length, connection) {
|
|
var classId = data.getGuid(offset);
|
|
offset += 16;
|
|
var index = data[offset++];
|
|
|
|
var template = _Warehouse["default"].getTemplateByClassId(classId, _TemplateType["default"].Enum);
|
|
|
|
if (template != null) {
|
|
if (template.definedType != null) {
|
|
var enumVal = _Warehouse["default"].createInstance(template.definedType);
|
|
|
|
enumVal.index = index;
|
|
enumVal.name = template.constants[index].name;
|
|
enumVal.value = template.constants[index].value;
|
|
return new _AsyncReply["default"].ready(enumVal);
|
|
} else {
|
|
return _AsyncReply["default"].ready((0, _IEnum["default"])(index, template.constants[index].value, template.constants[index].name));
|
|
}
|
|
} else {
|
|
var reply = new _AsyncReply["default"]();
|
|
if (connection == null) throw Error("Can't parse enum with no connection");
|
|
connection.getTemplate(classId).then(function (tmp) {
|
|
if (tmp != null) {
|
|
if (tmp.definedType != null) {
|
|
var enumVal = _Warehouse["default"].createInstance(tmp.definedType);
|
|
|
|
enumVal.index = index;
|
|
enumVal.name = tmp.constants[index].name;
|
|
enumVal.value = tmp.constants[index].value;
|
|
reply.trigger(enumVal);
|
|
} else {
|
|
reply.trigger(new _IEnum["default"](index, tmp.constants[index].value, tmp.constants[index].name));
|
|
}
|
|
} else reply.triggerError(new Error("Template not found for enum"));
|
|
}).error(function (x) {
|
|
return reply.triggerError(x);
|
|
});
|
|
return reply;
|
|
}
|
|
}
|
|
}, {
|
|
key: "recordListParser",
|
|
value: function recordListParser(data, offset, length, connection) {
|
|
var rt = new _AsyncBag["default"]();
|
|
|
|
while (length > 0) {
|
|
var parsed = _Codec["default"].parse(data, offset, connection);
|
|
|
|
rt.add(parsed.reply);
|
|
|
|
if (parsed.size > 0) {
|
|
offset += parsed.size;
|
|
length -= parsed.size;
|
|
} else throw new Error("Error while parsing structured data");
|
|
}
|
|
|
|
rt.seal();
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "resourceListParser",
|
|
value: function resourceListParser(data, offset, length, connection) {
|
|
var rt = new _AsyncBag["default"]();
|
|
|
|
while (length > 0) {
|
|
var parsed = _Codec["default"].parse(data, offset, connection);
|
|
|
|
rt.add(parsed.reply);
|
|
|
|
if (parsed.size > 0) {
|
|
offset += parsed.size;
|
|
length -= parsed.size;
|
|
} else throw new Error("Error while parsing structured data");
|
|
}
|
|
|
|
rt.seal();
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "listParser",
|
|
value: function listParser(data, offset, length, connection) {
|
|
var rt = new _AsyncBag["default"]();
|
|
|
|
while (length > 0) {
|
|
var parsed = _Codec["default"].parse(data, offset, connection);
|
|
|
|
rt.add(parsed.reply);
|
|
|
|
if (parsed.size > 0) {
|
|
offset += parsed.size;
|
|
length -= parsed.size;
|
|
} else throw new Error("Error while parsing structured data");
|
|
}
|
|
|
|
rt.seal();
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "typedMapParser",
|
|
value: function typedMapParser(data, offset, length, connection) {
|
|
// get key type
|
|
var keyRep = _RepresentationType["default"].parse(data, offset);
|
|
|
|
offset += keyRep.size;
|
|
length -= keyRep.size;
|
|
|
|
var valueRep = _RepresentationType["default"].parse(data, offset);
|
|
|
|
offset += valueRep.size;
|
|
length -= valueRep.size;
|
|
var map = new _TypedMap["default"]();
|
|
var rt = new _AsyncReply["default"]();
|
|
var results = new _AsyncBag["default"]();
|
|
|
|
while (length > 0) {
|
|
var parsed = _Codec["default"].parse(data, offset, connection);
|
|
|
|
results.add(parsed.reply);
|
|
|
|
if (parsed.size > 0) {
|
|
offset += parsed.size;
|
|
length -= parsed.size;
|
|
} else throw new Error("Error while parsing structured data");
|
|
}
|
|
|
|
results.seal();
|
|
results.then(function (ar) {
|
|
for (var i = 0; i < ar.length; i += 2) {
|
|
map.set(ar[i], ar[i + 1]);
|
|
}
|
|
|
|
rt.trigger(map);
|
|
});
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "tupleParser",
|
|
value: function tupleParser(data, offset, length, connection) {
|
|
var results = new _AsyncBag["default"]();
|
|
var rt = new _AsyncReply["default"]();
|
|
var tupleSize = data[offset++];
|
|
length--;
|
|
var types = [];
|
|
|
|
for (var i = 0; i < tupleSize; i++) {
|
|
var _rep$type$getRuntimeT;
|
|
|
|
var rep = _RepresentationType["default"].parse(data, offset);
|
|
|
|
if (rep.type != null) types.push((_rep$type$getRuntimeT = rep.type.getRuntimeType()) !== null && _rep$type$getRuntimeT !== void 0 ? _rep$type$getRuntimeT : Object);
|
|
offset += rep.size;
|
|
length -= rep.size;
|
|
}
|
|
|
|
while (length > 0) {
|
|
var parsed = _Codec["default"].parse(data, offset, connection);
|
|
|
|
results.add(parsed.reply);
|
|
|
|
if (parsed.size > 0) {
|
|
offset += parsed.size;
|
|
length -= parsed.size;
|
|
} else throw new Error("Error while parsing structured data");
|
|
}
|
|
|
|
results.seal();
|
|
results.then(function (ar) {
|
|
rt.trigger(_construct(_Tuple["default"].of.apply(_Tuple["default"], types), _toConsumableArray(ar)));
|
|
});
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "typedListParser",
|
|
value: function typedListParser(data, offset, length, connection) {
|
|
var rt = new _AsyncBag["default"](); // get the type
|
|
|
|
var rep = _RepresentationType["default"].parse(data, offset);
|
|
|
|
offset += rep.size;
|
|
length -= rep.size;
|
|
var runtimeType = rep.type.getRuntimeType();
|
|
rt.arrayType = runtimeType;
|
|
|
|
while (length > 0) {
|
|
var parsed = _Codec["default"].parse(data, offset, connection);
|
|
|
|
rt.add(parsed.reply);
|
|
|
|
if (parsed.size > 0) {
|
|
offset += parsed.size;
|
|
length -= parsed.size;
|
|
} else throw new Error("Error while parsing structured data");
|
|
}
|
|
|
|
rt.seal();
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "PropertyValueArrayParser",
|
|
value: function PropertyValueArrayParser(data, offset, length, connection) //, bool ageIncluded = true)
|
|
{
|
|
var rt = new _AsyncBag["default"]();
|
|
DataDeserializer.listParser(data, offset, length, connection).then(function (x) {
|
|
var pvs = new _PropertyValueArray["default"]();
|
|
|
|
for (var i = 0; i < x.length; i += 3) {
|
|
pvs.push(new _PropertyValue["default"](x[2], x[0], x[1]));
|
|
}
|
|
|
|
rt.trigger(pvs);
|
|
});
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "propertyValueParser",
|
|
value: function propertyValueParser(data, offset, connection) //, bool ageIncluded = true)
|
|
{
|
|
var reply = new _AsyncReply["default"]();
|
|
var age = data.getUint64(offset);
|
|
offset += 8;
|
|
var date = data.getDateTime(offset);
|
|
offset += 8;
|
|
|
|
var parsed = _Codec["default"].parse(data, offset, connection);
|
|
|
|
parsed.reply.then(function (value) {
|
|
reply.trigger(new _PropertyValue["default"](value, age, date));
|
|
});
|
|
return new PropertyValueParserResults(16 + parsed.size, reply);
|
|
}
|
|
}, {
|
|
key: "historyParser",
|
|
value: function historyParser(data, offset, length, resource, connection) {
|
|
throw new Error("Not implemented"); // @TODO
|
|
// var list = new KeyList<PropertyTemplate, List<PropertyValue>>();
|
|
// var reply = new AsyncReply<KeyList<PropertyTemplate, List<PropertyValue[]>>>();
|
|
// var bagOfBags = new AsyncBag<PropertyValue[]>();
|
|
// var ends = offset + length;
|
|
// while (offset < ends)
|
|
// {
|
|
// var index = data[offset++];
|
|
// var pt = resource.Instance.Template.GetPropertyTemplateByIndex(index);
|
|
// list.Add(pt, null);
|
|
// var cs = data.GetUInt32(offset);
|
|
// offset += 4;
|
|
// var (len, pv) = PropertyValueParser(data, offset, connection);
|
|
// bagOfBags.Add(pv);// ParsePropertyValueArray(data, offset, cs, connection));
|
|
// offset += len;
|
|
// }
|
|
// bagOfBags.Seal();
|
|
// bagOfBags.Then(x =>
|
|
// {
|
|
// for (var i = 0; i < list.Count; i++)
|
|
// list[list.Keys.ElementAt(i)] = x[i];
|
|
// reply.Trigger(list);
|
|
// });
|
|
// return reply;
|
|
}
|
|
}]);
|
|
|
|
return DataDeserializer;
|
|
}();
|
|
|
|
exports["default"] = DataDeserializer;
|
|
|
|
},{"../Core/AsyncBag.js":2,"../Core/AsyncReply.js":5,"../Net/IIP/DistributedConnection.js":42,"../Resource/Template/TemplateType.js":82,"../Resource/Warehouse.js":84,"./Codec.js":14,"./DC.js":15,"./IEnum.js":21,"./NotModified.js":24,"./PropertyValue.js":26,"./PropertyValueArray.js":27,"./Record.js":28,"./RepresentationType.js":31,"./Tuple.js":39,"./TypedMap.js":41}],17:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = exports.DataSerializerComposeResults = void 0;
|
|
|
|
var _BinaryList = _interopRequireDefault(require("./BinaryList.js"));
|
|
|
|
var _Codec = _interopRequireDefault(require("./Codec.js"));
|
|
|
|
var _Warehouse = _interopRequireDefault(require("../Resource/Warehouse.js"));
|
|
|
|
var _TransmissionType = require("./TransmissionType.js");
|
|
|
|
var _DC = _interopRequireWildcard(require("./DC.js"));
|
|
|
|
var _RepresentationType = _interopRequireDefault(require("./RepresentationType.js"));
|
|
|
|
var _Tuple = _interopRequireDefault(require("./Tuple.js"));
|
|
|
|
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
|
|
|
|
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
|
|
|
|
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
|
|
|
|
function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
|
|
|
|
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
|
|
|
|
function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
|
|
|
|
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
|
|
|
|
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var DataSerializerComposeResults = // int identifier;
|
|
//DC data;
|
|
function DataSerializerComposeResults(identifier, data) {
|
|
_classCallCheck(this, DataSerializerComposeResults);
|
|
|
|
this.identifier = identifier;
|
|
this.data = data;
|
|
};
|
|
|
|
exports.DataSerializerComposeResults = DataSerializerComposeResults;
|
|
|
|
var DataSerializer = /*#__PURE__*/function () {
|
|
function DataSerializer() {
|
|
_classCallCheck(this, DataSerializer);
|
|
}
|
|
|
|
_createClass(DataSerializer, null, [{
|
|
key: "historyComposer",
|
|
value: //public delegate byte[] Serializer(object value);
|
|
function historyComposer(history, connection) {
|
|
var prependLength = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
|
|
throw new Error("Not implemented");
|
|
}
|
|
}, {
|
|
key: "int32Composer",
|
|
value: function int32Composer(value, connection) {
|
|
var rt = new _DC["default"](4);
|
|
rt.setInt32(0, value);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Int32, rt);
|
|
}
|
|
}, {
|
|
key: "uInt32Composer",
|
|
value: function uInt32Composer(value, connection) {
|
|
var rt = new _DC["default"](4);
|
|
rt.setUint32(0, value);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.UInt32, rt);
|
|
}
|
|
}, {
|
|
key: "int16Composer",
|
|
value: function int16Composer(value, connection) {
|
|
var rt = new _DC["default"](2);
|
|
rt.setInt16(0, value);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Int16, rt);
|
|
}
|
|
}, {
|
|
key: "uInt16Composer",
|
|
value: function uInt16Composer(value, connection) {
|
|
var rt = new _DC["default"](2);
|
|
rt.setUint16(0, value);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.UInt16, rt);
|
|
}
|
|
}, {
|
|
key: "float32Composer",
|
|
value: function float32Composer(value, connection) {
|
|
var rt = new _DC["default"](4);
|
|
rt.setFloat32(0, value);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Float32, rt);
|
|
}
|
|
}, {
|
|
key: "float64Composer",
|
|
value: function float64Composer(value, connection) {
|
|
var rt = new _DC["default"](8);
|
|
rt.setFloat64(0, value);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Float64, rt);
|
|
}
|
|
}, {
|
|
key: "int64Composer",
|
|
value: function int64Composer(value, connection) {
|
|
var rt = new _DC["default"](8);
|
|
rt.setInt64(0, value);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Int64, rt);
|
|
}
|
|
}, {
|
|
key: "numberComposer",
|
|
value: function numberComposer(value, connection) {
|
|
var rt = new _DC["default"](8);
|
|
|
|
if (Number.isInteger(value)) {
|
|
rt.setInt64(0, value);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Int64, rt);
|
|
} else {
|
|
rt.setFloat64(0, value);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Float64, rt);
|
|
}
|
|
}
|
|
}, {
|
|
key: "uInt64Composer",
|
|
value: function uInt64Composer(value, connection) {
|
|
var rt = new _DC["default"](8);
|
|
rt.setUint64(0, value);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.UInt64, rt);
|
|
}
|
|
}, {
|
|
key: "dateTimeComposer",
|
|
value: function dateTimeComposer(value, connection) {
|
|
var rt = new _DC["default"](8);
|
|
rt.setDateTime(0, value);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.DateTime, rt);
|
|
}
|
|
}, {
|
|
key: "float128Composer",
|
|
value: function float128Composer(value, connection) {
|
|
//@TODO: implement decimal
|
|
var rt = new _DC["default"](16);
|
|
rt.setFloat64(0, value);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Float64, rt);
|
|
}
|
|
}, {
|
|
key: "stringComposer",
|
|
value: function stringComposer(value, connection) {
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.String, _DC["default"].stringToBytes(value));
|
|
}
|
|
}, {
|
|
key: "enumComposer",
|
|
value: function enumComposer(value, connection) {
|
|
if (value == null) return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Null, new _DC["default"](0));
|
|
|
|
var template = _Warehouse["default"].getTemplateByType(value.runtimeType);
|
|
|
|
if (template == null) return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Null, new _DC["default"](0));
|
|
var cts = template.constants.where(function (x) {
|
|
return x.value == value;
|
|
});
|
|
if (cts.isEmpty) return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Null, new _DC["default"](0));
|
|
var rt = (0, _BinaryList["default"])();
|
|
rt.addGuid(template.classId);
|
|
rt.addUint8(cts.first.index);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Enum, rt.toDC());
|
|
}
|
|
}, {
|
|
key: "uInt8Composer",
|
|
value: function uInt8Composer(value, connection) {
|
|
var rt = new _DC["default"](1);
|
|
rt[0] = value;
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.UInt8, rt);
|
|
}
|
|
}, {
|
|
key: "int8Composer",
|
|
value: function int8Composer(value, connection) {
|
|
var rt = new _DC["default"](1);
|
|
rt[0] = value;
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Int8, rt);
|
|
}
|
|
}, {
|
|
key: "char8Composer",
|
|
value: function char8Composer(value, connection) {
|
|
var rt = new _DC["default"](1);
|
|
rt[0] = value;
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Char8, rt);
|
|
}
|
|
}, {
|
|
key: "char16Composer",
|
|
value: function char16Composer(value, connection) {
|
|
var rt = new _DC["default"](2);
|
|
rt.setUint16(0, value);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Char16, rt);
|
|
}
|
|
}, {
|
|
key: "boolComposer",
|
|
value: function boolComposer(value, connection) {
|
|
return new DataSerializerComposeResults(value ? _TransmissionType.TransmissionTypeIdentifier.True : _TransmissionType.TransmissionTypeIdentifier.False, new _DC["default"](0));
|
|
}
|
|
}, {
|
|
key: "notModifiedComposer",
|
|
value: function notModifiedComposer(value, connection) {
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.NotModified, new _DC["default"](0));
|
|
}
|
|
}, {
|
|
key: "rawDataComposer",
|
|
value: function rawDataComposer(value, connection) {
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.RawData, value);
|
|
}
|
|
}, {
|
|
key: "listComposer",
|
|
value: function listComposer(value, connection) {
|
|
if (value == null) return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Null, new _DC["default"](0));else return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.List, DataSerializer.arrayComposer(value, connection)); //var rt = new List<byte>();
|
|
//var list = (IEnumerable)value;// ((List<object>)value);
|
|
//foreach (var o in list)
|
|
// rt.AddRange(Codec.Compose(o, connection));
|
|
//return (TransmissionTypeIdentifier.List, rt.ToArray());
|
|
}
|
|
}, {
|
|
key: "typedListComposer",
|
|
value: function typedListComposer(value, type, connection) {
|
|
var _RepresentationType$f;
|
|
|
|
if (value == null) return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Null, new _DC["default"](0));
|
|
var composed = DataSerializer.arrayComposer(value, connection);
|
|
var header = ((_RepresentationType$f = _RepresentationType["default"].fromType(type)) !== null && _RepresentationType$f !== void 0 ? _RepresentationType$f : _RepresentationType["default"].Dynamic).compose();
|
|
var rt = new _BinaryList["default"]().addDC(header).addDC(composed);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.TypedList, rt.toDC());
|
|
}
|
|
}, {
|
|
key: "propertyValueArrayComposer",
|
|
value: function propertyValueArrayComposer(value, connection) {
|
|
if (value == null) return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Null, new _DC["default"](0));
|
|
var rt = (0, _DC.BL)();
|
|
|
|
for (var i = 0; i < value.length; i++) {
|
|
rt.addDC(_Codec["default"].compose(value[i].age, connection));
|
|
rt.addDC(_Codec["default"].compose(value[i].date, connection));
|
|
rt.addDC(_Codec["default"].compose(value[i].value, connection));
|
|
}
|
|
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.List, rt.toDC());
|
|
}
|
|
}, {
|
|
key: "typedMapComposer",
|
|
value: function typedMapComposer(value, keyType, valueType, connection) {
|
|
var _RepresentationType$f2, _RepresentationType$f3;
|
|
|
|
if (value == null) return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Null, new _DC["default"](0));
|
|
var kt = ((_RepresentationType$f2 = _RepresentationType["default"].fromType(keyType)) !== null && _RepresentationType$f2 !== void 0 ? _RepresentationType$f2 : _RepresentationType["default"].Dynamic).compose();
|
|
var vt = ((_RepresentationType$f3 = _RepresentationType["default"].fromType(valueType)) !== null && _RepresentationType$f3 !== void 0 ? _RepresentationType$f3 : _RepresentationType["default"].Dynamic).compose();
|
|
var rt = new _BinaryList["default"]();
|
|
rt.addDC(kt);
|
|
rt.addDC(vt); //@TODO
|
|
|
|
var _iterator = _createForOfIteratorHelper(value),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var _step$value = _slicedToArray(_step.value, 2),
|
|
k = _step$value[0],
|
|
v = _step$value[1];
|
|
|
|
rt.addDC(_Codec["default"].compose(k, connection));
|
|
rt.addDC(_Codec["default"].compose(v, connection));
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.TypedMap, rt.toDC());
|
|
}
|
|
}, {
|
|
key: "arrayComposer",
|
|
value: function arrayComposer(value, connection) {
|
|
var rt = new _BinaryList["default"]();
|
|
|
|
var _iterator2 = _createForOfIteratorHelper(value),
|
|
_step2;
|
|
|
|
try {
|
|
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
|
|
var i = _step2.value;
|
|
rt.addDC(_Codec["default"].compose(i, connection));
|
|
}
|
|
} catch (err) {
|
|
_iterator2.e(err);
|
|
} finally {
|
|
_iterator2.f();
|
|
}
|
|
|
|
return rt.toDC();
|
|
}
|
|
}, {
|
|
key: "resourceListComposer",
|
|
value: function resourceListComposer(value, connection) {
|
|
if (value == null) return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Null, new _DC["default"](0));
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.ResourceList, DataSerializer.arrayComposer(value, connection));
|
|
}
|
|
}, {
|
|
key: "recordListComposer",
|
|
value: function recordListComposer(value, connection) {
|
|
if (value == null) return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Null, new _DC["default"](0));
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.RecordList, DataSerializer.arrayComposer(value, connection));
|
|
}
|
|
}, {
|
|
key: "resourceComposer",
|
|
value: function resourceComposer(value, connection) {
|
|
var resource = value;
|
|
var rt = new _DC["default"](4);
|
|
|
|
if (_Codec["default"].isLocalResource(resource, connection)) {
|
|
var _resource$id;
|
|
|
|
rt.setUint32(0, (_resource$id = resource.id) !== null && _resource$id !== void 0 ? _resource$id : 0);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.ResourceLocal, rt);
|
|
} else {
|
|
var _resource$instance$id, _resource$instance;
|
|
|
|
// @TODO: connection.cache.Add(value as IResource, DateTime.UtcNow);
|
|
rt.setUint32(0, (_resource$instance$id = (_resource$instance = resource.instance) === null || _resource$instance === void 0 ? void 0 : _resource$instance.id) !== null && _resource$instance$id !== void 0 ? _resource$instance$id : 0);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Resource, rt);
|
|
}
|
|
}
|
|
}, {
|
|
key: "mapComposer",
|
|
value: function mapComposer(value, connection) {
|
|
if (value == null) return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Null, new _DC["default"](0));
|
|
var rt = (0, _BinaryList["default"])();
|
|
|
|
for (var el in value) {
|
|
rt.addDC(_Codec["default"].compose(el.key, connection));
|
|
rt.addDC(_Codec["default"].compose(el.value, connection));
|
|
}
|
|
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Map, rt.toDC());
|
|
}
|
|
}, {
|
|
key: "recordComposer",
|
|
value: function recordComposer(value, connection) {
|
|
var rt = (0, _BinaryList["default"])();
|
|
|
|
var template = _Warehouse["default"].getTemplateByType(value.runtimeType);
|
|
|
|
if (template == null) return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Null, new _DC["default"](0));
|
|
rt.addDC(_DC["default"].guidToBytes(template.classId));
|
|
var recordData = value.serialize();
|
|
|
|
for (var pt in template.properties) {
|
|
var propValue = recordData[pt.name];
|
|
rt.addDC(_Codec["default"].compose(propValue, connection));
|
|
}
|
|
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Record, rt.toDC());
|
|
} // TODO:
|
|
// static DataSerializerComposeResults historyComposer(KeyList<PropertyTemplate, PropertyValue[]> history,
|
|
// DistributedConnection connection, bool prependLength = false)
|
|
// {
|
|
// //@TODO:Test
|
|
// var rt = new BinaryList();
|
|
// for (var i = 0; i < history.Count; i++)
|
|
// rt.AddUInt8(history.Keys.ElementAt(i).Index)
|
|
// .AddUInt8Array(Codec.Compose(history.Values.ElementAt(i), connection));
|
|
// if (prependLength)
|
|
// rt.InsertInt32(0, rt.Length);
|
|
// return rt.ToArray();
|
|
// }
|
|
|
|
}, {
|
|
key: "tupleComposer",
|
|
value: function tupleComposer(value, connection) {
|
|
if (value == null) return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Null, new _DC["default"](0));
|
|
var rt = (0, _DC.BL)();
|
|
|
|
var fields = _Tuple["default"].getTypes(value);
|
|
|
|
var types = fields.map(function (x) {
|
|
return _RepresentationType["default"].fromType(x).compose();
|
|
});
|
|
rt.Add(value.length);
|
|
|
|
var _iterator3 = _createForOfIteratorHelper(types),
|
|
_step3;
|
|
|
|
try {
|
|
for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
|
|
var t = _step3.value;
|
|
rt.addUint8Array(t);
|
|
}
|
|
} catch (err) {
|
|
_iterator3.e(err);
|
|
} finally {
|
|
_iterator3.f();
|
|
}
|
|
|
|
var composed = DataSerializer.arrayComposer(value, connection);
|
|
if (composed == null) return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Null, new _DC["default"](0));else {
|
|
rt.addUint8Array(composed);
|
|
return new DataSerializerComposeResults(_TransmissionType.TransmissionTypeIdentifier.Tuple, rt.toArray());
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return DataSerializer;
|
|
}();
|
|
|
|
exports["default"] = DataSerializer;
|
|
|
|
},{"../Resource/Warehouse.js":84,"./BinaryList.js":13,"./Codec.js":14,"./DC.js":15,"./RepresentationType.js":31,"./TransmissionType.js":38,"./Tuple.js":39}],18:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 25/07/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
var _default = {
|
|
Void: 0x0,
|
|
//Variant,
|
|
Bool: 1,
|
|
Int8: 2,
|
|
UInt8: 3,
|
|
Char: 4,
|
|
Int16: 5,
|
|
UInt16: 6,
|
|
Int32: 7,
|
|
UInt32: 8,
|
|
Int64: 9,
|
|
UInt64: 10,
|
|
Float32: 11,
|
|
Float64: 12,
|
|
Decimal: 13,
|
|
DateTime: 14,
|
|
Resource: 15,
|
|
DistributedResource: 16,
|
|
ResourceLink: 17,
|
|
String: 18,
|
|
Structure: 19,
|
|
Record: 20,
|
|
//Stream,
|
|
//Array = 0x80,
|
|
VarArray: 0x80,
|
|
BoolArray: 0x81,
|
|
Int8Array: 0x82,
|
|
UInt8Array: 0x83,
|
|
CharArray: 0x84,
|
|
Int16Array: 0x85,
|
|
UInt16Array: 0x86,
|
|
Int32Array: 0x87,
|
|
UInt32Array: 0x88,
|
|
Int64Array: 0x89,
|
|
UInt64Array: 0x8A,
|
|
Float32Array: 0x8B,
|
|
Float64Array: 0x8C,
|
|
DecimalArray: 0x8D,
|
|
DateTimeArray: 0x8E,
|
|
ResourceArray: 0x8F,
|
|
DistributedResourceArray: 0x90,
|
|
ResourceLinkArray: 0x91,
|
|
StringArray: 0x92,
|
|
StructureArray: 0x93,
|
|
RecordArray: 0x94,
|
|
NotModified: 0x7f,
|
|
Unspecified: 0xff,
|
|
isArray: function isArray(type) {
|
|
return (type & 0x80) == 0x80 && type != this.NotModified;
|
|
},
|
|
sizeOf: function sizeOf(type) {
|
|
switch (type) {
|
|
case this.Void:
|
|
case this.NotModified:
|
|
return 0;
|
|
|
|
case this.Bool:
|
|
case this.Int8:
|
|
case this.UInt8:
|
|
return 1;
|
|
|
|
case this.Char:
|
|
case this.Int16:
|
|
case this.UInt16:
|
|
return 2;
|
|
|
|
case this.Int32:
|
|
case this.UInt32:
|
|
case this.Float32:
|
|
case this.Resource:
|
|
return 4;
|
|
|
|
case this.Int64:
|
|
case this.UInt64:
|
|
case this.Float64:
|
|
case this.DateTime:
|
|
return 8;
|
|
|
|
case this.DistributedResource:
|
|
return 4;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
}
|
|
};
|
|
exports["default"] = _default;
|
|
|
|
},{}],19:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.Char8 = exports.Char16 = exports.Float128 = exports.Float64 = exports.Float32 = exports.UInt8 = exports.UInt16 = exports.UInt32 = exports.UInt64 = exports.UInt128 = exports.Int8 = exports.Int16 = exports.Int32 = exports.Int64 = exports.Int128 = void 0;
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
|
|
|
|
function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
|
|
|
|
function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
|
|
|
|
function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
var Num = /*#__PURE__*/function (_Number) {
|
|
_inherits(Num, _Number);
|
|
|
|
var _super = _createSuper(Num);
|
|
|
|
function Num(value) {
|
|
_classCallCheck(this, Num);
|
|
|
|
return _super.call(this, value);
|
|
}
|
|
|
|
_createClass(Num, [{
|
|
key: "toString",
|
|
value: function toString() {
|
|
return _get(_getPrototypeOf(Num.prototype), "toString", this).call(this);
|
|
}
|
|
}]);
|
|
|
|
return Num;
|
|
}( /*#__PURE__*/_wrapNativeSuper(Number));
|
|
|
|
var Int128 = /*#__PURE__*/function (_Num) {
|
|
_inherits(Int128, _Num);
|
|
|
|
var _super2 = _createSuper(Int128);
|
|
|
|
function Int128() {
|
|
_classCallCheck(this, Int128);
|
|
|
|
return _super2.apply(this, arguments);
|
|
}
|
|
|
|
return Int128;
|
|
}(Num);
|
|
|
|
exports.Int128 = Int128;
|
|
|
|
var Int64 = /*#__PURE__*/function (_Num2) {
|
|
_inherits(Int64, _Num2);
|
|
|
|
var _super3 = _createSuper(Int64);
|
|
|
|
function Int64() {
|
|
_classCallCheck(this, Int64);
|
|
|
|
return _super3.apply(this, arguments);
|
|
}
|
|
|
|
return Int64;
|
|
}(Num);
|
|
|
|
exports.Int64 = Int64;
|
|
|
|
var Int32 = /*#__PURE__*/function (_Num3) {
|
|
_inherits(Int32, _Num3);
|
|
|
|
var _super4 = _createSuper(Int32);
|
|
|
|
function Int32() {
|
|
_classCallCheck(this, Int32);
|
|
|
|
return _super4.apply(this, arguments);
|
|
}
|
|
|
|
return Int32;
|
|
}(Num);
|
|
|
|
exports.Int32 = Int32;
|
|
|
|
var Int16 = /*#__PURE__*/function (_Num4) {
|
|
_inherits(Int16, _Num4);
|
|
|
|
var _super5 = _createSuper(Int16);
|
|
|
|
function Int16() {
|
|
_classCallCheck(this, Int16);
|
|
|
|
return _super5.apply(this, arguments);
|
|
}
|
|
|
|
return Int16;
|
|
}(Num);
|
|
|
|
exports.Int16 = Int16;
|
|
|
|
var Int8 = /*#__PURE__*/function (_Num5) {
|
|
_inherits(Int8, _Num5);
|
|
|
|
var _super6 = _createSuper(Int8);
|
|
|
|
function Int8() {
|
|
_classCallCheck(this, Int8);
|
|
|
|
return _super6.apply(this, arguments);
|
|
}
|
|
|
|
return Int8;
|
|
}(Num);
|
|
|
|
exports.Int8 = Int8;
|
|
|
|
var UInt128 = /*#__PURE__*/function (_Num6) {
|
|
_inherits(UInt128, _Num6);
|
|
|
|
var _super7 = _createSuper(UInt128);
|
|
|
|
function UInt128() {
|
|
_classCallCheck(this, UInt128);
|
|
|
|
return _super7.apply(this, arguments);
|
|
}
|
|
|
|
return UInt128;
|
|
}(Num);
|
|
|
|
exports.UInt128 = UInt128;
|
|
|
|
var UInt64 = /*#__PURE__*/function (_Num7) {
|
|
_inherits(UInt64, _Num7);
|
|
|
|
var _super8 = _createSuper(UInt64);
|
|
|
|
function UInt64() {
|
|
_classCallCheck(this, UInt64);
|
|
|
|
return _super8.apply(this, arguments);
|
|
}
|
|
|
|
return UInt64;
|
|
}(Num);
|
|
|
|
exports.UInt64 = UInt64;
|
|
|
|
var UInt32 = /*#__PURE__*/function (_Num8) {
|
|
_inherits(UInt32, _Num8);
|
|
|
|
var _super9 = _createSuper(UInt32);
|
|
|
|
function UInt32() {
|
|
_classCallCheck(this, UInt32);
|
|
|
|
return _super9.apply(this, arguments);
|
|
}
|
|
|
|
return UInt32;
|
|
}(Num);
|
|
|
|
exports.UInt32 = UInt32;
|
|
|
|
var UInt16 = /*#__PURE__*/function (_Num9) {
|
|
_inherits(UInt16, _Num9);
|
|
|
|
var _super10 = _createSuper(UInt16);
|
|
|
|
function UInt16() {
|
|
_classCallCheck(this, UInt16);
|
|
|
|
return _super10.apply(this, arguments);
|
|
}
|
|
|
|
return UInt16;
|
|
}(Num);
|
|
|
|
exports.UInt16 = UInt16;
|
|
|
|
var UInt8 = /*#__PURE__*/function (_Num10) {
|
|
_inherits(UInt8, _Num10);
|
|
|
|
var _super11 = _createSuper(UInt8);
|
|
|
|
function UInt8() {
|
|
_classCallCheck(this, UInt8);
|
|
|
|
return _super11.apply(this, arguments);
|
|
}
|
|
|
|
return UInt8;
|
|
}(Num);
|
|
|
|
exports.UInt8 = UInt8;
|
|
|
|
var Float32 = /*#__PURE__*/function (_Num11) {
|
|
_inherits(Float32, _Num11);
|
|
|
|
var _super12 = _createSuper(Float32);
|
|
|
|
function Float32() {
|
|
_classCallCheck(this, Float32);
|
|
|
|
return _super12.apply(this, arguments);
|
|
}
|
|
|
|
return Float32;
|
|
}(Num);
|
|
|
|
exports.Float32 = Float32;
|
|
|
|
var Float64 = /*#__PURE__*/function (_Num12) {
|
|
_inherits(Float64, _Num12);
|
|
|
|
var _super13 = _createSuper(Float64);
|
|
|
|
function Float64() {
|
|
_classCallCheck(this, Float64);
|
|
|
|
return _super13.apply(this, arguments);
|
|
}
|
|
|
|
return Float64;
|
|
}(Num);
|
|
|
|
exports.Float64 = Float64;
|
|
|
|
var Float128 = /*#__PURE__*/function (_Num13) {
|
|
_inherits(Float128, _Num13);
|
|
|
|
var _super14 = _createSuper(Float128);
|
|
|
|
function Float128() {
|
|
_classCallCheck(this, Float128);
|
|
|
|
return _super14.apply(this, arguments);
|
|
}
|
|
|
|
return Float128;
|
|
}(Num);
|
|
|
|
exports.Float128 = Float128;
|
|
|
|
var Char16 = /*#__PURE__*/function (_String) {
|
|
_inherits(Char16, _String);
|
|
|
|
var _super15 = _createSuper(Char16);
|
|
|
|
function Char16() {
|
|
_classCallCheck(this, Char16);
|
|
|
|
return _super15.apply(this, arguments);
|
|
}
|
|
|
|
return Char16;
|
|
}( /*#__PURE__*/_wrapNativeSuper(String));
|
|
|
|
exports.Char16 = Char16;
|
|
|
|
var Char8 = /*#__PURE__*/function (_String2) {
|
|
_inherits(Char8, _String2);
|
|
|
|
var _super16 = _createSuper(Char8);
|
|
|
|
function Char8() {
|
|
_classCallCheck(this, Char8);
|
|
|
|
return _super16.apply(this, arguments);
|
|
}
|
|
|
|
return Char8;
|
|
}( /*#__PURE__*/_wrapNativeSuper(String));
|
|
|
|
exports.Char8 = Char8;
|
|
|
|
},{}],20:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _DC = _interopRequireDefault(require("./DC.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
var Guid = /*#__PURE__*/function () {
|
|
function Guid(dc) {
|
|
_classCallCheck(this, Guid);
|
|
|
|
this.value = dc;
|
|
}
|
|
|
|
_createClass(Guid, [{
|
|
key: "valueOf",
|
|
value: function valueOf() {
|
|
return this.value.getHex(0, 16);
|
|
}
|
|
}, {
|
|
key: "toString",
|
|
value: function toString() {
|
|
return this.vlue.toHex('');
|
|
} // [Symbol.toPrimitive](hint){
|
|
// console.log(hint);
|
|
// }
|
|
|
|
}], [{
|
|
key: "fromString",
|
|
value: function fromString(data) {
|
|
this.value = _DC["default"].fromHex(data, '');
|
|
}
|
|
}]);
|
|
|
|
return Guid;
|
|
}();
|
|
|
|
exports["default"] = Guid;
|
|
|
|
},{"./DC.js":15}],21:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
//import TemplateDescriber from '../Resource/Template/TemplateDescriber.js';
|
|
var IEnum = /*#__PURE__*/function () {
|
|
function IEnum() {
|
|
_classCallCheck(this, IEnum);
|
|
}
|
|
|
|
_createClass(IEnum, [{
|
|
key: "IEnum",
|
|
value: function IEnum(index, value, name) {
|
|
this.index = index;
|
|
this.value = value;
|
|
this.name = name;
|
|
}
|
|
}, {
|
|
key: "template",
|
|
get: function get() {//return new TemplateDescriber("IEnum");
|
|
}
|
|
}, {
|
|
key: "toString",
|
|
value: function toString() {
|
|
return "".concat(this.name, "<").concat(this.value, ">");
|
|
}
|
|
}]);
|
|
|
|
return IEnum;
|
|
}();
|
|
|
|
exports["default"] = IEnum;
|
|
|
|
},{}],22:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
var IRecord = /*#__PURE__*/function () {
|
|
function IRecord() {
|
|
_classCallCheck(this, IRecord);
|
|
}
|
|
|
|
_createClass(IRecord, [{
|
|
key: "toString",
|
|
value: function toString() {//return serialize().toString();
|
|
}
|
|
}]);
|
|
|
|
return IRecord;
|
|
}();
|
|
|
|
exports["default"] = IRecord;
|
|
|
|
},{}],23:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 06/11/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _IDestructible = _interopRequireDefault(require("../Core/IDestructible.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
|
|
|
|
function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
|
|
|
|
function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
|
|
|
|
var _item_destroyed = /*#__PURE__*/new WeakMap();
|
|
|
|
var KeyList = /*#__PURE__*/function () {
|
|
function KeyList() {
|
|
_classCallCheck(this, KeyList);
|
|
|
|
_item_destroyed.set(this, {
|
|
writable: true,
|
|
value: function value(sender) {
|
|
for (var i = 0; i < this.values.length; i++) {
|
|
if (sender == this.values[i]) {
|
|
this.removeAt(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
this.keys = [];
|
|
this.values = [];
|
|
}
|
|
|
|
_createClass(KeyList, [{
|
|
key: "toObject",
|
|
value: function toObject() {
|
|
var rt = {};
|
|
|
|
for (var i = 0; i < this.keys.length; i++) {
|
|
rt[this.keys[i]] = this.values[i];
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "at",
|
|
value: function at(index) {
|
|
return this.values[index];
|
|
}
|
|
}, {
|
|
key: "item",
|
|
value: function item(key) {
|
|
for (var i = 0; i < this.keys.length; i++) {
|
|
if (this.keys[i] == key) return this.values[i];
|
|
}
|
|
}
|
|
}, {
|
|
key: "get",
|
|
value: function get(key) {
|
|
if (key.valueOf != null) key = key.valueOf();
|
|
|
|
for (var i = 0; i < this.keys.length; i++) {
|
|
if (this.keys[i].valueOf != null) if (this.keys[i].valueOf() == key) return this.values[i];
|
|
}
|
|
}
|
|
}, {
|
|
key: "add",
|
|
value: function add(key, value) {
|
|
this.remove(key);
|
|
if (value instanceof _IDestructible["default"]) value.on("destroy", _classPrivateFieldGet(this, _item_destroyed), this);
|
|
this.keys.push(key);
|
|
this.values.push(value);
|
|
}
|
|
}, {
|
|
key: "contains",
|
|
value: function contains(key) {
|
|
for (var i = 0; i < this.keys.length; i++) {
|
|
if (this.keys[i] == key) return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "containsKey",
|
|
value: function containsKey(key) {
|
|
return this.contains(key);
|
|
}
|
|
}, {
|
|
key: "set",
|
|
value: function set(key, value) {
|
|
this.remove(key);
|
|
this.add(key, value);
|
|
}
|
|
}, {
|
|
key: "remove",
|
|
value: function remove(key) {
|
|
for (var i = 0; i < this.keys.length; i++) {
|
|
if (key == this.keys[i]) {
|
|
this.removeAt(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "removeAt",
|
|
value: function removeAt(index) {
|
|
if (this.values[index] instanceof _IDestructible["default"]) this.values[index].off("destroy", _classPrivateFieldGet(this, _item_destroyed));
|
|
this.keys.splice(index, 1);
|
|
this.values.splice(index, 1);
|
|
}
|
|
}, {
|
|
key: "clear",
|
|
value: function clear() {
|
|
while (this.length > 0) {
|
|
this.removeAt(0);
|
|
}
|
|
}
|
|
}, {
|
|
key: "filter",
|
|
value: function filter(selector) {
|
|
if (selector instanceof Function) {
|
|
return this.values.filter(selector);
|
|
} else {
|
|
var match = function match(small, big) {
|
|
if (small == big) {
|
|
return true;
|
|
} else if (_typeof(small) == "object" && _typeof(big) == "object" && small != null && big != null) {
|
|
if (small.constructor.name == "Object") {
|
|
for (var i in small) {
|
|
if (!match(small[i], big[i])) return false;
|
|
}
|
|
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else return false;
|
|
};
|
|
|
|
return this.values.filter(function (x) {
|
|
return match(selector, x);
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "length",
|
|
get: function get() {
|
|
return this.keys.length;
|
|
}
|
|
}]);
|
|
|
|
return KeyList;
|
|
}();
|
|
|
|
exports["default"] = KeyList;
|
|
|
|
},{"../Core/IDestructible.js":8}],24:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 26/08/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var NotModified = function NotModified() {
|
|
_classCallCheck(this, NotModified);
|
|
};
|
|
|
|
exports["default"] = NotModified;
|
|
|
|
},{}],25:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var ParseResult = function ParseResult(size, value) {
|
|
_classCallCheck(this, ParseResult);
|
|
|
|
this.size = size;
|
|
this.value = value;
|
|
};
|
|
|
|
exports["default"] = ParseResult;
|
|
|
|
},{}],26:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 06/11/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var PropertyValue = function PropertyValue(value, age, date) {
|
|
_classCallCheck(this, PropertyValue);
|
|
|
|
this.value = value;
|
|
this.age = age;
|
|
this.date = date;
|
|
};
|
|
|
|
exports["default"] = PropertyValue;
|
|
|
|
},{}],27:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
|
|
|
|
function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
var PropertyValueArray = /*#__PURE__*/function (_Array) {
|
|
_inherits(PropertyValueArray, _Array);
|
|
|
|
var _super = _createSuper(PropertyValueArray);
|
|
|
|
function PropertyValueArray() {
|
|
_classCallCheck(this, PropertyValueArray);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
return PropertyValueArray;
|
|
}( /*#__PURE__*/_wrapNativeSuper(Array));
|
|
|
|
exports["default"] = PropertyValueArray;
|
|
|
|
},{}],28:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _IRecord2 = _interopRequireDefault(require("./IRecord.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
var Record = /*#__PURE__*/function (_IRecord) {
|
|
_inherits(Record, _IRecord);
|
|
|
|
var _super = _createSuper(Record);
|
|
|
|
function Record() {
|
|
_classCallCheck(this, Record);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
return Record;
|
|
}(_IRecord2["default"]);
|
|
|
|
exports["default"] = Record;
|
|
|
|
},{"./IRecord.js":22}],29:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017-2022 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 26/08/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _IRecord = _interopRequireDefault(require("./IRecord.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
|
|
|
|
function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
|
|
|
|
function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
var RecordArray = /*#__PURE__*/function (_Array) {
|
|
_inherits(RecordArray, _Array);
|
|
|
|
var _super = _createSuper(RecordArray);
|
|
|
|
function RecordArray() {
|
|
_classCallCheck(this, RecordArray);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(RecordArray, [{
|
|
key: "push",
|
|
value: function push(value) {
|
|
if (value instanceof _IRecord["default"]) _get(_getPrototypeOf(RecordArray.prototype), "push", this).call(this, value);else return;
|
|
}
|
|
}]);
|
|
|
|
return RecordArray;
|
|
}( /*#__PURE__*/_wrapNativeSuper(Array));
|
|
|
|
exports["default"] = RecordArray;
|
|
|
|
},{"./IRecord.js":22}],30:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
var _default = // const ResourceComparisonResult =
|
|
{
|
|
Null: 0,
|
|
Record: 1,
|
|
RecordSameType: 2,
|
|
Same: 3,
|
|
Empty: 4
|
|
};
|
|
exports["default"] = _default;
|
|
|
|
},{}],31:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.RepresentationType = exports["default"] = exports.RepresentationTypeParseResults = exports.RepresentationTypeIdentifier = void 0;
|
|
|
|
var _TemplateType = _interopRequireDefault(require("../Resource/Template/TemplateType.js"));
|
|
|
|
var _IRecord = _interopRequireDefault(require("./IRecord.js"));
|
|
|
|
var _IResource = _interopRequireDefault(require("../Resource/IResource.js"));
|
|
|
|
var _BinaryList = _interopRequireDefault(require("./BinaryList.js"));
|
|
|
|
var _DC = _interopRequireDefault(require("./DC.js"));
|
|
|
|
var _Warehouse = _interopRequireDefault(require("../Resource/Warehouse.js"));
|
|
|
|
var _ExtendedTypes = require("./ExtendedTypes.js");
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var RepresentationTypeIdentifier = {
|
|
Void: 0x0,
|
|
Dynamic: 0x1,
|
|
Bool: 0x2,
|
|
UInt8: 0x3,
|
|
Int8: 0x4,
|
|
Char: 0x5,
|
|
Int16: 0x6,
|
|
UInt16: 0x7,
|
|
Int32: 0x8,
|
|
UInt32: 0x9,
|
|
Float32: 0xA,
|
|
Int64: 0xB,
|
|
UInt64: 0xC,
|
|
Float64: 0xD,
|
|
DateTime: 0xE,
|
|
Int128: 0xF,
|
|
UInt128: 0x10,
|
|
Decimal: 0x11,
|
|
String: 0x12,
|
|
RawData: 0x13,
|
|
Resource: 0x14,
|
|
Record: 0x15,
|
|
List: 0x16,
|
|
Map: 0x17,
|
|
Enum: 0x18,
|
|
TypedResource: 0x45,
|
|
// Followed by UUID
|
|
TypedRecord: 0x46,
|
|
// Followed by UUID
|
|
TypedList: 0x48,
|
|
// Followed by element type
|
|
Tuple2: 0x50,
|
|
// Followed by element type
|
|
TypedMap: 0x51,
|
|
// Followed by key type and value type
|
|
Tuple3: 0x58,
|
|
Tuple4: 0x60,
|
|
Tuple5: 0x68,
|
|
Tuple6: 0x70,
|
|
Tuple7: 0x78
|
|
};
|
|
exports.RepresentationTypeIdentifier = RepresentationTypeIdentifier;
|
|
var RuntimeTypes = {};
|
|
RuntimeTypes[RepresentationTypeIdentifier.Void] = [Object, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.Bool] = [Boolean, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.Char] = [_ExtendedTypes.Char8, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.Char16] = [_ExtendedTypes.Char16, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.UInt8] = [_ExtendedTypes.UInt8, _ExtendedTypes.UInt8];
|
|
RuntimeTypes[RepresentationTypeIdentifier.Int8] = [_ExtendedTypes.Int8, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.Int16] = [_ExtendedTypes.Int16, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.UInt16] = [_ExtendedTypes.UInt16, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.Int32] = [_ExtendedTypes.Int32, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.UInt32] = [_ExtendedTypes.UInt32, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.Int64] = [_ExtendedTypes.Int64, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.UInt64] = [_ExtendedTypes.UInt64, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.Int128] = [_ExtendedTypes.Int128, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.UInt128] = [_ExtendedTypes.UInt128, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.Float32] = [_ExtendedTypes.Float32, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.Float64] = [_ExtendedTypes.Float64, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.Decimal] = [_ExtendedTypes.Float128, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.String] = [String, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.DateTime] = [Date, Object];
|
|
RuntimeTypes[RepresentationTypeIdentifier.Resource] = [_IResource["default"], _IResource["default"]];
|
|
RuntimeTypes[RepresentationTypeIdentifier.Record] = [_IRecord["default"], _IRecord["default"]];
|
|
|
|
var RepresentationTypeParseResults = //RepresentationType type;
|
|
//int size;
|
|
function RepresentationTypeParseResults(size, type) {
|
|
_classCallCheck(this, RepresentationTypeParseResults);
|
|
|
|
this.size = size;
|
|
this.type = type;
|
|
};
|
|
|
|
exports.RepresentationTypeParseResults = RepresentationTypeParseResults;
|
|
|
|
var RepresentationType = /*#__PURE__*/function () {
|
|
function RepresentationType(identifier, nullable, guid, subTypes) {
|
|
_classCallCheck(this, RepresentationType);
|
|
|
|
this.identifier = identifier;
|
|
this.nullable = nullable;
|
|
this.guid = guid;
|
|
this.subTypes = subTypes;
|
|
}
|
|
|
|
_createClass(RepresentationType, [{
|
|
key: "toNullable",
|
|
value: // static getTypeFromName(name) {
|
|
// const types = {
|
|
// "int": int,
|
|
// "bool": bool,
|
|
// "double": double,
|
|
// "String": String,
|
|
// "IResource": IResource,
|
|
// "IRecord": IRecord,
|
|
// "IEnum": IEnum,
|
|
// "DC": DC,
|
|
// };
|
|
// if (types[name] != null) {
|
|
// return types[name];
|
|
// } else
|
|
// return Object().runtimeType;
|
|
// }
|
|
function toNullable() {
|
|
return new RepresentationType(this.identifier, true, this.guid, this.subTypes);
|
|
}
|
|
}, {
|
|
key: "getRuntimeType",
|
|
value: function getRuntimeType() {
|
|
var _Warehouse$getTemplat, _Warehouse$getTemplat2, _Warehouse$getTemplat3;
|
|
|
|
if (RuntimeTypes[this.identifier]) return this.nullable ? RuntimeTypes[this.identifier][1] : RuntimeTypes[this.identifier][0];
|
|
if (this.identifier == RepresentationTypeIdentifier.TypedRecord) return (_Warehouse$getTemplat = _Warehouse["default"].getTemplateByClassId(this.guid, _TemplateType["default"].Record)) === null || _Warehouse$getTemplat === void 0 ? void 0 : _Warehouse$getTemplat.definedType;else if (this.identifier == RepresentationTypeIdentifier.TypedResource) return (_Warehouse$getTemplat2 = _Warehouse["default"].getTemplateByClassId(this.guid, _TemplateType["default"].Unspecified)) === null || _Warehouse$getTemplat2 === void 0 ? void 0 : _Warehouse$getTemplat2.definedType;else if (this.identifier == RepresentationTypeIdentifier.Enum) return (_Warehouse$getTemplat3 = _Warehouse["default"].getTemplateByClassId(this.guid, _TemplateType["default"].Enum)) === null || _Warehouse$getTemplat3 === void 0 ? void 0 : _Warehouse$getTemplat3.definedType;
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "compose",
|
|
value: function compose() {
|
|
var rt = new _BinaryList["default"]();
|
|
if (this.nullable) rt.addUint8(0x80 | this.identifier);else rt.addUint8(this.identifier);
|
|
if (this.guid != null) rt.addDC(_DC["default"].guidToBytes(this.guid));
|
|
if (this.subTypes != null) for (var i = 0; i < this.subTypes.length; i++) {
|
|
rt.addDC(this.subTypes[i].compose());
|
|
}
|
|
return rt.toDC();
|
|
} //public override string ToString() => Identifier.ToString() + (Nullable ? "?" : "")
|
|
// + TypeTemplate != null ? "<" + TypeTemplate.ClassName + ">" : "";
|
|
|
|
}], [{
|
|
key: "Void",
|
|
get: function get() {
|
|
return new RepresentationType(RepresentationTypeIdentifier.Void, true, null, null);
|
|
}
|
|
}, {
|
|
key: "Dynamic",
|
|
get: function get() {
|
|
return new RepresentationType(RepresentationTypeIdentifier.Dynamic, true, null, null);
|
|
}
|
|
}, {
|
|
key: "fromType",
|
|
value: function fromType(type) {
|
|
var _Warehouse$typesFacto;
|
|
|
|
return (_Warehouse$typesFacto = _Warehouse["default"].typesFactory[type]) === null || _Warehouse$typesFacto === void 0 ? void 0 : _Warehouse$typesFacto.representationType;
|
|
}
|
|
}, {
|
|
key: "parse",
|
|
value: function parse(data, offset) {
|
|
var oOffset = offset;
|
|
var header = data[offset++];
|
|
var nullable = (header & 0x80) > 0;
|
|
var identifier = header & 0x7F;
|
|
|
|
if ((header & 0x40) > 0) {
|
|
var hasGUID = (header & 0x4) > 0;
|
|
var subsCount = header >> 3 & 0x7;
|
|
var guid = null;
|
|
|
|
if (hasGUID) {
|
|
guid = data.getGuid(offset);
|
|
offset += 16;
|
|
}
|
|
|
|
var subs = [];
|
|
|
|
for (var i = 0; i < subsCount; i++) {
|
|
var parsed = RepresentationType.parse(data, offset);
|
|
subs.push(parsed.type);
|
|
offset += parsed.size;
|
|
}
|
|
|
|
return new RepresentationTypeParseResults(offset - oOffset, new RepresentationType(identifier, nullable, guid, subs));
|
|
} else {
|
|
return new RepresentationTypeParseResults(1, new RepresentationType(identifier, nullable, null, null));
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return RepresentationType;
|
|
}();
|
|
|
|
exports.RepresentationType = exports["default"] = RepresentationType;
|
|
|
|
},{"../Resource/IResource.js":70,"../Resource/Template/TemplateType.js":82,"../Resource/Warehouse.js":84,"./BinaryList.js":13,"./DC.js":15,"./ExtendedTypes.js":19,"./IRecord.js":22}],32:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 26/08/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _IResource = _interopRequireDefault(require("../Resource/IResource.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
|
|
|
|
function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
|
|
|
|
function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
var ResourceArray = /*#__PURE__*/function (_Array) {
|
|
_inherits(ResourceArray, _Array);
|
|
|
|
var _super = _createSuper(ResourceArray);
|
|
|
|
function ResourceArray() {
|
|
_classCallCheck(this, ResourceArray);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(ResourceArray, [{
|
|
key: "push",
|
|
value: function push(value) {
|
|
if (value instanceof _IResource["default"]) _get(_getPrototypeOf(ResourceArray.prototype), "push", this).call(this, value);else return;
|
|
}
|
|
}]);
|
|
|
|
return ResourceArray;
|
|
}( /*#__PURE__*/_wrapNativeSuper(Array));
|
|
|
|
exports["default"] = ResourceArray;
|
|
|
|
},{"../Resource/IResource.js":70}],33:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
var _default = {
|
|
Dynamic: 0x0,
|
|
Static: 0x10,
|
|
Wrapper: 0x20
|
|
};
|
|
exports["default"] = _default;
|
|
|
|
},{}],34:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
var _default = // const ResourceComparisonResult =
|
|
{
|
|
Null: 0,
|
|
Distributed: 1,
|
|
Local: 2,
|
|
Same: 3,
|
|
Empty: 4
|
|
};
|
|
exports["default"] = _default;
|
|
|
|
},{}],35:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 26/08/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
var Structure = /*#__PURE__*/function () {
|
|
function Structure(data) {
|
|
_classCallCheck(this, Structure);
|
|
|
|
if (data instanceof Object) for (var i in data) {
|
|
this[i] = data[i];
|
|
}
|
|
}
|
|
|
|
_createClass(Structure, [{
|
|
key: "toArray",
|
|
value: function toArray() {
|
|
return this.toPairs();
|
|
}
|
|
}, {
|
|
key: "toPairs",
|
|
value: function toPairs() {
|
|
var rt = [];
|
|
|
|
for (var i in this) {
|
|
if (!(this[i] instanceof Function)) rt.push({
|
|
key: i,
|
|
value: this[i]
|
|
});
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "getKeys",
|
|
value: function getKeys() {
|
|
var rt = [];
|
|
|
|
for (var i in this) {
|
|
if (!(this[i] instanceof Function)) rt.push(i);
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "toObject",
|
|
value: function toObject() {
|
|
var rt = {};
|
|
|
|
for (var i in this) {
|
|
if (!(this[i] instanceof Function)) rt[i] = this[i];
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}]);
|
|
|
|
return Structure;
|
|
}();
|
|
|
|
exports["default"] = Structure;
|
|
|
|
},{}],36:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 06/09/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
|
|
|
|
function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
|
|
|
|
function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
var StructureArray = /*#__PURE__*/function (_Array) {
|
|
_inherits(StructureArray, _Array);
|
|
|
|
var _super = _createSuper(StructureArray);
|
|
|
|
function StructureArray() {
|
|
_classCallCheck(this, StructureArray);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(StructureArray, [{
|
|
key: "push",
|
|
value: function push(value) {
|
|
if (value instanceof Structure) _get(_getPrototypeOf(StructureArray.prototype), "push", this).call(this, value);else return;
|
|
}
|
|
}]);
|
|
|
|
return StructureArray;
|
|
}( /*#__PURE__*/_wrapNativeSuper(Array));
|
|
|
|
exports["default"] = StructureArray;
|
|
|
|
},{}],37:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
var _default = //const StructureComparisonResult =
|
|
{
|
|
Null: 0,
|
|
Structure: 1,
|
|
StructureSameKeys: 2,
|
|
StructureSameTypes: 3,
|
|
Same: 4
|
|
};
|
|
exports["default"] = _default;
|
|
|
|
},{}],38:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.TransmissionType = exports["default"] = exports.TransmissionTypeParseResults = exports.TransmissionTypeClass = exports.TransmissionTypeIdentifier = void 0;
|
|
|
|
var _DC = _interopRequireDefault(require("./DC.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var TransmissionTypeIdentifier = {
|
|
Null: 0x0,
|
|
False: 0x1,
|
|
True: 0x2,
|
|
NotModified: 0x3,
|
|
UInt8: 0x8,
|
|
Int8: 0x9,
|
|
Char8: 0xA,
|
|
Int16: 0x10,
|
|
UInt16: 0x11,
|
|
Char16: 0x12,
|
|
Int32: 0x18,
|
|
UInt32: 0x19,
|
|
Float32: 0x1A,
|
|
Resource: 0x1B,
|
|
ResourceLocal: 0x1C,
|
|
Int64: 0x20,
|
|
UInt64: 0x21,
|
|
Float64: 0x22,
|
|
DateTime: 0x23,
|
|
Int128: 0x28,
|
|
UInt128: 0x29,
|
|
Float128: 0x2A,
|
|
RawData: 0x40,
|
|
String: 0x41,
|
|
List: 0x42,
|
|
ResourceList: 0x43,
|
|
RecordList: 0x44,
|
|
Map: 0x45,
|
|
MapList: 0x46,
|
|
//Tuple = 0x47,
|
|
Record: 0x80,
|
|
TypedList: 0x81,
|
|
TypedMap: 0x82,
|
|
Tuple: 0x83,
|
|
Enum: 0x84,
|
|
Constant: 0x85
|
|
};
|
|
exports.TransmissionTypeIdentifier = TransmissionTypeIdentifier;
|
|
var TransmissionTypeClass = {
|
|
Fixed: 0,
|
|
Dynamic: 1,
|
|
Typed: 2
|
|
};
|
|
exports.TransmissionTypeClass = TransmissionTypeClass;
|
|
|
|
var TransmissionTypeParseResults = function TransmissionTypeParseResults(size, type) {
|
|
_classCallCheck(this, TransmissionTypeParseResults);
|
|
|
|
this.size = size;
|
|
this.type = type;
|
|
};
|
|
|
|
exports.TransmissionTypeParseResults = TransmissionTypeParseResults;
|
|
|
|
var TransmissionType = /*#__PURE__*/function () {
|
|
function TransmissionType(identifier, classType, index, offset, contentLength) {
|
|
var exponent = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
|
|
|
|
_classCallCheck(this, TransmissionType);
|
|
|
|
this.identifier = identifier;
|
|
this.classType = classType;
|
|
this.index = index;
|
|
this.offset = offset;
|
|
this.contentLength = contentLength;
|
|
this.exponent = exponent;
|
|
}
|
|
|
|
_createClass(TransmissionType, null, [{
|
|
key: "Null",
|
|
get: // final int identifier;
|
|
// final int index;
|
|
// final int classType;
|
|
// final int offset;
|
|
// final int contentLength;
|
|
// final int exponent;
|
|
function get() {
|
|
return new TransmissionType(TransmissionTypeIdentifier.Null, 0, 0, 0, 0);
|
|
}
|
|
}, {
|
|
key: "compose",
|
|
value: function compose(identifier, data) {
|
|
if (data.length == 0) return _DC["default"].fromList([identifier]);
|
|
var cls = identifier >> 6;
|
|
|
|
if (cls == TransmissionTypeClass.Fixed) {
|
|
return _DC["default"].combine([identifier], 0, 1, data, 0, data.length);
|
|
} else {
|
|
var len = data.length;
|
|
|
|
if (len == 0) {
|
|
return _DC["default"].fromList([identifier]);
|
|
} else if (len <= 0xFF) {
|
|
var rt = new _DC["default"](2 + len);
|
|
rt[0] = identifier | 0x8;
|
|
rt[1] = len;
|
|
rt.set(data, 2);
|
|
return rt;
|
|
} else if (len <= 0xFFFF) {
|
|
var _rt = new _DC["default"](3 + len);
|
|
|
|
_rt[0] = identifier | 0x10;
|
|
_rt[1] = len >> 8 & 0xFF;
|
|
_rt[2] = len & 0xFF;
|
|
|
|
_rt.set(data, 3);
|
|
|
|
return _rt;
|
|
} else if (len <= 0xFFFFFF) {
|
|
var _rt2 = new _DC["default"](4 + len);
|
|
|
|
_rt2[0] = identifier | 0x18;
|
|
_rt2[1] = len >> 16 & 0xFF;
|
|
_rt2[2] = len >> 8 & 0xFF;
|
|
_rt2[3] = len & 0xFF;
|
|
|
|
_rt2.set(data, 4);
|
|
|
|
return _rt2;
|
|
} else if (len <= 0xFFFFFFFF) {
|
|
var _rt3 = new _DC["default"](5 + len);
|
|
|
|
_rt3[0] = identifier | 0x20;
|
|
_rt3[1] = len >> 24 & 0xFF;
|
|
_rt3[2] = len >> 16 & 0xFF;
|
|
_rt3[3] = len >> 8 & 0xFF;
|
|
_rt3[4] = len & 0xFF;
|
|
|
|
_rt3.set(data, 5);
|
|
|
|
return _rt3;
|
|
} else if (len <= 0xFFFFFFFFFF) {
|
|
var _rt4 = new _DC["default"](6 + len);
|
|
|
|
_rt4[0] = identifier | 0x28;
|
|
_rt4[1] = len >> 32 & 0xFF;
|
|
_rt4[2] = len >> 24 & 0xFF;
|
|
_rt4[3] = len >> 16 & 0xFF;
|
|
_rt4[4] = len >> 8 & 0xFF;
|
|
_rt4[5] = len & 0xFF;
|
|
|
|
_rt4.set(data, 6);
|
|
|
|
return _rt4;
|
|
} else if (len <= 0xFFFFFFFFFFFF) {
|
|
var _rt5 = new _DC["default"](7 + len);
|
|
|
|
_rt5[0] = identifier | 0x30;
|
|
_rt5[1] = len >> 40 & 0xFF;
|
|
_rt5[2] = len >> 32 & 0xFF;
|
|
_rt5[3] = len >> 24 & 0xFF;
|
|
_rt5[4] = len >> 16 & 0xFF;
|
|
_rt5[5] = len >> 8 & 0xFF;
|
|
_rt5[6] = len & 0xFF;
|
|
|
|
_rt5.set(data, 7);
|
|
|
|
return _rt5;
|
|
} else //if (len <= 0xFF_FF_FF_FF_FF_FF_FF)
|
|
{
|
|
var _rt6 = new _DC["default"](8 + len);
|
|
|
|
_rt6[0] = identifier | 0x38;
|
|
_rt6[1] = len >> 48 & 0xFF;
|
|
_rt6[2] = len >> 40 & 0xFF;
|
|
_rt6[3] = len >> 32 & 0xFF;
|
|
_rt6[4] = len >> 24 & 0xFF;
|
|
_rt6[5] = len >> 16 & 0xFF;
|
|
_rt6[6] = len >> 8 & 0xFF;
|
|
_rt6[7] = len & 0xFF;
|
|
data.set(data, 8);
|
|
return _rt6;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "parse",
|
|
value: function parse(data, offset, ends) {
|
|
var h = data[offset++];
|
|
var cls = h >> 6;
|
|
|
|
if (cls == TransmissionTypeClass.Fixed) {
|
|
var exp = (h & 0x38) >> 3;
|
|
if (exp == 0) return new TransmissionTypeParseResults(1, new TransmissionType(h, cls, h & 0x7, 0, exp));
|
|
var cl = 1 << exp - 1;
|
|
if (ends - offset < cl) return new TransmissionTypeParseResults(ends - offset - cl, null);
|
|
return new TransmissionTypeParseResults(1 + cl, new TransmissionType(h, cls, h & 0x7, offset, cl, exp));
|
|
} else {
|
|
var cll = h >> 3 & 0x7;
|
|
if (ends - offset < cll) return new TransmissionTypeParseResults(ends - offset - cll, null);
|
|
var _cl = 0;
|
|
|
|
for (var i = 0; i < cll; i++) {
|
|
_cl = _cl << 8 | data[offset++];
|
|
}
|
|
|
|
return new TransmissionTypeParseResults(1 + _cl + cll, new TransmissionType(h & 0xC7, cls, h & 0x7, offset, _cl));
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return TransmissionType;
|
|
}();
|
|
|
|
exports.TransmissionType = exports["default"] = TransmissionType;
|
|
|
|
},{"./DC.js":15}],39:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
|
|
|
|
function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
var Tuple = /*#__PURE__*/function (_Array) {
|
|
_inherits(Tuple, _Array);
|
|
|
|
var _super = _createSuper(Tuple);
|
|
|
|
function Tuple() {
|
|
_classCallCheck(this, Tuple);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(Tuple, null, [{
|
|
key: "getTypes",
|
|
value: function getTypes(tuple) {
|
|
return tuple.constructor.types;
|
|
}
|
|
}, {
|
|
key: "of",
|
|
value: function of() {
|
|
var types = [];
|
|
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
types.push(arguments[i]);
|
|
}
|
|
|
|
if (Tuple.cache[types] != null) return Tuple.cache[types];
|
|
|
|
var c = /*#__PURE__*/function (_Tuple) {
|
|
_inherits(c, _Tuple);
|
|
|
|
var _super2 = _createSuper(c);
|
|
|
|
function c() {
|
|
_classCallCheck(this, c);
|
|
|
|
return _super2.apply(this, arguments);
|
|
}
|
|
|
|
return c;
|
|
}(Tuple);
|
|
|
|
Object.defineProperty(c, "name", {
|
|
value: types.map(function (x) {
|
|
return x.name;
|
|
}).join('') + "Tuple"
|
|
});
|
|
Object.defineProperty(c, "types", {
|
|
value: types
|
|
});
|
|
Tuple.cache[types] = c;
|
|
return c;
|
|
}
|
|
}]);
|
|
|
|
return Tuple;
|
|
}( /*#__PURE__*/_wrapNativeSuper(Array));
|
|
|
|
exports["default"] = Tuple;
|
|
|
|
_defineProperty(Tuple, "cache", {});
|
|
|
|
},{}],40:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _IResource = _interopRequireDefault(require("../Resource/IResource.js"));
|
|
|
|
var _PropertyValue = _interopRequireDefault(require("./PropertyValue.js"));
|
|
|
|
var _PropertyValueArray = _interopRequireDefault(require("./PropertyValueArray.js"));
|
|
|
|
var _ResourceArray = _interopRequireDefault(require("./ResourceArray.js"));
|
|
|
|
var _defineProperty2;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
|
|
|
|
function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
var TypedList = /*#__PURE__*/function (_Array) {
|
|
_inherits(TypedList, _Array);
|
|
|
|
var _super = _createSuper(TypedList);
|
|
|
|
function TypedList() {
|
|
_classCallCheck(this, TypedList);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(TypedList, null, [{
|
|
key: "getType",
|
|
value: // constructor(data)
|
|
// {
|
|
// if (data != undefined && data instanceof Array)
|
|
// for(var i = 0; i < data.length; i++)
|
|
// this.push(data[i]);
|
|
// }
|
|
function getType(typedList) {
|
|
return typedList.constructor.type;
|
|
}
|
|
}, {
|
|
key: "of",
|
|
value: function of(type) {
|
|
if (TypedList.cache[type] != null) return TypedList.cache[type];
|
|
|
|
var c = /*#__PURE__*/function (_TypedList) {
|
|
_inherits(c, _TypedList);
|
|
|
|
var _super2 = _createSuper(c);
|
|
|
|
function c() {
|
|
_classCallCheck(this, c);
|
|
|
|
return _super2.apply(this, arguments);
|
|
}
|
|
|
|
return c;
|
|
}(TypedList);
|
|
|
|
Object.defineProperty(c, "name", {
|
|
value: type.name + "List"
|
|
});
|
|
Object.defineProperty(c, "type", {
|
|
value: type
|
|
});
|
|
TypedList.cache[type] = c;
|
|
return c;
|
|
}
|
|
}]);
|
|
|
|
return TypedList;
|
|
}( /*#__PURE__*/_wrapNativeSuper(Array));
|
|
|
|
exports["default"] = TypedList;
|
|
|
|
_defineProperty(TypedList, "cache", (_defineProperty2 = {}, _defineProperty(_defineProperty2, _IResource["default"], _ResourceArray["default"]), _defineProperty(_defineProperty2, _PropertyValue["default"], _PropertyValueArray["default"]), _defineProperty2));
|
|
|
|
},{"../Resource/IResource.js":70,"./PropertyValue.js":26,"./PropertyValueArray.js":27,"./ResourceArray.js":32}],41:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
|
|
|
|
function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
var TypedMap = /*#__PURE__*/function (_Map) {
|
|
_inherits(TypedMap, _Map);
|
|
|
|
var _super = _createSuper(TypedMap);
|
|
|
|
function TypedMap(data) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, TypedMap);
|
|
|
|
_this = _super.call(this);
|
|
if (data instanceof Object) for (var i in data) {
|
|
_this.set(i, data[i]);
|
|
}
|
|
return _this;
|
|
}
|
|
|
|
_createClass(TypedMap, null, [{
|
|
key: "getTypes",
|
|
value: function getTypes(typedMap) {
|
|
var _typedMap$constructor, _typedMap$constructor2;
|
|
|
|
return [(_typedMap$constructor = typedMap.constructor.keyType) !== null && _typedMap$constructor !== void 0 ? _typedMap$constructor : Object, (_typedMap$constructor2 = typedMap.constructor.valueType) !== null && _typedMap$constructor2 !== void 0 ? _typedMap$constructor2 : Object];
|
|
}
|
|
}, {
|
|
key: "of",
|
|
value: function of(keyType, valueType) {
|
|
if (TypedMap.cache[[keyType, valueType]] != null) return TypedMap.cache[[keyType, valueType]]; //if (TypedMap.cache[keyType] != null)
|
|
// if (TypedMap.cache[keyType][valueType] != null)
|
|
// return TypedMap.cache[keyType][valueType];
|
|
|
|
var c = /*#__PURE__*/function (_TypedMap) {
|
|
_inherits(c, _TypedMap);
|
|
|
|
var _super2 = _createSuper(c);
|
|
|
|
function c() {
|
|
_classCallCheck(this, c);
|
|
|
|
return _super2.apply(this, arguments);
|
|
}
|
|
|
|
return c;
|
|
}(TypedMap);
|
|
|
|
Object.defineProperty(c, "name", {
|
|
value: keyType.name + valueType.name + "Map"
|
|
});
|
|
Object.defineProperty(c, "keyType", {
|
|
value: keyType
|
|
});
|
|
Object.defineProperty(c, "valueType", {
|
|
value: valueType
|
|
}); //if (TypedMap.cache[keyType] == null)
|
|
// TypedMap.cache[keyType] = {[valueType]: c};
|
|
//else
|
|
// TypedMap.cache[keyType][valueType] = c;
|
|
|
|
TypedMap.cache[[keyType, valueType]] = c;
|
|
return c;
|
|
}
|
|
}]);
|
|
|
|
return TypedMap;
|
|
}( /*#__PURE__*/_wrapNativeSuper(Map));
|
|
|
|
exports["default"] = TypedMap;
|
|
|
|
_defineProperty(TypedMap, "cache", {});
|
|
|
|
},{}],42:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 25/07/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _IStore2 = _interopRequireDefault(require("../../Resource/IStore.js"));
|
|
|
|
var _Session = _interopRequireDefault(require("../../Security/Authority/Session.js"));
|
|
|
|
var _Authentication = _interopRequireDefault(require("../../Security/Authority/Authentication.js"));
|
|
|
|
var _AuthenticationType = _interopRequireDefault(require("../../Security/Authority/AuthenticationType.js"));
|
|
|
|
var _SHA = _interopRequireDefault(require("../../Security/Integrity/SHA256.js"));
|
|
|
|
var _DC = require("../../Data/DC.js");
|
|
|
|
var _SendList = _interopRequireDefault(require("../SendList.js"));
|
|
|
|
var _AsyncReply = _interopRequireDefault(require("../../Core/AsyncReply.js"));
|
|
|
|
var _Codec = _interopRequireDefault(require("../../Data/Codec.js"));
|
|
|
|
var _KeyList = _interopRequireDefault(require("../../Data/KeyList.js"));
|
|
|
|
var _AsyncQueue = _interopRequireDefault(require("../../Core/AsyncQueue.js"));
|
|
|
|
var _Warehouse = _interopRequireDefault(require("../../Resource/Warehouse.js"));
|
|
|
|
var _IIPAuthPacket = _interopRequireDefault(require("../Packets/IIPAuthPacket.js"));
|
|
|
|
var _IIPPacket = _interopRequireDefault(require("../Packets/IIPPacket.js"));
|
|
|
|
var _IIPAuthPacketAction = _interopRequireDefault(require("../Packets/IIPAuthPacketAction.js"));
|
|
|
|
var _IIPAuthPacketCommand = _interopRequireDefault(require("../Packets/IIPAuthPacketCommand.js"));
|
|
|
|
var _AuthenticationMethod = _interopRequireDefault(require("../../Security/Authority/AuthenticationMethod.js"));
|
|
|
|
var _IIPPacketAction = _interopRequireDefault(require("../Packets/IIPPacketAction.js"));
|
|
|
|
var _IIPPacketCommand = _interopRequireDefault(require("../Packets/IIPPacketCommand.js"));
|
|
|
|
var _IIPPacketEvent = _interopRequireDefault(require("../Packets/IIPPacketEvent.js"));
|
|
|
|
var _IIPPacketReport = _interopRequireDefault(require("../Packets//IIPPacketReport.js"));
|
|
|
|
var _ErrorType = _interopRequireDefault(require("../../Core/ErrorType.js"));
|
|
|
|
var _ProgressType = _interopRequireDefault(require("../../Core/ProgressType.js"));
|
|
|
|
var _ExceptionCode = _interopRequireDefault(require("../../Core/ExceptionCode.js"));
|
|
|
|
var _DistributedResource = _interopRequireDefault(require("./DistributedResource.js"));
|
|
|
|
var _TypeTemplate = _interopRequireDefault(require("../../Resource/Template/TypeTemplate.js"));
|
|
|
|
var _DistributedResourceQueueItem = _interopRequireDefault(require("./DistributedResourceQueueItem.js"));
|
|
|
|
var _DistributedResourceQueueItemType = _interopRequireDefault(require("./DistributedResourceQueueItemType.js"));
|
|
|
|
var _DistributedPropertyContext = _interopRequireDefault(require("./DistributedPropertyContext.js"));
|
|
|
|
var _IResource = require("../../Resource/IResource.js");
|
|
|
|
var _Ruling = _interopRequireDefault(require("../../Security/Permissions/Ruling.js"));
|
|
|
|
var _ActionType = _interopRequireDefault(require("../../Security/Permissions/ActionType.js"));
|
|
|
|
var _AsyncException = _interopRequireDefault(require("../../Core/AsyncException.js"));
|
|
|
|
var _WSocket = _interopRequireDefault(require("../Sockets/WSocket.js"));
|
|
|
|
var _ClientAuthentication = _interopRequireDefault(require("../../Security/Authority/ClientAuthentication.js"));
|
|
|
|
var _HostAuthentication = _interopRequireDefault(require("../../Security/Authority/HostAuthentication.js"));
|
|
|
|
var _SocketState = _interopRequireDefault(require("../Sockets/SocketState.js"));
|
|
|
|
var _TemplateType = _interopRequireDefault(require("../../Resource/Template/TemplateType.js"));
|
|
|
|
var _AsyncBag = _interopRequireDefault(require("../../Core/AsyncBag.js"));
|
|
|
|
var _TransmissionType = require("../../Data/TransmissionType.js");
|
|
|
|
var _PropertyValue = _interopRequireDefault(require("../../Data/PropertyValue.js"));
|
|
|
|
var _PropertyValueArray = _interopRequireDefault(require("../../Data/PropertyValueArray.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
|
|
|
|
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
|
|
|
|
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
|
|
|
|
function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
|
|
|
|
function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
|
|
|
|
function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
|
|
|
|
var _instance_resourceDestroyed = /*#__PURE__*/new WeakMap();
|
|
|
|
var _instance_propertyModified = /*#__PURE__*/new WeakMap();
|
|
|
|
var _instance_eventOccurred = /*#__PURE__*/new WeakMap();
|
|
|
|
var DistributedConnection = /*#__PURE__*/function (_IStore) {
|
|
_inherits(DistributedConnection, _IStore);
|
|
|
|
var _super = _createSuper(DistributedConnection);
|
|
|
|
function DistributedConnection(server) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, DistributedConnection);
|
|
|
|
_this = _super.call(this);
|
|
|
|
_instance_resourceDestroyed.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: function value(resource) {
|
|
this._unsubscribe(resource); // compose the packet
|
|
|
|
|
|
this.sendEvent(_IIPPacketEvent["default"].ResourceDestroyed).addUint32(resource.instance.id).done();
|
|
}
|
|
});
|
|
|
|
_instance_propertyModified.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: function value(info) {
|
|
var _info$resource$instan;
|
|
|
|
this.sendEvent(_IIPPacketEvent["default"].PropertyUpdated).addUint32((_info$resource$instan = info.resource.instance) === null || _info$resource$instan === void 0 ? void 0 : _info$resource$instan.id).addUint8(info.propertyTemplate.index).addUint8Array(_Codec["default"].compose(info.value, this)).done();
|
|
}
|
|
});
|
|
|
|
_instance_eventOccurred.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: function value(info) {
|
|
if (info.eventTemplate.listenable) {
|
|
// check the client requested listen
|
|
if (!this.subscriptions.has(resource)) return;
|
|
if (!this.subscriptions.get(resource).includes(et.index)) return;
|
|
}
|
|
|
|
if (info.receivers instanceof Function) if (!info.receivers(this.sessions)) return;
|
|
if (info.resource.instance.applicable(this.session, _ActionType["default"].ReceiveEvent, info.eventTemplate, info.issuer) == _Ruling["default"].Denied) return; // compose the packet
|
|
|
|
this.sendEvent(_IIPPacketEvent["default"].EventOccurred).addUint32(info.resource.instance.id).addUint8(info.eventTemplate.index).addUint8Array(_Codec["default"].compose(info.value, this)).done();
|
|
}
|
|
});
|
|
|
|
_this._register("ready");
|
|
|
|
_this._register("error");
|
|
|
|
_this._register("close");
|
|
|
|
if (server != null) {
|
|
_this.session = new _Session["default"](new _Authentication["default"](_AuthenticationType["default"].Host), new _Authentication["default"](_AuthenticationType["default"].Client));
|
|
_this.server = server;
|
|
} else _this.session = new _Session["default"](new _Authentication["default"](_AuthenticationType["default"].Client), new _Authentication["default"](_AuthenticationType["default"].Host));
|
|
|
|
_this.packet = new _IIPPacket["default"]();
|
|
_this.authPacket = new _IIPAuthPacket["default"]();
|
|
_this.resources = new _KeyList["default"](); //{};
|
|
|
|
_this.templates = new _KeyList["default"]();
|
|
_this.requests = new _KeyList["default"](); // {};
|
|
//this.pathRequests = new KeyList();// {};
|
|
|
|
_this.templateRequests = new _KeyList["default"]();
|
|
_this.resourceRequests = new _KeyList["default"](); // {};
|
|
|
|
_this.callbackCounter = 0;
|
|
_this.queue = new _AsyncQueue["default"]();
|
|
_this.subscriptions = new Map();
|
|
|
|
_this.queue.then(function (x) {
|
|
if (x.type == _DistributedResourceQueueItemType["default"].Event) {
|
|
x.resource._emitEventByIndex(x.index, x.value);
|
|
} else {
|
|
x.resource._updatePropertyByIndex(x.index, x.value);
|
|
}
|
|
});
|
|
|
|
_this.localNonce = _this.generateNonce(32);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(DistributedConnection, [{
|
|
key: "sendAll",
|
|
value: function sendAll(data) {
|
|
this.socket.sendAll(data.buffer);
|
|
}
|
|
}, {
|
|
key: "sendParams",
|
|
value: function sendParams(doneReply) {
|
|
return new _SendList["default"](this, doneReply);
|
|
}
|
|
}, {
|
|
key: "generateNonce",
|
|
value: function generateNonce(length) {
|
|
var rt = new Uint8Array(length);
|
|
|
|
for (var i = 0; i < length; i++) {
|
|
rt[i] = Math.random() * 255;
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "_processPacket",
|
|
value: function _processPacket(msg, offset, ends, data) {
|
|
var _this2 = this;
|
|
|
|
var authPacket = this.authPacket;
|
|
|
|
if (this.ready) {
|
|
var packet = new _IIPPacket["default"]();
|
|
var rt = packet.parse(msg, offset, ends); //console.log("Inc " , rt, offset, ends);
|
|
|
|
if (rt <= 0) {
|
|
data.holdFor(msg, offset, ends - offset, -rt);
|
|
return ends;
|
|
} else {
|
|
offset += rt;
|
|
|
|
try {
|
|
if (packet.command == _IIPPacketCommand["default"].Event) {
|
|
switch (packet.event) {
|
|
case _IIPPacketEvent["default"].ResourceReassigned:
|
|
this.IIPEventResourceReassigned(packet.resourceId, packet.newResourceId);
|
|
break;
|
|
|
|
case _IIPPacketEvent["default"].ResourceDestroyed:
|
|
this.IIPEventResourceDestroyed(packet.resourceId);
|
|
break;
|
|
|
|
case _IIPPacketEvent["default"].PropertyUpdated:
|
|
this.IIPEventPropertyUpdated(packet.resourceId, packet.methodIndex, packet.dataType, msg);
|
|
break;
|
|
|
|
case _IIPPacketEvent["default"].EventOccurred:
|
|
this.IIPEventEventOccurred(packet.resourceId, packet.methodIndex, packet.dataType, msg);
|
|
break;
|
|
|
|
case _IIPPacketEvent["default"].ChildAdded:
|
|
this.IIPEventChildAdded(packet.resourceId, packet.childId);
|
|
break;
|
|
|
|
case _IIPPacketEvent["default"].ChildRemoved:
|
|
this.IIPEventChildRemoved(packet.resourceId, packet.childId);
|
|
break;
|
|
|
|
case _IIPPacketEvent["default"].Renamed:
|
|
this.IIPEventRenamed(packet.resourceId, packet.resourceName);
|
|
break;
|
|
|
|
case _IIPPacketEvent["default"].AttributesUpdated:
|
|
//@TODO: fix this
|
|
//this.IIPEventAttributesUpdated(packet.resourceId, packet.content);
|
|
break;
|
|
}
|
|
} else if (packet.command == _IIPPacketCommand["default"].Request) {
|
|
switch (packet.action) {
|
|
// Manage
|
|
case _IIPPacketAction["default"].AttachResource:
|
|
this.IIPRequestAttachResource(packet.callbackId, packet.resourceId);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].ReattachResource:
|
|
this.IIPRequestReattachResource(packet.callbackId, packet.resourceId, packet.resourceAge);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].DetachResource:
|
|
this.IIPRequestDetachResource(packet.callbackId, packet.resourceId);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].CreateResource:
|
|
// @TODO: implement this
|
|
// this.IIPRequestCreateResource(packet.callbackId, packet.storeId, packet.resourceId, packet.content);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].DeleteResource:
|
|
this.IIPRequestDeleteResource(packet.callbackId, packet.resourceId);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].AddChild:
|
|
this.IIPRequestAddChild(packet.callbackId, packet.resourceId, packet.childId);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].RemoveChild:
|
|
this.IIPRequestRemoveChild(packet.callbackId, packet.resourceId, packet.childId);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].RenameResource:
|
|
this.IIPRequestRenameResource(packet.callbackId, packet.resourceId, packet.resourceName);
|
|
break;
|
|
// Inquire
|
|
|
|
case _IIPPacketAction["default"].TemplateFromClassName:
|
|
this.IIPRequestTemplateFromClassName(packet.callbackId, packet.className);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].TemplateFromClassId:
|
|
this.IIPRequestTemplateFromClassId(packet.callbackId, packet.classId);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].TemplateFromResourceId:
|
|
this.IIPRequestTemplateFromResourceId(packet.callbackId, packet.resourceId);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].QueryLink:
|
|
this.IIPRequestQueryResources(packet.callbackId, packet.resourceLink);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].ResourceChildren:
|
|
this.IIPRequestResourceChildren(packet.callbackId, packet.resourceId);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].ResourceParents:
|
|
this.IIPRequestResourceParents(packet.callbackId, packet.resourceId);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].ResourceHistory:
|
|
this.IIPRequestInquireResourceHistory(packet.callbackId, packet.resourceId, packet.fromDate, packet.toDate);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].LinkTemplates:
|
|
this.IIPRequestLinkTemplates(packet.callbackId, packet.resourceLink);
|
|
break;
|
|
// Invoke
|
|
|
|
case _IIPPacketAction["default"].InvokeFunction:
|
|
this.IIPRequestInvokeFunction(packet.callbackId, packet.resourceId, packet.methodIndex, packet.dataType, msg);
|
|
break;
|
|
// case IIPPacketAction.GetProperty:
|
|
// this.IIPRequestGetProperty(packet.callbackId, packet.resourceId, packet.methodIndex);
|
|
// break;
|
|
// case IIPPacketAction.GetPropertyIfModified:
|
|
// this.IIPRequestGetPropertyIfModifiedSince(packet.callbackId, packet.resourceId, packet.methodIndex, packet.resourceAge);
|
|
// break;
|
|
|
|
case _IIPPacketAction["default"].Listen:
|
|
this.IIPRequestListen(packet.callbackId, packet.resourceId, packet.methodIndex);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].Unlisten:
|
|
this.IIPRequestUnlisten(packet.callbackId, packet.resourceId, packet.methodIndex);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].SetProperty:
|
|
this.IIPRequestSetProperty(packet.callbackId, packet.resourceId, packet.methodIndex, packet.dataType, msg);
|
|
break;
|
|
// Attribute @TODO: implement these
|
|
|
|
case _IIPPacketAction["default"].GetAllAttributes:
|
|
// this.IIPRequestGetAttributes(packet.callbackId, packet.resourceId, packet.content, true);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].UpdateAllAttributes:
|
|
// this.IIPRequestUpdateAttributes(packet.callbackId, packet.resourceId, packet.content, true);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].ClearAllAttributes:
|
|
// this.IIPRequestClearAttributes(packet.callbackId, packet.resourceId, packet.content, true);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].GetAttributes:
|
|
// this.IIPRequestGetAttributes(packet.callbackId, packet.resourceId, packet.content, false);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].UpdateAttributes:
|
|
// this.IIPRequestUpdateAttributes(packet.callbackId, packet.resourceId, packet.content, false);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].ClearAttributes:
|
|
// this.IIPRequestClearAttributes(packet.callbackId, packet.resourceId, packet.content, false);
|
|
break;
|
|
}
|
|
} else if (packet.command == _IIPPacketCommand["default"].Reply) {
|
|
switch (packet.action) {
|
|
case _IIPPacketAction["default"].AttachResource:
|
|
this.IIPReply(packet.callbackId, packet.classId, packet.resourceAge, packet.resourceLink, packet.dataType, msg);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].ReattachResource:
|
|
this.IIPReply(packet.callbackId, packet.resourceAge, packet.dataType, msg);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].DetachResource:
|
|
this.IIPReply(packet.callbackId);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].CreateResource:
|
|
this.IIPReply(packet.callbackId, packet.resourceId);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].DeleteResource:
|
|
case _IIPPacketAction["default"].AddChild:
|
|
case _IIPPacketAction["default"].RemoveChild:
|
|
case _IIPPacketAction["default"].RenameResource:
|
|
this.IIPReply(packet.callbackId);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].TemplateFromClassName:
|
|
case _IIPPacketAction["default"].TemplateFromClassId:
|
|
case _IIPPacketAction["default"].TemplateFromResourceId:
|
|
if (packet.dataType != null) {
|
|
var _packet$dataType$offs, _packet$dataType, _packet$dataType$cont, _packet$dataType2;
|
|
|
|
var content = msg.clip((_packet$dataType$offs = (_packet$dataType = packet.dataType) === null || _packet$dataType === void 0 ? void 0 : _packet$dataType.offset) !== null && _packet$dataType$offs !== void 0 ? _packet$dataType$offs : 0, (_packet$dataType$cont = (_packet$dataType2 = packet.dataType) === null || _packet$dataType2 === void 0 ? void 0 : _packet$dataType2.contentLength) !== null && _packet$dataType$cont !== void 0 ? _packet$dataType$cont : 0);
|
|
this.IIPReply(packet.callbackId, _TypeTemplate["default"].parse(content));
|
|
} else {
|
|
iipReportError(packet.callbackId, _ErrorType["default"].Management, _ExceptionCode["default"].TemplateNotFound.index, "Template not found");
|
|
}
|
|
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].QueryLink:
|
|
case _IIPPacketAction["default"].ResourceChildren:
|
|
case _IIPPacketAction["default"].ResourceParents:
|
|
case _IIPPacketAction["default"].ResourceHistory:
|
|
case _IIPPacketAction["default"].LinkTemplates:
|
|
this.IIPReply(packet.callbackId, packet.dataType, msg);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].InvokeFunction:
|
|
this.IIPReplyInvoke(packet.callbackId, packet.dataType, msg);
|
|
break;
|
|
// case IIPPacketAction.GetProperty:
|
|
// this.IIPReply(packet.callbackId, packet.content);
|
|
// break;
|
|
// case IIPPacketAction.GetPropertyIfModified:
|
|
// this.IIPReply(packet.callbackId, packet.content);
|
|
// break;
|
|
|
|
case _IIPPacketAction["default"].Listen:
|
|
case _IIPPacketAction["default"].Unlisten:
|
|
case _IIPPacketAction["default"].SetProperty:
|
|
this.IIPReply(packet.callbackId);
|
|
break;
|
|
// Attribute
|
|
|
|
case _IIPPacketAction["default"].GetAllAttributes:
|
|
case _IIPPacketAction["default"].GetAttributes:
|
|
this.IIPReply(packet.callbackId, packet.dataType, msg);
|
|
break;
|
|
|
|
case _IIPPacketAction["default"].UpdateAllAttributes:
|
|
case _IIPPacketAction["default"].UpdateAttributes:
|
|
case _IIPPacketAction["default"].ClearAllAttributes:
|
|
case _IIPPacketAction["default"].ClearAttributes:
|
|
this.IIPReply(packet.callbackId);
|
|
break;
|
|
}
|
|
} else if (packet.command == _IIPPacketCommand["default"].Report) {
|
|
switch (packet.report) {
|
|
case _IIPPacketReport["default"].ManagementError:
|
|
this.IIPReportError(packet.callbackId, _ErrorType["default"].Management, packet.errorCode, null);
|
|
break;
|
|
|
|
case _IIPPacketReport["default"].ExecutionError:
|
|
this.IIPReportError(packet.callbackId, _ErrorType["default"].Exception, packet.errorCode, packet.errorMessage);
|
|
break;
|
|
|
|
case _IIPPacketReport["default"].ProgressReport:
|
|
this.IIPReportProgress(packet.callbackId, _ProgressType["default"].Execution, packet.progressValue, packet.progressMax);
|
|
break;
|
|
|
|
case _IIPPacketReport["default"].ChunkStream:
|
|
this.IIPReportChunk(packet.callbackId, packet.dataType, msg);
|
|
break;
|
|
}
|
|
}
|
|
} catch (ex) {
|
|
console.log("Esiur Error ", ex);
|
|
}
|
|
}
|
|
} else {
|
|
var rt = authPacket.parse(msg, offset, ends); //console.log("Auth", rt, authPacket.command);
|
|
|
|
if (rt <= 0) {
|
|
data.holdAllFor(msg, ends - rt);
|
|
return ends;
|
|
} else {
|
|
offset += rt;
|
|
|
|
if (this.session.localAuthentication.type == _AuthenticationType["default"].Host) {
|
|
if (authPacket.command == _IIPAuthPacketCommand["default"].Declare) {
|
|
this.session.remoteAuthentication.method = authPacket.remoteMethod;
|
|
|
|
if (authPacket.remoteMethod == _AuthenticationMethod["default"].Credentials && authPacket.localMethod == _AuthenticationMethod["default"].None) {
|
|
try {
|
|
this.server.membership.userExists(authPacket.remoteUsername, authPacket.domain).then(function (x) {
|
|
if (x) {
|
|
_this2.session.remoteAuthentication.username = authPacket.remoteUsername;
|
|
_this2.remoteNonce = authPacket.remoteNonce;
|
|
_this2.session.remoteAuthentication.domain = authPacket.domain;
|
|
|
|
_this2.sendParams().addUint8(0xa0).addUint8Array(_this2.localNonce).done();
|
|
} else {
|
|
_this2.sendParams().addUint8(0xc0).addUint8(_ExceptionCode["default"].UserOrTokenNotFound).addUint16(14).addString("User not found").done();
|
|
}
|
|
});
|
|
} catch (ex) {
|
|
console.log(ex);
|
|
|
|
var errMsg = _DC.DC.stringToBytes(ex.message);
|
|
|
|
this.sendParams().addUint8(0xc0).addUint8(_ExceptionCode["default"].GeneralFailure).addUint16(errMsg.length).addUint8Array(errMsg).done();
|
|
}
|
|
} else if (authPacket.remoteMethod == _AuthenticationMethod["default"].Token && authPacket.localMethod == _AuthenticationMethod["default"].None) {
|
|
try {
|
|
// Check if user and token exists
|
|
this.server.membership.tokenExists(authPacket.remoteTokenIndex, authPacket.domain).then(function (x) {
|
|
if (x != null) {
|
|
_this2.session.remoteAuthentication.username = x;
|
|
_this2.session.remoteAuthentication.tokenIndex = authPacket.remoteTokenIndex;
|
|
_this2.remoteNonce = authPacket.remoteNonce;
|
|
_this2.session.remoteAuthentication.domain = authPacket.domain;
|
|
|
|
_this2.sendParams().addUint8(0xa0).addUint8Array(_this2.localNonce).done();
|
|
} else {
|
|
//Console.WriteLine("User not found");
|
|
_this2.sendParams().addUint8(0xc0).addUint8(_ExceptionCode["default"].UserOrTokenNotFound).addUint16(15).addString("Token not found").done();
|
|
}
|
|
});
|
|
} catch (ex) {
|
|
console.log(ex);
|
|
|
|
var errMsg = _DC.DC.stringToBytes(ex.message);
|
|
|
|
this.sendParams().addUint8(0xc0).addUint8(_ExceptionCode["default"].GeneralFailure).addUint16(errMsg.length).addUint8Array(errMsg).done();
|
|
}
|
|
} else if (authPacket.remoteMethod == _AuthenticationMethod["default"].None && authPacket.localMethod == _AuthenticationMethod["default"].None) {
|
|
try {
|
|
var _this$server;
|
|
|
|
// Check if guests are allowed
|
|
if ((_this$server = this.server) !== null && _this$server !== void 0 && _this$server.membership.guestsAllowed) {
|
|
this.session.remoteAuthentication.username = "g-" + Math.random().toString(36).substring(10);
|
|
this.session.remoteAuthentication.domain = authPacket.domain;
|
|
this.readyToEstablish = true;
|
|
this.sendParams().addUint8(0x80).done();
|
|
} else {
|
|
this.sendParams().addUInt8(0xc0).addUint8(_ExceptionCode["default"].AccessDenied).addUint16(18).addString("Guests not allowed").done();
|
|
}
|
|
} catch (ex) {
|
|
var errMsg = _DC.DC.stringToBytes(ex.message);
|
|
|
|
this.sendParams().addUInt8(0xc0).addUint8(_ExceptionCode["default"].GeneralFailure).addUint16(errMsg.length).addUint8Array(errMsg).done();
|
|
}
|
|
}
|
|
} else if (authPacket.command == _IIPAuthPacketCommand["default"].Action) {
|
|
if (authPacket.action == _IIPAuthPacketAction["default"].AuthenticateHash) {
|
|
var remoteHash = authPacket.hash;
|
|
var reply = null;
|
|
|
|
try {
|
|
if (this.session.remoteAuthentication.method == _AuthenticationMethod["default"].Credentials) {
|
|
reply = this.server.membership.getPassword(this.session.remoteAuthentication.username, this.session.remoteAuthentication.domain);
|
|
} else if (this.session.remoteAuthentication.method == _AuthenticationMethod["default"].Token) {
|
|
reply = this.server.membership.getToken(this.session.remoteAuthentication.tokenIndex, this.session.remoteAuthentication.domain);
|
|
} else {// Error
|
|
}
|
|
|
|
reply.then(function (pw) {
|
|
if (pw != null) {
|
|
var hash = _SHA["default"].compute((0, _DC.BL)().addUint8Array(pw).addUint8Array(_this2.remoteNonce).addUint8Array(_this2.localNonce).toArray());
|
|
|
|
if (hash.sequenceEqual(remoteHash)) {
|
|
// send our hash
|
|
var localHash = _SHA["default"].compute((0, _DC.BL)().addUint8Array(_this2.localNonce).addUint8Array(_this2.remoteNonce).addUint8Array(pw).toArray());
|
|
|
|
_this2.sendParams().addUint8(0).addUint8Array(localHash).done();
|
|
|
|
_this2.readyToEstablish = true;
|
|
} else {
|
|
_this2.sendParams().addUint8(0xc0).addUint8(_ExceptionCode["default"].AccessDenied).addUint16(13).addString("Access Denied").done();
|
|
}
|
|
}
|
|
});
|
|
} catch (ex) {
|
|
console.log(ex);
|
|
|
|
var errMsg = _DC.DC.stringToBytes(ex.message);
|
|
|
|
this.sendParams().addUint8(0xc0).addUint8(_ExceptionCode["default"].GeneralFailure).addUint16(errMsg.length).addUint8Array(errMsg).done();
|
|
}
|
|
} else if (authPacket.action == _IIPAuthPacketAction["default"].NewConnection) {
|
|
if (this.readyToEstablish) {
|
|
this.session.Id = this.generateNonce(32);
|
|
this.sendParams().addUint8(0x28).addUint8Array(this.session.Id).done();
|
|
|
|
if (this.instance == null) {
|
|
_Warehouse["default"].put(this.localUsername, this, null, this.server).then(function (x) {
|
|
var _this2$openReply, _this2$server;
|
|
|
|
_this2.ready = true;
|
|
(_this2$openReply = _this2.openReply) === null || _this2$openReply === void 0 ? void 0 : _this2$openReply.trigger(true);
|
|
|
|
_this2._emit("ready", _this2);
|
|
|
|
(_this2$server = _this2.server) === null || _this2$server === void 0 ? void 0 : _this2$server.membership.login(_this2.session);
|
|
}).error(function (x) {
|
|
var _this2$openReply2;
|
|
|
|
(_this2$openReply2 = _this2.openReply) === null || _this2$openReply2 === void 0 ? void 0 : _this2$openReply2.triggerError(x);
|
|
});
|
|
} else {
|
|
var _this$openReply, _this$server2;
|
|
|
|
this.ready = true;
|
|
(_this$openReply = this.openReply) === null || _this$openReply === void 0 ? void 0 : _this$openReply.trigger(true);
|
|
|
|
this._emit("ready", this);
|
|
|
|
(_this$server2 = this.server) === null || _this$server2 === void 0 ? void 0 : _this$server2.membership.login(this.session);
|
|
}
|
|
} else {
|
|
this.sendParams().addUint8(0xc0).addUint8(_ExceptionCode["default"].GeneralFailure).addUint16(9).addString("Not ready").done(); // this.close();
|
|
}
|
|
}
|
|
}
|
|
} else if (this.session.localAuthentication.type == _AuthenticationType["default"].Client) {
|
|
if (authPacket.command == _IIPAuthPacketCommand["default"].Acknowledge) {
|
|
if (authPacket.remoteMethod == _AuthenticationMethod["default"].None) {
|
|
// send establish
|
|
this.sendParams().addUint8(0x20).addUint16(0).done();
|
|
} else if (authPacket.remoteMethod == _AuthenticationMethod["default"].Credentials || authPacket.remoteMethod == _AuthenticationMethod["default"].Token) {
|
|
this.remoteNonce = authPacket.remoteNonce; // send our hash
|
|
|
|
var localHash = _SHA["default"].compute((0, _DC.BL)().addUint8Array(this.localPasswordOrToken).addUint8Array(this.localNonce).addUint8Array(this.remoteNonce).toArray());
|
|
|
|
this.sendParams().addUint8(0).addUint8Array(localHash).done();
|
|
}
|
|
} else if (authPacket.command == _IIPAuthPacketCommand["default"].Action) {
|
|
if (authPacket.action == _IIPAuthPacketAction["default"].AuthenticateHash) {
|
|
// check if the server knows my password
|
|
var remoteHash = _SHA["default"].compute((0, _DC.BL)().addUint8Array(this.remoteNonce).addUint8Array(this.localNonce).addUint8Array(this.localPasswordOrToken).toArray());
|
|
|
|
if (remoteHash.sequenceEqual(authPacket.hash)) {
|
|
// send establish request
|
|
//SendParams((byte)0x20, (ushort)0);
|
|
this.sendParams().addUint8(0x20).addUint16(0).done();
|
|
} else {
|
|
this.sendParams().addUint8(0xc0).addUint8(_ExceptionCode["default"].ChallengeFailed).addUint16(16).addString("Challenge Failed").done();
|
|
}
|
|
} else if (authPacket.action == _IIPAuthPacketAction["default"].ConnectionEstablished) {
|
|
var _this$openReply2;
|
|
|
|
this.session.id = authPacket.sessionId;
|
|
this.ready = true;
|
|
(_this$openReply2 = this.openReply) === null || _this$openReply2 === void 0 ? void 0 : _this$openReply2.trigger(true);
|
|
|
|
this._emit("ready", this); // put it in the warehouse
|
|
|
|
|
|
if (this.instance == null) {
|
|
_Warehouse["default"].put(this.localUsername, this, null, this.server).then(function (x) {
|
|
var _this2$openReply3;
|
|
|
|
(_this2$openReply3 = _this2.openReply) === null || _this2$openReply3 === void 0 ? void 0 : _this2$openReply3.trigger(true);
|
|
|
|
_this2._emit("ready", _this2);
|
|
}).error(function (x) {
|
|
var _this2$openReply4;
|
|
|
|
return (_this2$openReply4 = _this2.openReply) === null || _this2$openReply4 === void 0 ? void 0 : _this2$openReply4.triggerError(x);
|
|
});
|
|
} else {
|
|
var _this$openReply3;
|
|
|
|
(_this$openReply3 = this.openReply) === null || _this$openReply3 === void 0 ? void 0 : _this$openReply3.trigger(true);
|
|
|
|
this._emit("ready", this);
|
|
}
|
|
}
|
|
} else if (authPacket.command == _IIPAuthPacketCommand["default"].Error) {
|
|
var _this$openReply4;
|
|
|
|
(_this$openReply4 = this.openReply) === null || _this$openReply4 === void 0 ? void 0 : _this$openReply4.triggerError(new _AsyncException["default"](_ErrorType["default"].Management, authPacket.errorCode, authPacket.errorMessage));
|
|
|
|
this._emit("error", this, authPacket.errorCode, authPacket.errorMessage);
|
|
|
|
this.close();
|
|
}
|
|
} // if (this.session.localAuthentication.type == AuthenticationType.Host) {
|
|
// if (authPacket.command == IIPAuthPacketCommand.Declare) {
|
|
// if (authPacket.remoteMethod == AuthenticationMethod.Credentials
|
|
// && authPacket.localMethod == AuthenticationMethod.None) {
|
|
// console.log("Declare");
|
|
// this.session.remoteAuthentication.username = authPacket.remoteUsername;
|
|
// this.remoteNonce = authPacket.remoteNonce;
|
|
// this.domain = authPacket.domain;
|
|
// this.sendParams().addUint8(0xa0).addUint8Array(this.localNonce).done();
|
|
// }
|
|
// }
|
|
// else if (authPacket.command == IIPAuthPacketCommand.Action) {
|
|
// if (authPacket.action == IIPAuthPacketAction.AuthenticateHash) {
|
|
// var remoteHash = authPacket.hash;
|
|
// this.server.membership.getPassword(this.session.remoteAuthentication.username, this.domain).then(function (pw) {
|
|
// if (pw != null) {
|
|
// //var hash = new DC(sha256.arrayBuffer(BL().addString(pw).addUint8Array(remoteNonce).addUint8Array(this.localNonce).toArray()));
|
|
// var hash = SHA256.compute(BL().addString(pw).addUint8Array(remoteNonce).addUint8Array(this.localNonce).toDC());
|
|
// if (hash.sequenceEqual(remoteHash)) {
|
|
// // send our hash
|
|
// //var localHash = new DC(sha256.arrayBuffer((new BinaryList()).addUint8Array(this.localNonce).addUint8Array(remoteNonce).addUint8Array(pw).toArray()));
|
|
// var localHash = SHA256.compute(BL().addUint8Array(this.localNonce).addUint8Array(remoteNonce).addUint8Array(pw).toDC());
|
|
// this.sendParams().addUint8(0).addUint8Array(localHash).done();
|
|
// this.readyToEstablish = true;
|
|
// }
|
|
// else {
|
|
// // incorrect password
|
|
// this.sendParams().addUint8(0xc0)
|
|
// .addInt32(ExceptionCode.AccessDenied)
|
|
// .addUint16(13)
|
|
// .addString("Access Denied")
|
|
// .done();
|
|
// }
|
|
// }
|
|
// });
|
|
// }
|
|
// else if (authPacket.action == IIPAuthPacketAction.NewConnection) {
|
|
// if (readyToEstablish) {
|
|
// this.session.id = this.generateNonce(32);// new DC(32);
|
|
// //window.crypto.getRandomValues(this.session.id);
|
|
// this.sendParams().addUint8(0x28).addUint8Array(this.session.id).done();
|
|
// this.ready = true;
|
|
// this.openReply.trigger(this);
|
|
// this.openReply = null;
|
|
// //this._emit("ready", this);
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
// else if (this.session.localAuthentication.type == AuthenticationType.Client) {
|
|
// if (authPacket.command == IIPAuthPacketCommand.Acknowledge) {
|
|
// this.remoteNonce = authPacket.remoteNonce;
|
|
// // send our hash
|
|
// var localHash = SHA256.compute(BL().addUint8Array(this.localPasswordOrToken)
|
|
// .addUint8Array(this.localNonce)
|
|
// .addUint8Array(this.remoteNonce).toDC());
|
|
// this.sendParams().addUint8(0).addUint8Array(localHash).done();
|
|
// }
|
|
// else if (authPacket.command == IIPAuthPacketCommand.Action) {
|
|
// if (authPacket.action == IIPAuthPacketAction.AuthenticateHash) {
|
|
// var remoteHash = SHA256.compute(BL().addUint8Array(this.remoteNonce)
|
|
// .addUint8Array(this.localNonce)
|
|
// .addUint8Array(this.localPasswordOrToken).toDC());
|
|
// if (remoteHash.sequenceEqual(authPacket.hash)) {
|
|
// // send establish request
|
|
// this.sendParams().addUint8(0x20).addUint16(0).done();
|
|
// }
|
|
// else {
|
|
// this.sendParams().addUint8(0xc0)
|
|
// .addUint32(ExceptionCode.ChallengeFailed)
|
|
// .addUint16(16)
|
|
// .addString("Challenge Failed")
|
|
// .done();
|
|
// }
|
|
// }
|
|
// else if (authPacket.action == IIPAuthPacketAction.ConnectionEstablished) {
|
|
// this.session.id = authPacket.sessionId;
|
|
// this.ready = true;
|
|
// this.openReply.trigger(this);
|
|
// this.openReply = null;
|
|
// //this._emit("ready", this);
|
|
// }
|
|
// }
|
|
// else if (authPacket.command == IIPAuthPacketCommand.Error) {
|
|
// this.openReply.triggerError(1, authPacket.errorCode, authPacket.errorMessage);
|
|
// this.openReply = null;
|
|
// //this._emit("error", this, authPacket.errorCode, authPacket.errorMessage);
|
|
// this.close();
|
|
// }
|
|
// }
|
|
|
|
}
|
|
}
|
|
|
|
return offset; //if (offset < ends)
|
|
// this.processPacket(msg, offset, ends, data);
|
|
} // dataReceived(data) {
|
|
// var msg = data.read();
|
|
// var offset = 0;
|
|
// var ends = msg.length;
|
|
// var packet = this.packet;
|
|
// //console.log("Data");
|
|
// while (offset < ends) {
|
|
// offset = this.processPacket(msg, offset, ends, data);
|
|
// }
|
|
// }
|
|
|
|
}, {
|
|
key: "_dataReceived",
|
|
value: function _dataReceived(data) {
|
|
var _this$socket;
|
|
|
|
var msg = data.read();
|
|
var offset = 0;
|
|
var ends = msg.length;
|
|
this.socket.hold();
|
|
|
|
try {
|
|
while (offset < ends) {
|
|
offset = this._processPacket(msg, offset, ends, data);
|
|
}
|
|
} catch (ex) {
|
|
console.log(ex);
|
|
}
|
|
|
|
(_this$socket = this.socket) === null || _this$socket === void 0 ? void 0 : _this$socket.unhold();
|
|
}
|
|
}, {
|
|
key: "close",
|
|
value: function close(event) {
|
|
try {
|
|
this.socket.close();
|
|
} catch (_unused) {}
|
|
}
|
|
}, {
|
|
key: "reconnect",
|
|
value: function reconnect() {}
|
|
}, {
|
|
key: "hold",
|
|
value: function hold() {
|
|
this.holdSending = true;
|
|
}
|
|
}, {
|
|
key: "unhold",
|
|
value: function unhold() {
|
|
if (this.holdSending) {
|
|
this.holdSending = false;
|
|
var msg = this.sendBuffer.read();
|
|
if (msg == null || msg.length == 0) return;
|
|
this.socket.sendAll(msg);
|
|
}
|
|
}
|
|
}, {
|
|
key: "trigger",
|
|
value: function trigger(_trigger) {
|
|
if (_trigger == _IResource.ResourceTrigger.Open) {
|
|
if (this.server != null) return new _AsyncReply["default"](true);
|
|
|
|
var _this$instance$attrib = this.instance.attributes.toObject(),
|
|
_this$instance$attrib2 = _this$instance$attrib.domain,
|
|
domain = _this$instance$attrib2 === void 0 ? null : _this$instance$attrib2,
|
|
_this$instance$attrib3 = _this$instance$attrib.secure,
|
|
secure = _this$instance$attrib3 === void 0 ? false : _this$instance$attrib3,
|
|
_this$instance$attrib4 = _this$instance$attrib.username,
|
|
username = _this$instance$attrib4 === void 0 ? null : _this$instance$attrib4,
|
|
_this$instance$attrib5 = _this$instance$attrib.password,
|
|
password = _this$instance$attrib5 === void 0 ? null : _this$instance$attrib5,
|
|
_this$instance$attrib6 = _this$instance$attrib.checkInterval,
|
|
checkInterval = _this$instance$attrib6 === void 0 ? 30 : _this$instance$attrib6,
|
|
_this$instance$attrib7 = _this$instance$attrib.connectionTimeout,
|
|
connectionTimeout = _this$instance$attrib7 === void 0 ? 600 : _this$instance$attrib7,
|
|
_this$instance$attrib8 = _this$instance$attrib.revivingTime,
|
|
revivingTime = _this$instance$attrib8 === void 0 ? 120 : _this$instance$attrib8,
|
|
_this$instance$attrib9 = _this$instance$attrib.tokenIndex,
|
|
tokenIndex = _this$instance$attrib9 === void 0 ? 0 : _this$instance$attrib9,
|
|
_this$instance$attrib10 = _this$instance$attrib.token,
|
|
token = _this$instance$attrib10 === void 0 ? null : _this$instance$attrib10,
|
|
_this$instance$attrib11 = _this$instance$attrib.debug,
|
|
debug = _this$instance$attrib11 === void 0 ? false : _this$instance$attrib11;
|
|
|
|
this.debug = debug;
|
|
this.checkInterval = checkInterval * 1000; // check every 30 seconds
|
|
|
|
this.connectionTimeout = connectionTimeout * 1000; // 10 minutes (4 pings failed)
|
|
|
|
this.revivingTime = revivingTime * 1000; // 2 minutes
|
|
|
|
var host = this.instance.name.split(':');
|
|
var address = host[0];
|
|
var port = host.length > 1 ? parseInt(host[1]) : 10518;
|
|
|
|
if (username != null && password != null) {
|
|
var pw = _DC.DC.stringToBytes(password);
|
|
|
|
return this.connect(_AuthenticationMethod["default"].Credentials, null, address, port, username, null, pw, domain, secure);
|
|
} else if (token != null) {
|
|
var tk = token instanceof Uint8Array ? token : _DC.DC.stringToBytes(token);
|
|
return this.connect(_AuthenticationMethod["default"].Token, null, address, port, null, tokenIndex, tk, domain, secure);
|
|
} else {
|
|
return this.connect(_AuthenticationMethod["default"].None, null, address, port, null, 0, null, domain, secure);
|
|
}
|
|
}
|
|
|
|
return new _AsyncReply["default"](true);
|
|
}
|
|
}, {
|
|
key: "connect",
|
|
value: function connect() {
|
|
var method = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _AuthenticationMethod["default"].Certificate;
|
|
var socket = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
|
var hostname = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
|
|
var port = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
|
|
var username = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
|
|
var tokenIndex = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
|
|
var passwordOrToken = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;
|
|
var domain = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : null;
|
|
var secure = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : false;
|
|
if (this.openReply != null) throw new _AsyncException["default"](_ErrorType["default"].Exception, 0, "Connection in progress");
|
|
this.openReply = new _AsyncReply["default"]();
|
|
|
|
if (hostname != null) {
|
|
this.session = new _Session["default"](new _ClientAuthentication["default"](), new _HostAuthentication["default"]());
|
|
this.session.localAuthentication.method = method;
|
|
this.session.localAuthentication.tokenIndex = tokenIndex;
|
|
this.session.localAuthentication.domain = domain;
|
|
this.session.localAuthentication.username = username;
|
|
this.localPasswordOrToken = passwordOrToken;
|
|
}
|
|
|
|
if (this.session == null) throw new _AsyncException["default"](_ErrorType["default"].Exception, 0, "Session not initialized");
|
|
if (socket == null) socket = new _WSocket["default"](); // TCPSocket();
|
|
|
|
if (port > 0) this._port = port;
|
|
if (hostname != null) this._hostname = hostname;
|
|
if (secure != null) this._secure = secure;
|
|
var self = this;
|
|
socket.connect(this._hostname, this._port, this._secure).then(function (x) {
|
|
self.assign(socket);
|
|
}).error(function (x) {
|
|
var _self$openReply;
|
|
|
|
(_self$openReply = self.openReply) === null || _self$openReply === void 0 ? void 0 : _self$openReply.triggerError(x);
|
|
self.openReply = null;
|
|
});
|
|
return this.openReply; // //connect(secure, method, hostname, port, username, tokenIndex, passwordOrToken, domain) {
|
|
// this.openReply = new AsyncReply();
|
|
// if (secure !== undefined) {
|
|
// this.session.localAuthentication.method = method;
|
|
// this.session.localAuthentication.tokenIndex = tokenIndex;
|
|
// this.session.localAuthentication.domain = domain;
|
|
// this.session.localAuthentication.username = username;
|
|
// this.localPasswordOrToken = passwordOrToken;
|
|
// //this.url = `ws${secure ? 's' : ''}://${this.instance.name}`;
|
|
// this.url = `ws${secure ? 's' : ''}://${hostname}:${port}`;
|
|
// let socket = new WebSocket(this.url, "iip");
|
|
// socket.binaryType = "arraybuffer";
|
|
// socket.connection = this;
|
|
// this.assign(socket);
|
|
// return this.openReply;
|
|
// }
|
|
}
|
|
}, {
|
|
key: "_declare",
|
|
value: function _declare() {
|
|
// declare (Credentials -> No Auth, No Enctypt)
|
|
var dmn = _DC.DC.stringToBytes(this.session.localAuthentication.domain);
|
|
|
|
if (this.session.localAuthentication.method == _AuthenticationMethod["default"].Credentials) {
|
|
var un = _DC.DC.stringToBytes(this.session.localAuthentication.username);
|
|
|
|
this.sendParams().addUint8(0x60).addUint8(dmn.length).addUint8Array(dmn).addUint8Array(this.localNonce).addUint8(un.length).addUint8Array(un).done();
|
|
} else if (this.session.localAuthentication.method == _AuthenticationMethod["default"].Token) {
|
|
this.sendParams().addUint8(0x70).addUint8(dmn.length).addUint8Array(dmn).addUint8Array(this.localNonce).addUint64(this.session.localAuthentication.tokenIndex).done();
|
|
} else if (this.session.localAuthentication.method == _AuthenticationMethod["default"].None) {
|
|
this.sendParams().addUint8(0x40).addUint8(dmn.length).addUint8Array(dmn).done();
|
|
}
|
|
}
|
|
}, {
|
|
key: "assign",
|
|
value: function assign(socket) {
|
|
this.socket = socket;
|
|
socket.receiver = this; // this.session.remoteAuthentication.source.attributes[SourceAttributeType.IPv4] = socket.RemoteEndPoint.Address;
|
|
// this.session.remoteAuthentication.source.attributes[SourceAttributeType.Port] = socket.RemoteEndPoint.Port;
|
|
// this.session.localAuthentication.source.attributes[SourceAttributeType.IPv4] = socket.LocalEndPoint.Address;
|
|
// this.session.localAuthentication.source.attributes[SourceAttributeType.Port] = socket.LocalEndPoint.Port;
|
|
|
|
if (socket.state == _SocketState["default"].Established && this.session.localAuthentication.type == _AuthenticationType["default"].Client) this._declare();
|
|
}
|
|
}, {
|
|
key: "_unsubscribeAll",
|
|
value: function _unsubscribeAll() {
|
|
var _iterator = _createForOfIteratorHelper(this.subscriptions.keys()),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var _resource = _step.value;
|
|
|
|
_resource.instance.off("EventOccurred", _classPrivateFieldGet(this, _instance_eventOccurred), this);
|
|
|
|
_resource.instance.off("PropertyModified", _classPrivateFieldGet(this, _instance_propertyModified), this);
|
|
|
|
_resource.instance.off("ResourceDestroyed", _classPrivateFieldGet(this, _instance_resourceDestroyed), this);
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
|
|
this.subscriptions.clear();
|
|
}
|
|
}, {
|
|
key: "destroy",
|
|
value: function destroy() {
|
|
this._unsubscribeAll();
|
|
|
|
_get(_getPrototypeOf(DistributedConnection.prototype), "destroy", this).call(this);
|
|
}
|
|
}, {
|
|
key: "networkClose",
|
|
value: function networkClose(socket) {
|
|
var _this$server3;
|
|
|
|
this.readyToEstablish = false;
|
|
|
|
try {
|
|
this.requests.values.forEach(function (x) {
|
|
return x.triggerError(new _AsyncException["default"](_ErrorType["default"].Management, 0, "Connection closed"));
|
|
});
|
|
this.resourceRequests.values.forEach(function (x) {
|
|
return x.triggerError(new _AsyncException["default"](_ErrorType["default"].Management, 0, "Connection closed"));
|
|
});
|
|
this.templateRequests.values.forEach(function (x) {
|
|
return x.triggerError(new _AsyncException["default"](_ErrorType["default"].Management, 0, "Connection closed"));
|
|
});
|
|
} catch (ex) {// unhandled error
|
|
}
|
|
|
|
this.requests.clear();
|
|
this.resourceRequests.clear();
|
|
this.templateRequests.clear();
|
|
this.resources.values.forEach(function (x) {
|
|
return x._suspend();
|
|
});
|
|
|
|
this._unsubscribeAll();
|
|
|
|
_Warehouse["default"].remove(this);
|
|
|
|
if (this.ready) (_this$server3 = this.server) === null || _this$server3 === void 0 ? void 0 : _this$server3.membership.logout(this.session);
|
|
this.ready = false;
|
|
|
|
this._emit("close", this);
|
|
}
|
|
}, {
|
|
key: "networkConnect",
|
|
value: function networkConnect(socket) {
|
|
if (this.session.localAuthentication.Type == _AuthenticationType["default"].Client) this._declare();
|
|
|
|
this._emit("connect", this);
|
|
}
|
|
}, {
|
|
key: "networkReceive",
|
|
value: function networkReceive(sender, buffer) {
|
|
try {
|
|
// Unassigned ?
|
|
if (this.socket == null) return; // Closed ?
|
|
|
|
if (this.socket.state == _SocketState["default"].Closed) return; //this.lastAction = DateTime.Now;
|
|
|
|
if (!this.processing) {
|
|
this.processing = true;
|
|
|
|
try {
|
|
while (buffer.available > 0 && !buffer["protected"]) {
|
|
//console.log("RX", buffer.length );
|
|
this._dataReceived(buffer);
|
|
}
|
|
} catch (_unused2) {}
|
|
|
|
this.processing = false;
|
|
}
|
|
} catch (ex) {
|
|
console.log(ex); //Global.Log("NetworkConnection", LogType.Warning, ex.ToString());
|
|
}
|
|
}
|
|
}, {
|
|
key: "put",
|
|
value: function put(resource) {
|
|
this.resources.add(parseInt(resource.instance.name), resource);
|
|
return new _AsyncReply["default"](true);
|
|
}
|
|
}, {
|
|
key: "remove",
|
|
value: function remove(resource) {// nothing to do (IStore interface)
|
|
} // Protocol Implementation
|
|
|
|
}, {
|
|
key: "sendRequest",
|
|
value: function sendRequest(action) {
|
|
var reply = new _AsyncReply["default"]();
|
|
this.callbackCounter++;
|
|
this.requests.set(this.callbackCounter, reply);
|
|
return this.sendParams(reply).addUint8(0x40 | action).addUint32(this.callbackCounter);
|
|
}
|
|
}, {
|
|
key: "sendDetachRequest",
|
|
value: function sendDetachRequest(instanceId) {
|
|
try {
|
|
return this.sendRequest(_IIPPacketAction["default"].DetachResource).addUint32(instanceId).done();
|
|
} catch (ex) {
|
|
return null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "sendInvoke",
|
|
value: function sendInvoke(instanceId, index, parameters) {
|
|
var reply = new _AsyncReply["default"]();
|
|
|
|
var pb = _Codec["default"].compose(parameters, this);
|
|
|
|
var callbackId = ++this.callbackCounter;
|
|
this.sendParams().addUint8(0x40 | _IIPPacketAction["default"].InvokeFunction).addUint32(callbackId).addUint32(instanceId).addUint8(index).addUint8Array(pb).done();
|
|
this.requests.set(callbackId, reply);
|
|
return reply;
|
|
}
|
|
}, {
|
|
key: "sendError",
|
|
value: function sendError(type, callbackId, errorCode) {
|
|
var errorMessage = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : "";
|
|
|
|
var msg = _DC.DC.stringToBytes(errorMessage);
|
|
|
|
if (type == _ErrorType["default"].Management) this.sendParams().addUint8(0xC0 | _IIPPacketReport["default"].ManagementError).addUint32(callbackId).addUint16(errorCode).done();else if (type == _ErrorType["default"].Exception) this.sendParams().addUint8(0xC0 | _IIPPacketReport["default"].ExecutionError).addUint32(callbackId).addUint16(errorCode).addUint16(msg.length).addUint8Array(msg).done();
|
|
}
|
|
}, {
|
|
key: "sendProgress",
|
|
value: function sendProgress(callbackId, value, max) {
|
|
this.sendParams().addUint8(0xC0 | _IIPPacketReport["default"].ProgressReport).addUint32(callbackId).addInt32(value).addInt32(max).done();
|
|
}
|
|
}, {
|
|
key: "sendChunk",
|
|
value: function sendChunk(callbackId, chunk) {
|
|
var c = _Codec["default"].compose(chunk, this);
|
|
|
|
this.sendParams().addUint8(0xC0 | _IIPPacketReport["default"].ChunkStream).addUint32(callbackId).addUint8Array(c).done();
|
|
}
|
|
}, {
|
|
key: "IIPReply",
|
|
value: function IIPReply(callbackId) {
|
|
var results = Array.prototype.slice.call(arguments, 1);
|
|
var req = this.requests.item(callbackId);
|
|
this.requests.remove(callbackId);
|
|
req.trigger(results);
|
|
}
|
|
}, {
|
|
key: "IIPReplyInvoke",
|
|
value: function IIPReplyInvoke(callbackId, dataType, data) {
|
|
var req = this.requests.item(callbackId);
|
|
|
|
if (req != null) {
|
|
this.requests.remove(callbackId);
|
|
|
|
_Codec["default"].parse(data, 0, this, dataType).reply.then(function (rt) {
|
|
req.trigger(rt);
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "IIPReportError",
|
|
value: function IIPReportError(callbackId, errorType, errorCode, errorMessage) {
|
|
var req = this.requests.item(callbackId);
|
|
|
|
if (req != null) {
|
|
this.requests.remove(callbackId);
|
|
req.triggerError(errorType, errorCode, errorMessage);
|
|
}
|
|
}
|
|
}, {
|
|
key: "IIPReportProgress",
|
|
value: function IIPReportProgress(callbackId, type, value, max) {
|
|
var req = this.requests.item(callbackId);
|
|
if (req != null) req.triggerProgress(type, value, max);
|
|
}
|
|
}, {
|
|
key: "IIPReportChunk",
|
|
value: function IIPReportChunk(callbackId, dataType, data) {
|
|
var req = this.requests.item(callbackId);
|
|
|
|
if (req != null) {
|
|
_Codec["default"].parse(data, 0, this, dataType).reply.then(function (x) {
|
|
req.triggerChunk(x);
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "IIPEventResourceReassigned",
|
|
value: function IIPEventResourceReassigned(resourceId, newResourceId) {}
|
|
}, {
|
|
key: "IIPEventResourceDestroyed",
|
|
value: function IIPEventResourceDestroyed(resourceId) {
|
|
if (this.resources.item(resourceId)) {
|
|
var r = this.resources.item(resourceId);
|
|
this.resources.remove(resourceId);
|
|
r.destroy();
|
|
}
|
|
}
|
|
}, {
|
|
key: "IIPEventPropertyUpdated",
|
|
value: function IIPEventPropertyUpdated(resourceId, index, dataType, data) {
|
|
var self = this;
|
|
this.fetch(resourceId).then(function (r) {
|
|
var pt = r.instance.template.getPropertyTemplateByIndex(index);
|
|
if (pt == null) return; // ft found, fi not found, this should never happen
|
|
// push to the queue to gaurantee serialization
|
|
|
|
var item = new _AsyncReply["default"]();
|
|
self.queue.add(item);
|
|
|
|
_Codec["default"].parse(data, 0, self, dataType).reply.then(function (args) {
|
|
item.trigger(new _DistributedResourceQueueItem["default"](r, _DistributedResourceQueueItemType["default"].Propery, args, index));
|
|
}).error(function (ex) {
|
|
self.queue.remove(item);
|
|
console.log("Esiur Property Error", ex);
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPEventEventOccurred",
|
|
value: function IIPEventEventOccurred(resourceId, index, dataType, data) {
|
|
var self = this;
|
|
this.fetch(resourceId).then(function (r) {
|
|
var et = r.instance.template.getEventTemplateByIndex(index);
|
|
if (et == null) return; // ft found, fi not found, this should never happen
|
|
// push to the queue to guarantee serialization
|
|
|
|
var item = new _AsyncReply["default"]();
|
|
self.queue.add(item); // Codec.parseVarArray(content, 0, content.length, self).then(function (args) {
|
|
|
|
_Codec["default"].parse(data, 0, self, dataType).reply.then(function (args) {
|
|
item.trigger(new _DistributedResourceQueueItem["default"](r, _DistributedResourceQueueItemType["default"].Event, args, index));
|
|
}).error(function (ex) {
|
|
self.queue.remove(item);
|
|
console.log("Esiur Event Error", ex);
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPEventChildAdded",
|
|
value: function IIPEventChildAdded(resourceId, childId) {
|
|
var self = this;
|
|
this.fetch(resourceId).then(function (parent) {
|
|
self.fetch(childId).then(function (child) {
|
|
parent.instance.children.add(child);
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPEventChildRemoved",
|
|
value: function IIPEventChildRemoved(resourceId, childId) {
|
|
var self = this;
|
|
this.fetch(resourceId).then(function (parent) {
|
|
self.fetch(childId).then(function (child) {
|
|
parent.instance.children.remove(child);
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPEventRenamed",
|
|
value: function IIPEventRenamed(resourceId, name) {
|
|
this.fetch(resourceId).then(function (resource) {
|
|
resource.instance.attributes.set("name", name);
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPEventAttributesUpdated",
|
|
value: function IIPEventAttributesUpdated(resourceId, attributes) {
|
|
var self = this;
|
|
this.fetch(resourceId).then(function (resource) {
|
|
var attrs = attributes.getStringArray(0, attributes.length);
|
|
self.getAttributes(resource, attrs).then(function (s) {
|
|
resource.instance.setAttributes(s);
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "sendReply",
|
|
value: function sendReply(action, callbackId) {
|
|
return this.sendParams().addUint8(0x80 | action).addUint32(callbackId);
|
|
}
|
|
}, {
|
|
key: "sendEvent",
|
|
value: function sendEvent(evt) {
|
|
return this.sendParams().addUint8(evt);
|
|
}
|
|
}, {
|
|
key: "sendListenRequest",
|
|
value: function sendListenRequest(instanceId, index) {
|
|
var reply = new _AsyncReply["default"]();
|
|
var callbackId = ++this.callbackCounter;
|
|
this.sendParams().addUint8(0x40 | _IIPPacketAction["default"].Listen).addUint32(callbackId).addUint32(instanceId).addUint8(index).done();
|
|
this.requests.set(callbackId, reply);
|
|
return reply;
|
|
}
|
|
}, {
|
|
key: "sendUnlistenRequest",
|
|
value: function sendUnlistenRequest(instanceId, index) {
|
|
var reply = new _AsyncReply["default"]();
|
|
var callbackId = ++this.callbackCounter;
|
|
this.sendParams().addUint8(0x40 | _IIPPacketAction["default"].Unlisten).addUint32(callbackId).addUint32(instanceId).addUint8(index).done();
|
|
this.requests.set(callbackId, reply);
|
|
return reply;
|
|
}
|
|
}, {
|
|
key: "IIPRequestAttachResource",
|
|
value: function IIPRequestAttachResource(callback, resourceId) {
|
|
//var sl = this.sendParams();
|
|
var self = this;
|
|
|
|
_Warehouse["default"].getById(resourceId).then(function (r) {
|
|
if (r != null) {
|
|
if (r.instance.applicable(self.session, _ActionType["default"].Attach, null) == _Ruling["default"].Denied) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].AttachDenied);
|
|
return;
|
|
}
|
|
|
|
self._unsubscribe(r); // reply ok
|
|
|
|
|
|
var link = _DC.DC.stringToBytes(r.instance.link);
|
|
|
|
if (r instanceof _DistributedResource["default"]) self.sendReply(_IIPPacketAction["default"].AttachResource, callback).addUint8Array(r.instance.template.classId.value).addUint64(r.instance.age).addUint16(link.length).addUint8Array(link).addUint8Array(_Codec["default"].compose(r._serialize(), self)).done();else self.sendReply(_IIPPacketAction["default"].AttachResource, callback).addUint8Array(r.instance.template.classId.value).addUint64(r.instance.age).addUint16(link.length).addUint8Array(link).addUint8Array(_Codec["default"].compose(r.instance.serialize(), self)).done();
|
|
|
|
self._subscribe(r);
|
|
} else {
|
|
// reply failed
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "_subscribe",
|
|
value: function _subscribe(resource) {
|
|
resource.instance.on("EventOccurred", _classPrivateFieldGet(this, _instance_eventOccurred), this);
|
|
resource.instance.on("PropertyModified", _classPrivateFieldGet(this, _instance_propertyModified), this);
|
|
resource.instance.on("ResourceDestroyed", _classPrivateFieldGet(this, _instance_resourceDestroyed), this);
|
|
this.subscriptions.set(resource, []);
|
|
}
|
|
}, {
|
|
key: "_unsubscribe",
|
|
value: function _unsubscribe(resource) {
|
|
resource.instance.off("EventOccurred", _classPrivateFieldGet(this, _instance_eventOccurred), this);
|
|
resource.instance.off("PropertyModified", _classPrivateFieldGet(this, _instance_propertyModified), this);
|
|
resource.instance.off("ResourceDestroyed", _classPrivateFieldGet(this, _instance_resourceDestroyed), this);
|
|
this.subscriptions["delete"](resource);
|
|
}
|
|
}, {
|
|
key: "IIPRequestReattachResource",
|
|
value: function IIPRequestReattachResource(callback, resourceId, resourceAge) {
|
|
var self = this;
|
|
|
|
_Warehouse["default"].getById(resourceId).then(function (r) {
|
|
if (r != null) {
|
|
self._unsubscribe(r);
|
|
|
|
self._subscribe(r); // reply ok
|
|
|
|
|
|
self.sendReply(_IIPPacketAction["default"].ReattachResource, callback).addUint64(r.instance.age).addUint8Array(_Codec["default"].compose(r.instance.serialize(), self)).done();
|
|
} else {
|
|
// reply failed
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPRequestDetachResource",
|
|
value: function IIPRequestDetachResource(callback, resourceId) {
|
|
var self = this;
|
|
|
|
_Warehouse["default"].getById(resourceId).then(function (r) {
|
|
if (r != null) {
|
|
self._unsubscribe(r); // reply ok
|
|
|
|
|
|
self.sendReply(_IIPPacketAction["default"].DetachResource, callback).done();
|
|
} else {
|
|
// reply failed
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPRequestCreateResource",
|
|
value: function IIPRequestCreateResource(callback, storeId, parentId, content) {
|
|
var self = this;
|
|
|
|
_Warehouse["default"].getById(storeId).then(function (store) {
|
|
if (store == null) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].StoreNotFound);
|
|
return;
|
|
}
|
|
|
|
if (!(store instanceof _IStore2["default"])) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceIsNotStore);
|
|
return;
|
|
} // check security
|
|
|
|
|
|
if (store.instance.applicable(self.session, _ActionType["default"].CreateResource, null) != _Ruling["default"].Allowed) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].CreateDenied);
|
|
return;
|
|
}
|
|
|
|
_Warehouse["default"].getById(parentId).then(function (parent) {
|
|
// check security
|
|
if (parent != null) if (parent.instance.applicable(self.session, _ActionType["default"].AddChild, null) != _Ruling["default"].Allowed) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].AddChildDenied);
|
|
return;
|
|
}
|
|
var offset = 0;
|
|
var className = content.getString(offset + 1, content[0]);
|
|
offset += 1 + content[0];
|
|
var nameLength = content.getUint16(offset);
|
|
offset += 2;
|
|
var name = content.getString(offset, nameLength);
|
|
var cl = content.getUint32(offset);
|
|
offset += 4;
|
|
var type = window[className];
|
|
|
|
if (type == null) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ClassNotFound);
|
|
return;
|
|
}
|
|
|
|
DataDeserializer.listParser(content, offset, cl, self).then(function (parameters) {
|
|
offset += cl;
|
|
cl = content.getUint32(offset);
|
|
DataDeserializer.typedMapParser(content, offset, cl, self).then(function (attributes) {
|
|
offset += cl;
|
|
cl = content.length - offset;
|
|
DataDeserializer.typedMapParser(content, offset, cl, self).then(function (values) {
|
|
var resource = new (Function.prototype.bind.apply(type, values))();
|
|
|
|
_Warehouse["default"].put(name, resource, store, parent).then(function (ok) {
|
|
self.sendReply(_IIPPacketAction["default"].CreateResource, callback).addUint32(resource.Instance.Id).done();
|
|
}).error(function (ex) {
|
|
// send some error
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].AddToStoreFailed);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPRequestDeleteResource",
|
|
value: function IIPRequestDeleteResource(callback, resourceId) {
|
|
var self = this;
|
|
|
|
_Warehouse["default"].getById(resourceId).then(function (r) {
|
|
if (r == null) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);
|
|
return;
|
|
}
|
|
|
|
if (r.instance.store.instance.applicable(session, _ActionType["default"].Delete, null) != _Ruling["default"].Allowed) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].DeleteDenied);
|
|
return;
|
|
}
|
|
|
|
if (_Warehouse["default"].remove(r)) self.sendReply(_IIPPacketAction["default"].DeleteResource, callback).done();else self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].DeleteFailed);
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPRequestLinkTemplates",
|
|
value: function IIPRequestLinkTemplates(callback, resourceLink) {
|
|
var _this3 = this,
|
|
_this$server4;
|
|
|
|
var queryCallback = function queryCallback(r) {
|
|
if (r == null) _this3.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);else {
|
|
var list = r.filter(function (x) {
|
|
return x.instance.applicable(_this3.session, _ActionType["default"].ViewTemplate, null) != _Ruling["default"].Denied;
|
|
});
|
|
if (list.length == 0) _this3.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);else {
|
|
// get all templates related to this resource
|
|
var msg = new BinaryList();
|
|
var templates = [];
|
|
|
|
for (var i = 0; i < list.length; i++) {
|
|
templates = templates.concat(_TypeTemplate["default"].getDependencies(list[i].instance.template).filter(function (x) {
|
|
return !templates.includes(x);
|
|
}));
|
|
}
|
|
|
|
for (var i = 0; i < templates.length; i++) {
|
|
msg.addInt32(templates[i].content.length).addUint8Array(templates[i].content);
|
|
} // send
|
|
|
|
|
|
_this3.sendReply(_IIPPacketAction["default"].LinkTemplates, callback).addDC(_TransmissionType.TransmissionType.compose(_TransmissionType.TransmissionTypeIdentifier.RawData, msg)).done();
|
|
}
|
|
}
|
|
};
|
|
|
|
if (((_this$server4 = this.server) === null || _this$server4 === void 0 ? void 0 : _this$server4.entryPoint) != null) this.server.entryPoint.query(resourceLink, this).then(queryCallback);else _Warehouse["default"].query(resourceLink).then(queryCallback);
|
|
}
|
|
}, {
|
|
key: "IIPRequestTemplateFromClassName",
|
|
value: function IIPRequestTemplateFromClassName(callback, className) {
|
|
var self = this;
|
|
|
|
var t = _Warehouse["default"].getTemplateByClassName(className);
|
|
|
|
if (t != null) {
|
|
self.sendReply(_IIPPacketAction["default"].TemplateFromClassName, callback).addUint32(t.content.length).addUint8Array(t.content).done();
|
|
} else {
|
|
// reply failed
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].TemplateNotFound);
|
|
}
|
|
}
|
|
}, {
|
|
key: "IIPRequestTemplateFromClassId",
|
|
value: function IIPRequestTemplateFromClassId(callback, classId) {
|
|
var self = this;
|
|
|
|
var t = _Warehouse["default"].getTemplateByClassId(classId);
|
|
|
|
if (t != null) self.sendReply(_IIPPacketAction["default"].TemplateFromClassId, callback).addDC(_TransmissionType.TransmissionType.compose(_TransmissionType.TransmissionTypeIdentifier.RawData, t.content)).done();else {
|
|
// reply failed
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].TemplateNotFound);
|
|
}
|
|
}
|
|
}, {
|
|
key: "IIPRequestTemplateFromResourceId",
|
|
value: function IIPRequestTemplateFromResourceId(callback, resourceId) {
|
|
var self = this;
|
|
|
|
_Warehouse["default"].getById(resourceId).then(function (r) {
|
|
if (r != null) self.sendReply(_IIPPacketAction["default"].TemplateFromResourceId, callback).addDC(_TransmissionType.TransmissionType.compose(_TransmissionType.TransmissionTypeIdentifier.RawData, r.instance.template.content)).done();else {
|
|
// reply failed
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].TemplateNotFound);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPRequestInvokeFunction",
|
|
value: function IIPRequestInvokeFunction(callback, resourceId, index, dataType, data) {
|
|
var self = this;
|
|
|
|
_Warehouse["default"].getById(resourceId).then(function (r) {
|
|
if (r == null) {
|
|
this.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);
|
|
return;
|
|
}
|
|
|
|
var ft = r.instance.template.getFunctionTemplateByIndex(index);
|
|
|
|
if (ft == null) {
|
|
// no function at this index
|
|
this.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].MethodNotFound);
|
|
return;
|
|
}
|
|
|
|
_Codec["default"].parse(data, 0, self, dataType).reply.then(function (args) {
|
|
if (r instanceof _DistributedResource["default"]) {
|
|
var rt = r._invoke(index, args);
|
|
|
|
if (rt != null) {
|
|
rt.then(function (res) {
|
|
self.sendReply(_IIPPacketAction["default"].InvokeFunction, callback).addUint8Array(_Codec["default"].compose(res, self)).done();
|
|
});
|
|
} else {
|
|
// function not found on a distributed object
|
|
this.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].MethodNotFound);
|
|
return;
|
|
}
|
|
} else {
|
|
var fi = r[ft.name];
|
|
|
|
if (!(fi instanceof Function)) {
|
|
// ft found, fi not found, this should never happen
|
|
this.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].MethodNotFound);
|
|
return;
|
|
}
|
|
|
|
if (r.instance.applicable(self.session, _ActionType["default"].Execute, ft) == _Ruling["default"].Denied) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].InvokeDenied);
|
|
return;
|
|
}
|
|
|
|
var indexedArgs = [];
|
|
|
|
for (var i = 0; i < ft.args.length; i++) {
|
|
indexedArgs.push(args.get(i));
|
|
}
|
|
|
|
indexedArgs.push(self);
|
|
|
|
var _rt;
|
|
|
|
try {
|
|
_rt = fi.apply(r, indexedArgs);
|
|
} catch (ex) {
|
|
self.sendError(_ErrorType["default"].Exception, callback, 0, ex.toString());
|
|
return;
|
|
} // Is iterator ?
|
|
|
|
|
|
if (_rt != null && _rt[Symbol.iterator] instanceof Function) {
|
|
var _iterator2 = _createForOfIteratorHelper(_rt),
|
|
_step2;
|
|
|
|
try {
|
|
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
|
|
var v = _step2.value;
|
|
self.sendChunk(callback, v);
|
|
}
|
|
} catch (err) {
|
|
_iterator2.e(err);
|
|
} finally {
|
|
_iterator2.f();
|
|
}
|
|
|
|
self.sendReply(_IIPPacketAction["default"].InvokeFunction, callback).addUint8(DataType.Void).done();
|
|
} else if (_rt instanceof _AsyncReply["default"]) {
|
|
_rt.then(function (res) {
|
|
self.sendReply(_IIPPacketAction["default"].InvokeFunction, callback).addUint8Array(_Codec["default"].compose(res, self)).done();
|
|
}).error(function (ex) {
|
|
self.sendError(_ErrorType["default"].Exception, callback, ex.code, ex.message);
|
|
}).progress(function (pt, pv, pm) {
|
|
self.sendProgress(callback, pv, pm);
|
|
}).chunk(function (v) {
|
|
self.sendChunk(callback, v);
|
|
});
|
|
} else if (_rt instanceof Promise) {
|
|
_rt.then(function (res) {
|
|
self.sendReply(_IIPPacketAction["default"].InvokeFunction, callback).addUint8Array(_Codec["default"].compose(res, self)).done();
|
|
})["catch"](function (ex) {
|
|
self.sendError(_ErrorType["default"].Exception, callback, 0, ex.toString());
|
|
});
|
|
} else {
|
|
self.sendReply(_IIPPacketAction["default"].InvokeFunction, callback).addUint8Array(_Codec["default"].compose(_rt, self)).done();
|
|
}
|
|
}
|
|
});
|
|
});
|
|
} // IIPRequestGetProperty(callback, resourceId, index) {
|
|
// var self = this;
|
|
// Warehouse.getById(resourceId).then(function (r) {
|
|
// if (r != null) {
|
|
// var pt = r.instance.template.getFunctionTemplateByIndex(index);
|
|
// if (pt != null) {
|
|
// if (r instanceof DistributedResource) {
|
|
// self.sendReply(IIPPacketAction.GetProperty, callback)
|
|
// .addUint8Array(Codec.compose(r._get(pt.index), self))
|
|
// .done();
|
|
// }
|
|
// else {
|
|
// var pv = r[pt.name];
|
|
// self.sendReply(IIPPacketAction.GetProperty)
|
|
// .addUint8Array(Codec.compose(pv, self))
|
|
// .done();
|
|
// }
|
|
// }
|
|
// else {
|
|
// // pt not found
|
|
// }
|
|
// }
|
|
// else {
|
|
// // resource not found
|
|
// }
|
|
// });
|
|
// }
|
|
// IIPRequestGetPropertyIfModifiedSince(callback, resourceId, index, age) {
|
|
// var self = this;
|
|
// Warehouse.getById(resourceId).then(function (r) {
|
|
// if (r != null) {
|
|
// var pt = r.instance.template.getFunctionTemplateByIndex(index);
|
|
// if (pt != null) {
|
|
// if (r.instance.getAge(index) > age) {
|
|
// var pv = r[pt.name];
|
|
// self.sendReply(IIPPacketAction.GetPropertyIfModified, callback)
|
|
// .addUint8Array(Codec.compose(pv, self))
|
|
// .done();
|
|
// }
|
|
// else {
|
|
// self.sendReply(IIPPacketAction.GetPropertyIfModified, callback)
|
|
// .addUint8(DataType.NotModified)
|
|
// .done();
|
|
// }
|
|
// }
|
|
// else {
|
|
// // pt not found
|
|
// }
|
|
// }
|
|
// else {
|
|
// // resource not found
|
|
// }
|
|
// });
|
|
// }
|
|
|
|
}, {
|
|
key: "IIPRequestListen",
|
|
value: function IIPRequestListen(callback, resourceId, index) {
|
|
var self = this;
|
|
|
|
_Warehouse["default"].getById(resourceId).then(function (r) {
|
|
if (r != null) {
|
|
var et = r.instance.template.getEventTemplateByIndex(index);
|
|
|
|
if (et != null) {
|
|
if (r instanceof _DistributedResource["default"]) {
|
|
r.listen(et).then(function (x) {
|
|
self.sendReply(_IIPPacketAction["default"].Listen, callback).done();
|
|
}).error(function (x) {
|
|
return self.sendError(_ErrorType["default"].Exception, callback, _ExceptionCode["default"].GeneralFailure);
|
|
});
|
|
} else {
|
|
if (!self.subscriptions.has(r)) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].NotAttached);
|
|
return;
|
|
}
|
|
|
|
if (self.subscriptions.get(r).includes(index)) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].AlreadyListened);
|
|
return;
|
|
}
|
|
|
|
self.subscriptions.get(r).push(index);
|
|
self.sendReply(_IIPPacketAction["default"].Listen, callback).done();
|
|
}
|
|
} else {
|
|
// pt not found
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].MethodNotFound);
|
|
}
|
|
} else {
|
|
// resource not found
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPRequestUnlisten",
|
|
value: function IIPRequestUnlisten(callback, resourceId, index) {
|
|
var self = this;
|
|
|
|
_Warehouse["default"].getById(resourceId).then(function (r) {
|
|
if (r != null) {
|
|
var et = r.instance.template.getEventTemplateByIndex(index);
|
|
|
|
if (et != null) {
|
|
if (r instanceof _DistributedResource["default"]) {
|
|
r.unlisten(et).then(function (x) {
|
|
self.sendReply(_IIPPacketAction["default"].Unlisten, callback).done();
|
|
}).error(function (x) {
|
|
return self.sendError(_ErrorType["default"].Exception, callback, _ExceptionCode["default"].GeneralFailure);
|
|
});
|
|
} else {
|
|
if (!self.subscriptions.has(r)) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].NotAttached);
|
|
return;
|
|
}
|
|
|
|
if (!self.subscriptions.get(r).includes(index)) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].AlreadyUnlistened);
|
|
return;
|
|
}
|
|
|
|
var ar = self.subscriptions.get(r);
|
|
var i = ar.indexOf(index);
|
|
ar.splice(i, 1);
|
|
self.sendReply(_IIPPacketAction["default"].Unlisten, callback).done();
|
|
}
|
|
} else {
|
|
// pt not found
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].MethodNotFound);
|
|
}
|
|
} else {
|
|
// resource not found
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPRequestSetProperty",
|
|
value: function IIPRequestSetProperty(callback, resourceId, index, dataType, data) {
|
|
var self = this;
|
|
|
|
_Warehouse["default"].getById(resourceId).then(function (r) {
|
|
if (r != null) {
|
|
var pt = r.instance.template.getPropertyTemplateByIndex(index);
|
|
|
|
if (pt != null) {
|
|
_Codec["default"].parse(data, 0, self, dataType).reply.then(function (value) {
|
|
if (r instanceof _DistributedResource["default"]) {
|
|
// propagation
|
|
r._set(index, value).then(function (x) {
|
|
self.sendReply(_IIPPacketAction["default"].SetProperty, callback).done();
|
|
}).error(function (x) {
|
|
self.sendError(x.type, callback, x.code, x.message).done();
|
|
});
|
|
} else {
|
|
if (r.instance.applicable(self.session, _ActionType["default"].SetProperty, pt) == _Ruling["default"].Denied) {
|
|
self.sendError(_AsyncReply["default"].ErrorType.Exception, callback, _ExceptionCode["default"].SetPropertyDenied);
|
|
return;
|
|
}
|
|
|
|
try {
|
|
if (r[pt.name] instanceof _DistributedPropertyContext["default"]) value = new _DistributedPropertyContext["default"](this, value);
|
|
r[pt.name] = value;
|
|
self.sendReply(_IIPPacketAction["default"].SetProperty, callback).done();
|
|
} catch (ex) {
|
|
self.sendError(_AsyncReply["default"].ErrorType.Exception, callback, 0, ex.toString()).done();
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
// property not found
|
|
self.sendError(_AsyncReply["default"].ErrorType.Management, callback, _ExceptionCode["default"].PropertyNotFound).done();
|
|
}
|
|
} else {
|
|
// resource not found
|
|
self.sendError(_AsyncReply["default"].ErrorType.Management, callback, _ExceptionCode["default"].PropertyNotFound).done();
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPRequestInquireResourceHistory",
|
|
value: function IIPRequestInquireResourceHistory(callback, resourceId, fromDate, toDate) {
|
|
var self = this;
|
|
|
|
_Warehouse["default"].getById(resourceId).then(function (r) {
|
|
if (r != null) {
|
|
r.instance.store.getRecord(r, fromDate, toDate).then(function (results) {
|
|
var history = _Codec["default"].composeHistory(results, self, true);
|
|
|
|
self.sendReply(_IIPPacketAction["default"].ResourceHistory, callback).addUint8Array(history).done();
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPRequestQueryResources",
|
|
value: function IIPRequestQueryResources(callback, resourceLink) {
|
|
var _this$server5;
|
|
|
|
var self = this;
|
|
|
|
var queryCallback = function queryCallback(resources) {
|
|
if (resources == null) self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);else {
|
|
var list = resources.filter(function (r) {
|
|
return r.instance.applicable(self.session, _ActionType["default"].Attach, null) != _Ruling["default"].Denied;
|
|
});
|
|
if (list.length == 0) self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);else self.sendReply(_IIPPacketAction["default"].QueryLink, callback).addUint8Array(_Codec["default"].compose(list, self)).done();
|
|
}
|
|
};
|
|
|
|
if (((_this$server5 = this.server) === null || _this$server5 === void 0 ? void 0 : _this$server5.entryPoint) != null) {
|
|
var _this$server6;
|
|
|
|
(_this$server6 = this.server) === null || _this$server6 === void 0 ? void 0 : _this$server6.entryPoint.query(resourceLink, this).then(queryCallback);
|
|
} else {
|
|
_Warehouse["default"].query(resourceLink).then(queryCallback);
|
|
}
|
|
}
|
|
}, {
|
|
key: "create",
|
|
value: function create(store, parent, className, parameters, attributes, values) {
|
|
var reply = new _AsyncReply["default"]();
|
|
|
|
var sb = _DC.DC.stringToBytes(className);
|
|
|
|
var pkt = (0, _DC.BL)().addUint32(store.instance.id).addUint32(parent.instance.id).addUint32(sb.length).addUint8Array(sb).addUint8Array(_Codec["default"].composeVarArray(parameters, this, true)).addUint8Array(_Codec["default"].composeStructure(attributes, this, true, true, true)).addUint8Array(_Codec["default"].composeStructure(values, this));
|
|
pkt.addUint32(pkt.length, 8);
|
|
this.sendRequest(_IIPPacketAction["default"].CreateResource).addUint8Array(pkt.ToArray()).done().then(function (args) {
|
|
var rid = args[0];
|
|
self.fetch(rid).then(function (r) {
|
|
reply.trigger(r);
|
|
});
|
|
});
|
|
return reply;
|
|
}
|
|
}, {
|
|
key: "query",
|
|
value: function query(resourceLink) {
|
|
var reply = new _AsyncReply["default"]();
|
|
var self = this;
|
|
|
|
var sb = _DC.DC.stringToBytes(resourceLink);
|
|
|
|
this.sendRequest(_IIPPacketAction["default"].QueryLink).addUint16(sb.length).addUint8Array(sb).done().then(function (ar) {
|
|
var dataType = ar[0];
|
|
var data = ar[1];
|
|
|
|
_Codec["default"].parse(data, 0, self, dataType).reply.then(function (resources) {
|
|
reply.trigger(resources);
|
|
}).error(function (ex) {
|
|
return reply.triggerError(ex);
|
|
});
|
|
}).error(function (ex) {
|
|
reply.triggerError(ex);
|
|
});
|
|
return reply;
|
|
}
|
|
}, {
|
|
key: "getTemplate",
|
|
value: function getTemplate(classId) {
|
|
if (this.templates.contains(classId)) return new _AsyncReply["default"](this.templates.item(classId));else if (this.templateRequests.contains(classId)) return this.templateRequests.item(classId);
|
|
var reply = new _AsyncReply["default"]();
|
|
this.templateRequests.add(classId.valueOf(), reply);
|
|
var self = this;
|
|
this.sendRequest(_IIPPacketAction["default"].TemplateFromClassId).addUint8Array(classId.value).done().then(function (rt) {
|
|
self.templateRequests.remove(classId);
|
|
self.templates.add(rt[0].classId.valueOf(), rt[0]);
|
|
|
|
_Warehouse["default"].putTemplate(rt[0]);
|
|
|
|
reply.trigger(rt[0]);
|
|
});
|
|
return reply;
|
|
} // IStore interface
|
|
|
|
}, {
|
|
key: "get",
|
|
value: function get(path) {
|
|
var rt = new _AsyncReply["default"]();
|
|
this.query(path).then(function (ar) {
|
|
if (ar != null && ar.length > 0) rt.trigger(ar[0]);else rt.trigger(null);
|
|
}).error(function (ex) {
|
|
rt.triggerError(ex);
|
|
});
|
|
return rt;
|
|
/*
|
|
if (this.pathRequests[path])
|
|
return this.pathRequests[path];
|
|
var reply = new AsyncReply();
|
|
this.pathRequests[path] = reply;
|
|
var bl = new BinaryList();
|
|
bl.addString(path);
|
|
bl.addUint16(bl.length, 0);
|
|
var link = data.get
|
|
var self = this;
|
|
this.sendRequest(IIPPacketAction.ResourceIdFromResourceLink)
|
|
.addUint16(.then(function (rt) {
|
|
delete self.pathRequests[path];
|
|
self.fetch(rt[1]).then(function (r) {
|
|
reply.trigger(r);
|
|
});
|
|
});
|
|
return reply;
|
|
*/
|
|
}
|
|
}, {
|
|
key: "retrieve",
|
|
value: function retrieve(iid) {
|
|
var r = this.resources.item(iid);
|
|
return new _AsyncReply["default"](r); //for (var r in this.resources)
|
|
// if (this.resources[r].instance.id == iid)
|
|
// return new AsyncReply(r);
|
|
//return new AsyncReply(null);
|
|
}
|
|
}, {
|
|
key: "getLinkTemplates",
|
|
value: function getLinkTemplates(link) {
|
|
var reply = new _AsyncReply["default"]();
|
|
|
|
var l = _DC.DC.stringToBytes(link);
|
|
|
|
this.sendRequest(_IIPPacketAction["default"].LinkTemplates).addUint16(l.length).addUint8Array(l).done().then(function (rt) {
|
|
var templates = []; // parse templates
|
|
|
|
var tt = rt[0];
|
|
var data = rt[1]; //var offset = 0;
|
|
|
|
for (var offset = tt.offset; offset < tt.contentLength;) {
|
|
var cs = data.getUint32(offset);
|
|
offset += 4;
|
|
templates.push(_TypeTemplate["default"].parse(data, offset, cs));
|
|
offset += cs;
|
|
}
|
|
|
|
reply.trigger(templates);
|
|
}).error(function (ex) {
|
|
reply.triggerError(ex);
|
|
});
|
|
return reply;
|
|
} // Get a resource from the other end
|
|
|
|
}, {
|
|
key: "fetch",
|
|
value: function fetch(id) {
|
|
var resource = this.resources.item(id);
|
|
var request = this.resourceRequests.item(id);
|
|
|
|
if (request != null) {
|
|
if (resource != null) // dig for dead locks // or not
|
|
return new _AsyncReply["default"](resource);else return request;
|
|
} else if (resource != null && !resource._p.suspended) {
|
|
return new _AsyncReply["default"](resource);
|
|
}
|
|
|
|
var reply = new _AsyncReply["default"]();
|
|
this.resourceRequests.set(id, reply);
|
|
var self = this;
|
|
this.sendRequest(_IIPPacketAction["default"].AttachResource).addUint32(id).done().then(function (rt) {
|
|
var dr;
|
|
|
|
if (resource == null) {
|
|
var template = _Warehouse["default"].getTemplateByClassId(rt[0], _TemplateType["default"].Wrapper);
|
|
|
|
if ((template === null || template === void 0 ? void 0 : template.definedType) != null) dr = new template.getDependencies(self, id, rt[1], rt[2]);else dr = new _DistributedResource["default"](self, id, rt[1], rt[2]);
|
|
} else dr = resource; //let dr = resource || new DistributedResource(self, id, rt[1], rt[2]);
|
|
|
|
|
|
var transmissionType = rt[3];
|
|
var content = rt[4];
|
|
self.getTemplate(rt[0]).then(function (tmp) {
|
|
// ClassId, ResourceAge, ResourceLink, Content
|
|
if (resource == null) {
|
|
var wp = _Warehouse["default"].put(id.toString(), dr, self, null, tmp).then(function (ok) {
|
|
_Codec["default"].parse(content, 0, self, transmissionType).reply.then(function (ar) {
|
|
var pvs = new _PropertyValueArray["default"]();
|
|
|
|
for (var i = 0; i < ar.length; i += 3) {
|
|
pvs.push(new _PropertyValue["default"](ar[i + 2], ar[i], ar[i + 1]));
|
|
}
|
|
|
|
dr._attach(pvs);
|
|
|
|
self.resourceRequests.remove(id);
|
|
reply.trigger(dr);
|
|
}).error(function (ex) {
|
|
return reply.triggerError(ex);
|
|
});
|
|
});
|
|
|
|
wp.error(function (ex) {
|
|
reply.triggerError(ex);
|
|
});
|
|
} else {
|
|
_Codec["default"].parse(content, 0, self, transmissionType).reply.then(function (ar) {
|
|
//print("attached");
|
|
if (results != null) {
|
|
var pvs = new _PropertyValueArray["default"]();
|
|
|
|
for (var i = 0; i < ar.length; i += 3) {
|
|
pvs.push(new _PropertyValue["default"](ar[i + 2], ar[i], ar[i + 1]));
|
|
}
|
|
|
|
dr._attach(pvs);
|
|
}
|
|
|
|
self.resourceRequests.remove(id);
|
|
reply.trigger(dr);
|
|
}).error(function (ex) {
|
|
reply.triggerError(ex);
|
|
});
|
|
}
|
|
}).error(function (ex) {
|
|
reply.triggerError(ex);
|
|
});
|
|
}).error(function (ex) {
|
|
reply.triggerError(ex);
|
|
});
|
|
return reply;
|
|
}
|
|
}, {
|
|
key: "getRecord",
|
|
value: function getRecord(resource, fromDate, toDate) {
|
|
if (resource instanceof _DistributedResource["default"]) {
|
|
if (resource._p.connection != this) return new _AsyncReply["default"](null);
|
|
var reply = new _AsyncReply["default"]();
|
|
var self = this;
|
|
this.sendRequest(_IIPPacketAction["default"].ResourceHistory).addUint32(resource._p.instanceId).addDateTime(fromDate).addDateTime(toDate).done().then(function (rt) {
|
|
_Codec["default"].parseHistory(rt[0], 0, rt[0].length, resource, self).then(function (history) {
|
|
reply.trigger(history);
|
|
});
|
|
});
|
|
return reply;
|
|
} else return new _AsyncReply["default"](null);
|
|
}
|
|
}, {
|
|
key: "IIPRequestAddChild",
|
|
value: function IIPRequestAddChild(callback, parentId, childId) {
|
|
var self = this;
|
|
|
|
_Warehouse["default"].getById(parentId).then(function (parent) {
|
|
if (parent == null) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);
|
|
return;
|
|
}
|
|
|
|
_Warehouse["default"].getById(childId).then(function (child) {
|
|
if (child == null) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);
|
|
return;
|
|
}
|
|
|
|
if (parent.instance.applicable(self.session, _ActionType["default"].AddChild, null) != _Ruling["default"].Allowed) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].AddChildDenied);
|
|
return;
|
|
}
|
|
|
|
if (child.instance.applicable(self.session, _ActionType["default"].AddParent, null) != _Ruling["default"].Allowed) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].AddParentDenied);
|
|
return;
|
|
}
|
|
|
|
parent.instance.children.add(child);
|
|
self.sendReply(_IIPPacketAction["default"].AddChild, callback).done(); //child.Instance.Parents
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPRequestRemoveChild",
|
|
value: function IIPRequestRemoveChild(callback, parentId, childId) {
|
|
var self = this;
|
|
|
|
_Warehouse["default"].getById(parentId).then(function (parent) {
|
|
if (parent == null) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);
|
|
return;
|
|
}
|
|
|
|
_Warehouse["default"].getById(childId).then(function (child) {
|
|
if (child == null) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);
|
|
return;
|
|
}
|
|
|
|
if (parent.instance.applicable(self.session, _ActionType["default"].RemoveChild, null) != _Ruling["default"].Allowed) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].AddChildDenied);
|
|
return;
|
|
}
|
|
|
|
if (child.instance.applicable(self.session, _ActionType["default"].RemoveParent, null) != _Ruling["default"].Allowed) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].AddParentDenied);
|
|
return;
|
|
}
|
|
|
|
parent.instance.children.remove(child);
|
|
self.sendReply(_IIPPacketAction["default"].RemoveChild, callback).done(); //child.Instance.Parents
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPRequestRenameResource",
|
|
value: function IIPRequestRenameResource(callback, resourceId, name) {
|
|
var self = this;
|
|
|
|
_Warehouse["default"].getById(resourceId).then(function (resource) {
|
|
if (resource == null) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);
|
|
return;
|
|
}
|
|
|
|
if (resource.instance.applicable(self.session, _ActionType["default"].Rename, null) != _Ruling["default"].Allowed) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].RenameDenied);
|
|
return;
|
|
}
|
|
|
|
resource.instance.name = name;
|
|
self.sendReply(_IIPPacketAction["default"].RenameResource, callback).done();
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPRequestResourceChildren",
|
|
value: function IIPRequestResourceChildren(callback, resourceId) {
|
|
var self = this;
|
|
|
|
_Warehouse["default"].getById(resourceId).then(function (resource) {
|
|
if (resource == null) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);
|
|
return;
|
|
}
|
|
|
|
self.sendReply(_IIPPacketAction["default"].ResourceChildren, callback).addUint8Array(_Codec["default"].compose(resource.instance.children.toArray(), self)).done();
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPRequestResourceParents",
|
|
value: function IIPRequestResourceParents(callback, resourceId) {
|
|
var self = this;
|
|
|
|
_Warehouse["default"].getById(resourceId).then(function (resource) {
|
|
if (resource == null) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);
|
|
return;
|
|
}
|
|
|
|
self.sendReply(_IIPPacketAction["default"].ResourceParents, callback).addUint8Array(_Codec["default"].compose(resource.instance.parents.toArray(), self)).done();
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPRequestClearAttributes",
|
|
value: function IIPRequestClearAttributes(callback, resourceId, attributes) {
|
|
var all = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
|
|
|
|
_Warehouse["default"].getById(resourceId).then(function (r) {
|
|
if (r == null) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);
|
|
return;
|
|
}
|
|
|
|
if (r.instance.store.instance.applicable(self.session, _ActionType["default"].UpdateAttributes, null) != _Ruling["default"].Allowed) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].UpdateAttributeDenied);
|
|
return;
|
|
}
|
|
|
|
var attrs = [];
|
|
if (!all) attrs = attributes.getStringArray(0, attributes.length);
|
|
if (r.instance.removeAttributes(attrs)) self.sendReply(all ? _IIPPacketAction["default"].ClearAllAttributes : _IIPPacketAction["default"].ClearAttributes, callback).done();else self.sendError(_AsyncReply["default"].ErrorType.Management, callback, _ExceptionCode["default"].UpdateAttributeFailed);
|
|
});
|
|
}
|
|
}, {
|
|
key: "IIPRequestUpdateAttributes",
|
|
value: function IIPRequestUpdateAttributes(callback, resourceId, attributes) {
|
|
var clearAttributes = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
|
|
var self = this;
|
|
|
|
_Warehouse["default"].getById(resourceId).then(function (r) {
|
|
if (r == null) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].ResourceNotFound);
|
|
return;
|
|
}
|
|
|
|
if (r.instance.store.instance.applicable(self.session, _ActionType["default"].UpdateAttributes, null) != _Ruling["default"].Allowed) {
|
|
self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].UpdateAttributeDenied);
|
|
return;
|
|
}
|
|
|
|
DataDeserializer.typedListParser(attributes, 0, attributes.length, this).then(function (attrs) {
|
|
if (r.instance.setAttributes(attrs, clearAttributes)) self.sendReply(clearAttributes ? _IIPPacketAction["default"].ClearAllAttributes : _IIPPacketAction["default"].ClearAttributes, callback).done();else self.sendError(_ErrorType["default"].Management, callback, _ExceptionCode["default"].UpdateAttributeFailed);
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "getChildren",
|
|
value: function getChildren(resource) {
|
|
if (resource._p.connection != this) return new _AsyncReply["default"](null);
|
|
var rt = new _AsyncReply["default"]();
|
|
var self = this;
|
|
this.sendRequest(_IIPPacketAction["default"].ResourceChildren).addUint32(resource._p.instanceId).done().then(function (ar) {
|
|
var dataType = ar[0];
|
|
var data = ar[1];
|
|
|
|
_Codec["default"].parse(data, 0, self, dataType).reply.then(function (resources) {
|
|
rt.trigger(resources);
|
|
}).error(function (ex) {
|
|
return rt.triggerError(ex);
|
|
});
|
|
});
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "getParents",
|
|
value: function getParents(resource) {
|
|
if (resource._p.connection != this) return new _AsyncReply["default"](null);
|
|
var rt = new _AsyncReply["default"]();
|
|
var self = this;
|
|
this.sendRequest(_IIPPacketAction["default"].ResourceParents).addUint32(resource._p.instanceId).done().then(function (ar) {
|
|
var dataType = ar[0];
|
|
var data = ar[1];
|
|
|
|
_Codec["default"].parse(data, 0, self, dataType).reply.then(function (resources) {
|
|
rt.trigger(resources);
|
|
}).error(function (ex) {
|
|
return rt.triggerError(ex);
|
|
});
|
|
});
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "removeAttributes",
|
|
value: function removeAttributes(resource) {
|
|
var attributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
|
if (resource._p.connection != this) return new _AsyncReply["default"](null);
|
|
var rt = new _AsyncReply["default"]();
|
|
if (attributes == null) this.sendRequest(_IIPPacketAction["default"].ClearAllAttributes).addUint32(resource._p.instanceId).done().then(function (ar) {
|
|
rt.trigger(true);
|
|
}).error(function (ex) {
|
|
rt.triggerError(ex);
|
|
});else {
|
|
var attrs = _DC.DC.stringArrayToBytes(attributes);
|
|
|
|
this.sendRequest(_IIPPacketAction["default"].ClearAttributes).addUint32(resource.instance.id).addUint32(attrs.length).addUint8Array(attrs).done().then(function (ar) {
|
|
rt.trigger(true);
|
|
}).error(function (ex) {
|
|
rt.triggerError(ex);
|
|
});
|
|
}
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "setAttributes",
|
|
value: function setAttributes(resource, attributes) {
|
|
var clearAttributes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
|
|
if (resource._p.connection != this) return new _AsyncReply["default"](null);
|
|
var rt = new _AsyncReply["default"]();
|
|
this.sendRequest(clearAttributes ? _IIPPacketAction["default"].UpdateAllAttributes : _IIPPacketAction["default"].UpdateAttributes).addUint32(resource._p.instanceId).addUint8Array(_Codec["default"].compose(attributes, this)).done().then(function () {
|
|
rt.trigger(true);
|
|
}).error(function (ex) {
|
|
rt.triggerError(ex);
|
|
});
|
|
return rt;
|
|
}
|
|
}, {
|
|
key: "getAttributes",
|
|
value: function getAttributes(resource) {
|
|
var attributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
|
if (resource._p.connection != this) return new _AsyncReply["default"](null);
|
|
var rt = new _AsyncReply["default"]();
|
|
var self = this;
|
|
|
|
if (attributes == null) {
|
|
this.sendRequest(_IIPPacketAction["default"].GetAllAttributes).addUint32(resource._p.instanceId).done().then(function (ar) {
|
|
var dataType = ar[0];
|
|
var data = ar[1];
|
|
|
|
_Codec["default"].parse(data, 0, self, dataType).reply.then(function (st) {
|
|
var _resource$instance;
|
|
|
|
(_resource$instance = resource.instance) === null || _resource$instance === void 0 ? void 0 : _resource$instance.setAttributes(st);
|
|
rt.trigger(st);
|
|
}).error(function (ex) {
|
|
return rt.triggerError(ex);
|
|
});
|
|
}).error(function (ex) {
|
|
rt.triggerError(ex);
|
|
});
|
|
} else {
|
|
var attrs = _DC.DC.stringArrayToBytes(attributes);
|
|
|
|
this.sendRequest(_IIPPacketAction["default"].GetAttributes).addUint32(resource._p.instanceId).addUint32(attrs.length).addUint8Array(attrs).done().then(function (ar) {
|
|
var dataType = ar[0];
|
|
var data = ar[1];
|
|
|
|
_Codec["default"].parse(data, 0, self, dataType).reply.then(function (st) {
|
|
var _resource$instance2;
|
|
|
|
(_resource$instance2 = resource.instance) === null || _resource$instance2 === void 0 ? void 0 : _resource$instance2.setAttributes(st);
|
|
rt.trigger(st);
|
|
}).error(function (ex) {
|
|
return rt.triggerError(ex);
|
|
});
|
|
}).error(function (ex) {
|
|
return rt.triggerError(ex);
|
|
});
|
|
;
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
}]);
|
|
|
|
return DistributedConnection;
|
|
}(_IStore2["default"]);
|
|
|
|
exports["default"] = DistributedConnection;
|
|
|
|
},{"../../Core/AsyncBag.js":2,"../../Core/AsyncException.js":3,"../../Core/AsyncQueue.js":4,"../../Core/AsyncReply.js":5,"../../Core/ErrorType.js":6,"../../Core/ExceptionCode.js":7,"../../Core/ProgressType.js":10,"../../Data/Codec.js":14,"../../Data/DC.js":15,"../../Data/KeyList.js":23,"../../Data/PropertyValue.js":26,"../../Data/PropertyValueArray.js":27,"../../Data/TransmissionType.js":38,"../../Resource/IResource.js":70,"../../Resource/IStore.js":71,"../../Resource/Template/TemplateType.js":82,"../../Resource/Template/TypeTemplate.js":83,"../../Resource/Warehouse.js":84,"../../Security/Authority/Authentication.js":85,"../../Security/Authority/AuthenticationMethod.js":86,"../../Security/Authority/AuthenticationType.js":87,"../../Security/Authority/ClientAuthentication.js":88,"../../Security/Authority/HostAuthentication.js":89,"../../Security/Authority/Session.js":90,"../../Security/Integrity/SHA256.js":91,"../../Security/Permissions/ActionType.js":93,"../../Security/Permissions/Ruling.js":95,"../Packets//IIPPacketReport.js":61,"../Packets/IIPAuthPacket.js":54,"../Packets/IIPAuthPacketAction.js":55,"../Packets/IIPAuthPacketCommand.js":56,"../Packets/IIPPacket.js":57,"../Packets/IIPPacketAction.js":58,"../Packets/IIPPacketCommand.js":59,"../Packets/IIPPacketEvent.js":60,"../SendList.js":62,"../Sockets/SocketState.js":64,"../Sockets/WSocket.js":65,"./DistributedPropertyContext.js":43,"./DistributedResource.js":44,"./DistributedResourceQueueItem.js":45,"./DistributedResourceQueueItemType.js":46}],43:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017-2018 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 27/10/2018.
|
|
*/
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var DistributedPropertyContext = function DistributedPropertyContext(p1, p2) {
|
|
_classCallCheck(this, DistributedPropertyContext);
|
|
|
|
if (arguments.length == 1) {
|
|
this.method = p1;
|
|
} else if (arguments.length == 2) {
|
|
this.connection = p1;
|
|
this.value = p2;
|
|
}
|
|
};
|
|
|
|
exports["default"] = DistributedPropertyContext;
|
|
|
|
},{}],44:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 25/07/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _IResource2 = _interopRequireDefault(require("../../Resource/IResource.js"));
|
|
|
|
var _AsyncReply = _interopRequireDefault(require("../../Core/AsyncReply.js"));
|
|
|
|
var _Codec = _interopRequireDefault(require("../../Data/Codec.js"));
|
|
|
|
var _IIPPacketAction = _interopRequireDefault(require("../Packets//IIPPacketAction.js"));
|
|
|
|
var _EventTemplate = _interopRequireDefault(require("../../Resource/Template/EventTemplate.js"));
|
|
|
|
var _AsyncException = _interopRequireDefault(require("../../Core/AsyncException.js"));
|
|
|
|
var _ExceptionCode = _interopRequireDefault(require("../../Core//ExceptionCode.js"));
|
|
|
|
var _ErrorType = _interopRequireDefault(require("../../Core/ErrorType.js"));
|
|
|
|
var _ExtendedTypes = require("../../Data/ExtendedTypes.js");
|
|
|
|
var _TypedMap = _interopRequireDefault(require("../../Data/TypedMap.js"));
|
|
|
|
var _PropertyValueArray = _interopRequireDefault(require("../../Data/PropertyValueArray.js"));
|
|
|
|
var _PropertyValue = _interopRequireDefault(require("../../Data/PropertyValue.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
var DistributedResource = /*#__PURE__*/function (_IResource) {
|
|
_inherits(DistributedResource, _IResource);
|
|
|
|
var _super = _createSuper(DistributedResource);
|
|
|
|
function DistributedResource(connection, instanceId, age, link) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, DistributedResource);
|
|
|
|
_this = _super.call(this);
|
|
_this._p = {
|
|
suspended: false,
|
|
attached: false,
|
|
connection: connection,
|
|
instanceId: instanceId,
|
|
age: age,
|
|
link: link,
|
|
properties: []
|
|
};
|
|
return _this;
|
|
}
|
|
|
|
_createClass(DistributedResource, [{
|
|
key: "destroy",
|
|
value: function destroy() {
|
|
this.destroyed = true;
|
|
this._p.attached = false;
|
|
|
|
this._p.connection.sendDetachRequest(this._p.instanceId);
|
|
|
|
this._emit("destroy", this);
|
|
}
|
|
}, {
|
|
key: "_suspend",
|
|
value: function _suspend() {
|
|
this._p.suspended = true;
|
|
this._p.attached = false;
|
|
}
|
|
}, {
|
|
key: "trigger",
|
|
value: function trigger(type) {
|
|
return new _AsyncReply["default"](true);
|
|
}
|
|
}, {
|
|
key: "_serialize",
|
|
value: function _serialize() {
|
|
var props = new _PropertyValueArray["default"]();
|
|
|
|
for (var i = 0; i < this._p.properties.length; i++) {
|
|
props.push(new _PropertyValue["default"](this._p.properties[i], this.instance.getAge(i), this.instance.getModificationDate(i)));
|
|
}
|
|
|
|
return props;
|
|
}
|
|
}, {
|
|
key: "_attach",
|
|
value: function _attach(properties) {
|
|
if (this._p.attached) {
|
|
console.log("Already attached.");
|
|
return false;
|
|
} else {
|
|
this._p.attached = true;
|
|
this._p.suspended = false;
|
|
this._p.properties = [];
|
|
|
|
for (var i = 0; i < properties.length; i++) {
|
|
this.instance.setAge(i, properties[i].age);
|
|
this.instance.setModificationDate(i, properties[i].date);
|
|
|
|
this._p.properties.push(properties[i].value);
|
|
}
|
|
|
|
var self = this;
|
|
|
|
var makeFunc = function makeFunc(ft) {
|
|
var func = function func() {
|
|
var argsMap = new (_TypedMap["default"].of(_ExtendedTypes.UInt8, Object))();
|
|
|
|
if (arguments.length == 1 && arguments[0] instanceof Object && arguments[0].constructor.name == "Object") {
|
|
// named args
|
|
for (var _i = 0; _i < ft.args.length; _i++) {
|
|
var arg = ft.args[_i];
|
|
|
|
if (arguments[arg.name] != undefined) {
|
|
argsMap.set(new _ExtendedTypes.UInt8(arg.index), arguments[arg.name]);
|
|
}
|
|
}
|
|
|
|
return self._invoke(ft.index, argsMap);
|
|
} else {
|
|
for (var _i2 = 0; _i2 < arguments.length && _i2 < ft.args.length; _i2++) {
|
|
argsMap.set(new _ExtendedTypes.UInt8(_i2), arguments[_i2]);
|
|
}
|
|
|
|
return self._invoke(ft.index, argsMap);
|
|
}
|
|
}; // get expansion
|
|
|
|
|
|
func.help = self.instance.template.functions[ft.index].expansion;
|
|
return func;
|
|
};
|
|
|
|
var makeGetter = function makeGetter(index) {
|
|
return function () {
|
|
return self._get(index);
|
|
};
|
|
};
|
|
|
|
var makeSetter = function makeSetter(index) {
|
|
return function (value) {
|
|
self._set(index, value);
|
|
};
|
|
};
|
|
|
|
for (var _i3 = 0; _i3 < this.instance.template.functions.length; _i3++) {
|
|
var ft = this.instance.template.functions[_i3];
|
|
this[ft.name] = makeFunc(ft);
|
|
}
|
|
|
|
for (var _i4 = 0; _i4 < this.instance.template.properties.length; _i4++) {
|
|
var pt = this.instance.template.properties[_i4];
|
|
Object.defineProperty(this, pt.name, {
|
|
get: makeGetter(pt.index),
|
|
set: makeSetter(pt.index),
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}, {
|
|
key: "listen",
|
|
value: function listen(event) {
|
|
var et = event instanceof _EventTemplate["default"] ? event : this.instance.template.getEventTemplateByName(event);
|
|
if (et == null) return new _AsyncReply["default"]().triggerError(new _AsyncException["default"](_ErrorType["default"].Management, _ExceptionCode["default"].MethodNotFound, ""));
|
|
if (!et.listenable) return new _AsyncReply["default"]().triggerError(new _AsyncException["default"](_ErrorType["default"].Management, _ExceptionCode["default"].NotListenable, ""));
|
|
return this._p.connection.sendListenRequest(this._p.instanceId, et.index);
|
|
}
|
|
}, {
|
|
key: "unlisten",
|
|
value: function unlisten(event) {
|
|
var et = event instanceof _EventTemplate["default"] ? event : this.instance.template.getEventTemplateByName(event);
|
|
if (et == null) return new _AsyncReply["default"]().triggerError(new _AsyncException["default"](_ErrorType["default"].Management, _ExceptionCode["default"].MethodNotFound, ""));
|
|
if (!et.listenable) return new _AsyncReply["default"]().triggerError(new _AsyncException["default"](_ErrorType["default"].Management, _ExceptionCode["default"].NotListenable, ""));
|
|
return this._p.connection.sendUnlistenRequest(this._p.instanceId, et.index);
|
|
}
|
|
}, {
|
|
key: "_emitEventByIndex",
|
|
value: function _emitEventByIndex(index, args) {
|
|
var et = this.instance.template.getEventTemplateByIndex(index); //@TODO if array _emitArgs
|
|
//this._emitArgs(et.name, [args]);
|
|
|
|
this._emit(et.name, args);
|
|
|
|
this.instance._emitResourceEvent(null, null, et, args);
|
|
}
|
|
}, {
|
|
key: "_invoke",
|
|
value: function _invoke(index, args) {
|
|
if (this.destroyed) throw new Error("Trying to access destroyed object");
|
|
if (this._p.suspended) throw new Error("Trying to access suspended object");
|
|
if (index >= this.instance.template.functions.length) throw new Error("Function index is incorrect");
|
|
return this._p.connection.sendInvoke(this._p.instanceId, index, args);
|
|
}
|
|
}, {
|
|
key: "_get",
|
|
value: function _get(index) {
|
|
if (index >= this._p.properties.length) return null;
|
|
return this._p.properties[index];
|
|
}
|
|
}, {
|
|
key: "_updatePropertyByIndex",
|
|
value: function _updatePropertyByIndex(index, value) {
|
|
var pt = this.instance.template.getPropertyTemplateByIndex(index);
|
|
this._p.properties[index] = value;
|
|
this.instance.emitModification(pt, value); // this to invoke other property setters
|
|
|
|
this._p.neglect = true;
|
|
this[pt.name] = null;
|
|
this._p.neglect = false;
|
|
}
|
|
}, {
|
|
key: "_set",
|
|
value: function _set(index, value) {
|
|
if (!this._p.attached) {
|
|
console.log("Resource not attached.");
|
|
return;
|
|
}
|
|
|
|
if (this._p.neglect) return;
|
|
if (index >= this._p.properties.length) return null;
|
|
var reply = new _AsyncReply["default"]();
|
|
|
|
var parameters = _Codec["default"].compose(value, this._p.connection);
|
|
|
|
var self = this;
|
|
|
|
this._p.connection.sendRequest(_IIPPacketAction["default"].SetProperty).addUint32(self._p.instanceId).addUint8(index).addUint8Array(parameters).done().then(function (res) {
|
|
// not really needed, server will always send property modified, this only happens if the programmer forgot to emit in property setter
|
|
self._p.properties[index] = value;
|
|
reply.trigger(null);
|
|
});
|
|
|
|
return reply;
|
|
}
|
|
}]);
|
|
|
|
return DistributedResource;
|
|
}(_IResource2["default"]);
|
|
|
|
exports["default"] = DistributedResource;
|
|
|
|
},{"../../Core//ExceptionCode.js":7,"../../Core/AsyncException.js":3,"../../Core/AsyncReply.js":5,"../../Core/ErrorType.js":6,"../../Data/Codec.js":14,"../../Data/ExtendedTypes.js":19,"../../Data/PropertyValue.js":26,"../../Data/PropertyValueArray.js":27,"../../Data/TypedMap.js":41,"../../Resource/IResource.js":70,"../../Resource/Template/EventTemplate.js":76,"../Packets//IIPPacketAction.js":58}],45:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 25/07/2017.
|
|
*/
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var DistributedResourceQueueItem = function DistributedResourceQueueItem(resource, type, value, index) {
|
|
_classCallCheck(this, DistributedResourceQueueItem);
|
|
|
|
this.resource = resource;
|
|
this.index = index;
|
|
this.type = type;
|
|
this.value = value;
|
|
};
|
|
|
|
exports["default"] = DistributedResourceQueueItem;
|
|
|
|
},{}],46:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
var _default = {
|
|
Propery: 0,
|
|
Event: 1
|
|
};
|
|
exports["default"] = _default;
|
|
|
|
},{}],47:[function(require,module,exports){
|
|
/*
|
|
* Copyright (c) 2017-2021 Ahmed Kh. Zamil
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Created by Ahmed Zamil on 03/05/2021.
|
|
*/
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _IResource2 = _interopRequireDefault(require("../../Resource/IResource.js"));
|
|
|
|
var _AsyncReply = _interopRequireDefault(require("../../Core/AsyncReply.js"));
|
|
|
|
var _Codec = _interopRequireDefault(require("../../Data/Codec.js"));
|
|
|
|
var _Structure = _interopRequireDefault(require("../../Data/Structure.js"));
|
|
|
|
var _IIPPacketAction = _interopRequireDefault(require("../Packets//IIPPacketAction.js"));
|
|
|
|
var _EventTemplate = _interopRequireDefault(require("../../Resource/Template/EventTemplate.js"));
|
|
|
|
var _AsyncException = _interopRequireDefault(require("../../Core/AsyncException.js"));
|
|
|
|
var _ExceptionCode = _interopRequireDefault(require("../../Core//ExceptionCode.js"));
|
|
|
|
var _ErrorType = _interopRequireDefault(require("../../Core/ErrorType.js"));
|
|
|
|
var _DistributedConnection = _interopRequireDefault(require("./DistributedConnection.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
var DistributedServer = /*#__PURE__*/function (_IResource) {
|
|
_inherits(DistributedServer, _IResource);
|
|
|
|
var _super = _createSuper(DistributedServer);
|
|
|
|
function DistributedServer() {
|
|
var _this;
|
|
|
|
_classCallCheck(this, DistributedServer);
|
|
|
|
_this = _super.call(this);
|
|
_this.connections = [];
|
|
return _this;
|
|
} //@TODO: con.off("close", ...)
|
|
|
|
|
|
_createClass(DistributedServer, [{
|
|
key: "destroy",
|
|
value: function destroy() {
|
|
this.connections = [];
|
|
this.destroyed = true;
|
|
|
|
this._emit("destroy", this);
|
|
}
|
|
}, {
|
|
key: "trigger",
|
|
value: function trigger(type) {
|
|
return new _AsyncReply["default"](true);
|
|
}
|
|
}, {
|
|
key: "membership",
|
|
get: function get() {
|
|
return this.instance.attributes.get("membership");
|
|
}
|
|
}, {
|
|
key: "entryPoint",
|
|
get: function get() {
|
|
return this.instance.attributes.get("entryPoint");
|
|
}
|
|
}, {
|
|
key: "add",
|
|
value: function add() {
|
|
var self = this;
|
|
var con = new _DistributedConnection["default"](this);
|
|
con.on("close", function () {
|
|
return self.remove(con);
|
|
});
|
|
this.connections.push(con);
|
|
return con;
|
|
}
|
|
}, {
|
|
key: "remove",
|
|
value: function remove(connection) {
|
|
var i = this.connections.indexOf(connection);
|
|
if (i > -1) this.connections.splice(i, 1);
|
|
}
|
|
}]);
|
|
|
|
return DistributedServer;
|
|
}(_IResource2["default"]);
|
|
|
|
exports["default"] = DistributedServer;
|
|
|
|
},{"../../Core//ExceptionCode.js":7,"../../Core/AsyncException.js":3,"../../Core/AsyncReply.js":5,"../../Core/ErrorType.js":6,"../../Data/Codec.js":14,"../../Data/Structure.js":35,"../../Resource/IResource.js":70,"../../Resource/Template/EventTemplate.js":76,"../Packets//IIPPacketAction.js":58,"./DistributedConnection.js":42}],48:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _IResource2 = _interopRequireDefault(require("../../Resource/IResource.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
var EntryPoint = /*#__PURE__*/function (_IResource) {
|
|
_inherits(EntryPoint, _IResource);
|
|
|
|
var _super = _createSuper(EntryPoint);
|
|
|
|
function EntryPoint() {
|
|
_classCallCheck(this, EntryPoint);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(EntryPoint, [{
|
|
key: "query",
|
|
value: function query(path, sender) {}
|
|
}, {
|
|
key: "create",
|
|
value: function create() {}
|
|
}]);
|
|
|
|
return EntryPoint;
|
|
}(_IResource2["default"]);
|
|
|
|
exports["default"] = EntryPoint;
|
|
|
|
},{"../../Resource/IResource.js":70}],49:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _IDestructible2 = _interopRequireDefault(require("../Core/IDestructible.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
var INetworkReceiver = /*#__PURE__*/function (_IDestructible) {
|
|
_inherits(INetworkReceiver, _IDestructible);
|
|
|
|
var _super = _createSuper(INetworkReceiver);
|
|
|
|
function INetworkReceiver() {
|
|
_classCallCheck(this, INetworkReceiver);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(INetworkReceiver, [{
|
|
key: "networkClose",
|
|
value: function networkClose(sender) {}
|
|
}, {
|
|
key: "networkReceive",
|
|
value: function networkReceive(sender, buffer) {}
|
|
}, {
|
|
key: "networkConnect",
|
|
value: function networkConnect(sender) {}
|
|
}]);
|
|
|
|
return INetworkReceiver;
|
|
}(_IDestructible2["default"]);
|
|
|
|
exports["default"] = INetworkReceiver;
|
|
|
|
},{"../Core/IDestructible.js":8}] |