@iotize/tap
Version:
IoTize Device client for Javascript
1,137 lines (1,124 loc) • 121 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@iotize/tap/client/api'), require('@iotize/common/byte-converter'), require('@iotize/common/byte-stream'), require('@iotize/common/debug'), require('@iotize/common/error'), require('rxjs'), require('rxjs/operators'), require('buffer'), require('@iotize/common/tlv')) :
typeof define === 'function' && define.amd ? define('@iotize/tap/client/impl', ['exports', '@iotize/tap/client/api', '@iotize/common/byte-converter', '@iotize/common/byte-stream', '@iotize/common/debug', '@iotize/common/error', 'rxjs', 'rxjs/operators', 'buffer', '@iotize/common/tlv'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.iotize = global.iotize || {}, global.iotize.tap = global.iotize.tap || {}, global.iotize.tap.client = global.iotize.tap.client || {}, global.iotize.tap.client.impl = {}), global.iotize.tap.client.api, global.byteConverter, global.byteStream, global.debug$1, global.error, global.rxjs, global.rxjs.operators, global.buffer, global.tlv));
})(this, (function (exports, api, byteConverter, byteStream, debug$1, error, rxjs, operators, buffer, tlv) { 'use strict';
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b)
if (Object.prototype.hasOwnProperty.call(b, p))
d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function () {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __rest(s, e) {
var t = {};
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
r = Reflect.decorate(decorators, target, key, desc);
else
for (var i = decorators.length - 1; i >= 0; i--)
if (d = decorators[i])
r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); };
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try {
step(generator.next(value));
}
catch (e) {
reject(e);
} }
function rejected(value) { try {
step(generator["throw"](value));
}
catch (e) {
reject(e);
} }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function () { if (t[0] & 1)
throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f)
throw new TypeError("Generator is already executing.");
while (_)
try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
return t;
if (y = 0, t)
op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return { value: op[1], done: false };
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2])
_.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
}
catch (e) {
op = [6, e];
y = 0;
}
finally {
f = t = 0;
}
if (op[0] & 5)
throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
}
var __createBinding = Object.create ? (function (o, m, k, k2) {
if (k2 === undefined)
k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
}) : (function (o, m, k, k2) {
if (k2 === undefined)
k2 = k;
o[k2] = m[k];
});
function __exportStar(m, o) {
for (var p in m)
if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
__createBinding(o, m, p);
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m)
return m.call(o);
if (o && typeof o.length === "number")
return {
next: function () {
if (o && i >= o.length)
o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m)
return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
ar.push(r.value);
}
catch (error) {
e = { error: error };
}
finally {
try {
if (r && !r.done && (m = i["return"]))
m.call(i);
}
finally {
if (e)
throw e.error;
}
}
return ar;
}
/** @deprecated */
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
/** @deprecated */
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++)
s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
}
function __spreadArray(to, from, pack) {
if (pack || arguments.length === 2)
for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar)
ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
}
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { if (g[n])
i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
function resume(n, v) { try {
step(g[n](v));
}
catch (e) {
settle(q[0][3], e);
} }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length)
resume(q[0][0], q[0][1]); }
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
}
function __asyncValues(o) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) {
Object.defineProperty(cooked, "raw", { value: raw });
}
else {
cooked.raw = raw;
}
return cooked;
}
;
var __setModuleDefault = Object.create ? (function (o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function (o, v) {
o["default"] = v;
};
function __importStar(mod) {
if (mod && mod.__esModule)
return mod;
var result = {};
if (mod != null)
for (var k in mod)
if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
__createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
function __classPrivateFieldGet(receiver, state, kind, f) {
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
}
function __classPrivateFieldSet(receiver, state, value, kind, f) {
if (kind === "m")
throw new TypeError("Private method is not writable");
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
}
var prefix = '@iotize/tap/client/impl';
var debug = debug$1.createDebugger(prefix);
exports.ConverterError = /** @class */ (function (_super) {
__extends(ConverterError, _super);
function ConverterError(code, msg, cause) {
var _this = _super.call(this, msg, code) || this;
_this.cause = cause;
return _this;
}
ConverterError.unexpectedBufferSize = function (expected, buffer) {
return new ConverterError(ConverterError.Code.UnexpectedBufferSizeError, 'Expected buffer of ' +
expected +
' byte(s) but found only ' +
buffer.length +
' byte(s)');
};
ConverterError.nullBufferError = function (msg) {
return new ConverterError(ConverterError.Code.NullBufferError, msg);
};
ConverterError.valueTooBigError = function (value, maxValue) {
return new ConverterError(ConverterError.Code.ValueTooBigError, "Value " + value + " is not acceptable. Maximum authorized value is " + maxValue + ".");
};
return ConverterError;
}(error.CodeError));
(function (ConverterError) {
var Code;
(function (Code) {
Code["UnexpectedBufferSizeError"] = "UnexpectedBufferSizeError";
Code["NullBufferError"] = "NullBufferError";
Code["ValueTooBigError"] = "ConverterErrorValueTooBigError";
})(Code = ConverterError.Code || (ConverterError.Code = {}));
})(exports.ConverterError || (exports.ConverterError = {}));
var NumberConverter = /** @class */ (function () {
function NumberConverter(options) {
this.options = options;
}
/**
* Number as unsigned 8 bits converter
* @param lsb true for least significant bit first
*/
NumberConverter.uint8 = function (lsb) {
if (lsb === void 0) { lsb = false; }
return new NumberConverter({
signed: false,
sizeOf: 8,
leastSignificantBitFirst: lsb,
});
};
/**
* Number as unsigned 16 bits converter
* @param lsb true for least significant bit first
*/
NumberConverter.uint16 = function (lsb) {
if (lsb === void 0) { lsb = false; }
return new NumberConverter({
signed: false,
sizeOf: 16,
leastSignificantBitFirst: lsb,
});
};
/**
* Number as unsigned 32 bits converter
* @param lsb true for least significant bit first
*/
NumberConverter.uint32 = function (lsb) {
if (lsb === void 0) { lsb = false; }
return new NumberConverter({
signed: false,
sizeOf: 32,
leastSignificantBitFirst: lsb,
});
};
/**
* Number as signed 8 bits converter
* @param lsb true for least significant bit first
*/
NumberConverter.int8 = function (lsb) {
if (lsb === void 0) { lsb = false; }
return new NumberConverter({
signed: true,
sizeOf: 8,
leastSignificantBitFirst: lsb,
});
};
/**
* Number as signed 16 bits converter
* @param lsb true for least significant bit first
*/
NumberConverter.int16 = function (lsb) {
if (lsb === void 0) { lsb = false; }
return new NumberConverter({
signed: true,
sizeOf: 16,
leastSignificantBitFirst: lsb,
});
};
/**
* Number as signed 32 bits converter
* @param lsb true for least significant bit first
*/
NumberConverter.int32 = function (lsb) {
if (lsb === void 0) { lsb = false; }
return new NumberConverter({
signed: true,
sizeOf: 32,
leastSignificantBitFirst: lsb,
});
};
NumberConverter.prototype.decode = function (body) {
if (body.length * 8 < this.options.sizeOf) {
throw exports.ConverterError.unexpectedBufferSize(this.options.sizeOf / 8, body);
}
return NumberConverter.fromBytes(body, this.options.sizeOf / 8, this.options.signed, this.options.leastSignificantBitFirst);
};
NumberConverter.prototype.encode = function (value) {
var maxValue = Math.pow(2, this.options.sizeOf) - 1;
if (value > maxValue) {
throw exports.ConverterError.valueTooBigError(value, maxValue);
}
var result = new Uint8Array(this.options.sizeOf >> 3);
for (var i = 0; i < result.length; i++) {
var decalage = (result.length - i - 1) * 8;
result[i] = (value >> decalage) & 0xff;
}
if (this.options.leastSignificantBitFirst) {
result.reverse();
}
return result;
};
NumberConverter.toOpaqueMsb = function (input, sizeOf) {
var maxValue = Math.pow(2, sizeOf) - 1;
if (input > maxValue) {
throw exports.ConverterError.valueTooBigError(input, maxValue);
}
if (sizeOf === 8) {
return new Uint8Array([input & 0xff]);
}
else if (sizeOf === 16) {
return new Uint8Array([(input >> 8) & 0xff, input & 0xff]);
}
else if (sizeOf === 32) {
return new Uint8Array([
(input >> 24) & 0xff,
(input >> 16) & 0xff,
(input >> 8) & 0xff,
input & 0xff,
]);
}
else {
throw new Error("Invalid size " + sizeOf + ". Must be 8, 16 or 32");
}
};
NumberConverter.fromOpaqueMsb = function (data, sizeOf) {
if (!sizeOf) {
sizeOf = data.length * 8;
}
if (sizeOf === 8) {
return data[0] & 0xff;
}
if (sizeOf === 16) {
return (data[1] & 0xff) + ((data[0] & 0xff) << 8);
}
if (sizeOf === 32) {
return ((data[3] & 0xff) +
((data[2] & 0xff) << 8) +
((data[1] & 0xff) << 16) +
((data[0] & 0xff) << 24));
}
throw new Error("Invalid size " + sizeOf + ". Must be 8, 16 or 32");
};
/**
* @param size size in bytes
*/
NumberConverter.fromBytes = function (data, size, signed, lsb) {
if (lsb) {
data = data.reverse();
}
var result = 0;
var last = 0;
var decalage;
for (var i = 0; i < size; i++) {
decalage = (size - i - 1) * 8;
result += ((data[i] & 0xff) << decalage) >>> 0;
if (last > result && !signed) {
throw new Error('Overflow. Last value: ' + last + ' but new is ' + result);
}
last = result;
}
if (signed && (data[0] & 0x80) === 0x80) {
result = -(Math.pow(2, 8 * size) - result);
}
return result;
};
return NumberConverter;
}());
var _mpeg2Instance;
var CRC = /** @class */ (function () {
function CRC(polynomial) {
this.polynomial = polynomial;
}
CRC.mpeg2 = function () {
if (!_mpeg2Instance) {
_mpeg2Instance = new CRC(CRC.POLYNOMIAL_CRC32_MPEG2);
}
return _mpeg2Instance;
};
CRC.prototype.compute = function (buffer, firstValue) {
if (firstValue === void 0) { firstValue = CRC.FIRST_VALUE; }
if (buffer instanceof Uint32Array) {
return CRC.fromWord(buffer, firstValue, this.polynomial);
}
else {
return CRC.fromBytes(buffer, firstValue, this.polynomial);
}
};
CRC.fromBytes = function (data, crc, polynomial) {
if (crc === void 0) { crc = CRC.FIRST_VALUE; }
if (polynomial === void 0) { polynomial = CRC.POLYNOMIAL_CRC32_MPEG2; }
if (data.length % CRC.MODULO !== 0) {
throw new Error("Cannot compute CRC, input size must be a multiple of 4. Length is " + data.length + " % " + CRC.MODULO + " = " + data.length % CRC.MODULO);
}
var uint32Data = new Uint32Array(data.length / 4);
for (var offset = 0; offset < uint32Data.byteLength; offset++) {
uint32Data[offset] = NumberConverter.fromOpaqueMsb(data.slice(offset * 4, (offset + 1) * 4), 32);
}
return CRC.fromWord(uint32Data, crc, polynomial);
};
// crc 32 calculation by word.
CRC.fromWord = function (buffer, crc, polynomial) {
if (crc === void 0) { crc = CRC.FIRST_VALUE; }
if (polynomial === void 0) { polynomial = CRC.POLYNOMIAL_CRC32_MPEG2; }
// don't follow null pointers
if (!buffer) {
throw new Error('Buffer is null');
}
// don't accept buffers larger than 16MB
if (buffer.byteLength > 16 * 1024 * 1024) {
throw new Error('Buffers larger than 16MB');
}
var myword;
for (var i = 0; i < buffer.length; i++) {
myword = buffer[i]; // Get next word.
crc = CRC.appendCrcNumber(crc, myword, polynomial);
}
return crc;
};
CRC.appendCrcNumber = function (crc, data, polynomial) {
crc = crc ^ data;
for (var i = 0; i < 32; i++) {
if (crc & 0x80000000) {
crc = ((crc << 1) ^ polynomial) >>> 0;
}
else {
crc = (crc << 1) >>> 0;
}
}
return crc;
};
return CRC;
}());
CRC.POLYNOMIAL_CRC32_MPEG2 = 0x4c11db7;
CRC.MODULO = 4;
CRC.FIRST_VALUE = 0xffffffff;
function enumKeyOrValueToNumber(key, mapping) {
if (typeof key === 'string') {
// if (!(key in mapping)) {
// throw new Error(``)
// }
return mapping[key];
}
else {
return key;
}
}
var TapStreamReader = /** @class */ (function (_super) {
__extends(TapStreamReader, _super);
function TapStreamReader() {
return _super !== null && _super.apply(this, arguments) || this;
}
TapStreamReader.fromArray = function (array) {
var buffer = byteConverter.typedArrayToBuffer(array);
return new TapStreamReader(buffer);
};
TapStreamReader.create = function (packet) {
return packet instanceof Uint8Array
? TapStreamReader.fromArray(packet)
: packet;
};
TapStreamReader.prototype.readStr = function (n) {
return String.fromCharCode.apply(null, this.readBytes(n));
};
/**
* Read given byte size as string
* @param n number of byte to read
*/
TapStreamReader.prototype.readString = function (n) {
if (n === void 0) { n = this.byteLeft; }
return this.readStr(n);
};
/**
* Read string until terminator character is reached
*/
TapStreamReader.prototype.readStringTerminator = function (terminator) {
var result = '';
while (true) {
var lastByte = this.readU1();
var lastChar = String.fromCharCode(lastByte);
if (lastChar !== terminator) {
result += lastChar;
}
else {
break;
}
}
return result;
};
TapStreamReader.prototype.readU2 = function () {
return this._isBigEndian ? this.readU2be() : this.readU2le();
};
TapStreamReader.prototype.readU4 = function () {
return this._isBigEndian ? this.readU4be() : this.readU4le();
};
TapStreamReader.prototype.readF4 = function () {
return this._isBigEndian ? this.readF4be() : this.readF4le();
};
TapStreamReader.prototype.subStream = function (length) {
return TapStreamReader.fromArray(this.readBytes(length));
};
return TapStreamReader;
}(byteStream.KaitaiStreamReader));
var TapStreamWriter = /** @class */ (function (_super) {
__extends(TapStreamWriter, _super);
function TapStreamWriter(lengthOrBuffer, byteOffset, isBigEndian) {
if (lengthOrBuffer === void 0) { lengthOrBuffer = 512; }
if (isBigEndian === void 0) { isBigEndian = true; }
var _this = this;
if (typeof lengthOrBuffer === 'number') {
lengthOrBuffer = new ArrayBuffer(lengthOrBuffer);
}
_this = _super.call(this, lengthOrBuffer, byteOffset, isBigEndian) || this;
return _this;
}
TapStreamWriter.create = function (size) {
return new TapStreamWriter(new ArrayBuffer(size));
};
TapStreamWriter.prototype.writeFunction = function (type, options, fieldValue, fieldSize) {
switch (type) {
case 'crc32':
return this.addCRC(options);
case 'padding':
if (fieldValue) {
debug('Padding is already set');
return this.writeBytes(fieldValue);
}
else {
if (typeof fieldSize == undefined) {
throw new Error("Padding function expect padding size as a second argument. Args: " + JSON.stringify(arguments));
}
return this.addPadding(fieldSize);
}
default:
throw new Error("Invalid writer function type: " + type);
}
};
TapStreamWriter.prototype.addPadding = function (padSize) {
this.writeBytes(new Uint8Array(padSize));
return this;
};
TapStreamWriter.prototype.addCRC = function (options) {
var buffer = this.toBytes;
if (options && options.offset) {
buffer = buffer.slice(options.offset);
}
var crc = CRC.fromBytes(buffer);
this.writeU4(crc);
// console.info(`TODO REMOVE Compute CRC from ${options ? options.offset : 0}:${buffer.length} 0x${bufferToHexString(buffer)} => 0x${crc.toString(16)}`)
return this;
};
TapStreamWriter.prototype.writeUnsigned = function (value, length) {
this.writeU(value, length);
return this;
};
TapStreamWriter.prototype.writeU4 = function (value) {
this.writeU(value, 4);
return this;
};
TapStreamWriter.prototype.writeU2 = function (value) {
this.writeU(value, 2);
return this;
};
TapStreamWriter.prototype.writeU1 = function (value) {
this.writeU(value, 1);
return this;
};
TapStreamWriter.prototype.writeF4 = function (value) {
this.writeF(value, 4);
return this;
};
TapStreamWriter.prototype.writeFloat = function (value, length) {
this.writeF(value, length);
return this;
};
TapStreamWriter.prototype.writeSigned = function (value, length) {
this.writeSigned(value, length);
return this;
};
TapStreamWriter.prototype.writeString = function (value, length) {
if (length === void 0) { length = (value === null || value === void 0 ? void 0 : value.length) || 0; }
return this.writeStr(value || '', length);
};
TapStreamWriter.prototype.writeStr = function (value, length) {
if (length === void 0) { length = value.length; }
var i = 1;
var stringWriteLength = Math.min(value.length, length);
for (; i <= stringWriteLength; i++) {
this.writeByte(value.charCodeAt(i - 1));
}
var remaining = length - stringWriteLength;
if (remaining > 0) {
this.writeBytes(new Uint8Array(remaining));
}
return this;
};
TapStreamWriter.prototype.writeBitsInt = function (value, n) {
this.writeB(value, n);
return this;
};
TapStreamWriter.prototype.writeBits = function (value, n) {
this.writeB(value, n);
return this;
};
TapStreamWriter.prototype.writeBoolean = function (value, n) {
this.writeBits(value ? 1 : 0, n);
return this;
};
return TapStreamWriter;
}(byteStream.KaitaiStreamWriter));
/**
* Generated file. Do not edit
*/
TapStreamReader.prototype.readApduRequest = function () {
var model = {};
model.header = this.readApduRequestHeader();
model.data = this.readBytes(model.header.lc);
return model;
};
TapStreamReader.prototype.readApduRequestHeader =
function () {
var model = {};
model.cla = this.readUnsigned(1);
model.ins = this.readUnsigned(1);
model.p1 = this.readUnsigned(1);
model.p2 = this.readUnsigned(1);
model.lc = this.readUnsigned(1);
return model;
};
TapStreamReader.prototype.readApduResponse = function () {
var model = {};
model.data = this.readBytes(this.getStreamSize() - 2);
model.status = this.readUnsigned(2);
return model;
};
TapStreamReader.prototype.readTapRequestEncrypted =
function () {
var model = {};
model.header = this.readApduRequestHeader();
model.request = this.readTapRequestFrame();
return model;
};
TapStreamReader.prototype.readTapApduRequest = function () {
var model = {};
return model;
};
TapStreamReader.prototype.readTapEncryptedFrame =
function () {
var model = {};
model.id = this.readUnsigned(2);
model.len = this.readUnsigned(2);
model.payload = this.readBytes(model.len);
model.padding = this.readBytes((16 - ((2 + 2 + (model.len === undefined ? 0 : model.len) + 4) % 16)) %
16);
model.crc = this.readUnsigned(4);
return model;
};
TapStreamReader.prototype.readTapRequestFrame = function () {
var model = {};
model.header = this.readTapRequestFrameHeader();
model.payload = this.readBytes();
return model;
};
TapStreamReader.prototype.readTapRequestFrameHeader =
function () {
var model = {};
model.methodType = this.readUnsigned(1);
model.path = this.readTapRequestFramePath();
return model;
};
TapStreamReader.prototype.readTapRequestFramePath =
function () {
var model = {};
model.objectId = this.readUnsigned(2);
model.objectInstanceId = this.readUnsigned(2);
model.resourceId = this.readUnsigned(2);
return model;
};
TapStreamReader.prototype.readTapResponseFrame = function () {
var model = {};
model.status = this.readUnsigned(1);
model.data = this.readBytes();
return model;
};
// TapStreamWriter.prototype.write(model: ApduRequest) : TapStreamWriter{
// return this.writeApduRequest(model)
// }
TapStreamWriter.prototype.writeApduRequest = function (model) {
this.writeApduRequestHeader(model.header);
this.writeBytes(model.data, model.header.lc);
return this;
};
TapStreamWriter.prototype.writeApduRequestHeader = function (model) {
this.writeUnsigned(model.cla, 1);
this.writeUnsigned(model.ins, 1);
this.writeUnsigned(model.p1, 1);
this.writeUnsigned(model.p2, 1);
this.writeUnsigned(model.lc, 1);
return this;
};
// TapStreamWriter.prototype.write(model: ApduResponse) : TapStreamWriter{
// return this.writeApduResponse(model)
// }
TapStreamWriter.prototype.writeApduResponse = function (model) {
this.writeBytes(model.data, undefined);
this.writeUnsigned(model.status, 2);
return this;
};
// TapStreamWriter.prototype.write(model: TapRequestEncrypted) : TapStreamWriter{
// return this.writeTapRequestEncrypted(model)
// }
TapStreamWriter.prototype.writeTapRequestEncrypted = function (model) {
this.writeApduRequestHeader(model.header);
this.writeTapRequestFrame(model.request);
return this;
};
// TapStreamWriter.prototype.write(model: TapApduRequest) : TapStreamWriter{
// return this.writeTapApduRequest(model)
// }
TapStreamWriter.prototype.writeTapApduRequest = function (model) {
return this;
};
// TapStreamWriter.prototype.write(model: TapEncryptedFrame) : TapStreamWriter{
// return this.writeTapEncryptedFrame(model)
// }
TapStreamWriter.prototype.writeTapEncryptedFrame = function (model) {
this.writeUnsigned(model.id, 2);
this.writeUnsigned(model.len, 2);
this.writeBytes(model.payload, model.len);
this.writeFunction('padding', undefined, model.padding, (16 - ((2 + 2 + (model.len === undefined ? 0 : model.len) + 4) % 16)) % 16);
this.writeFunction('crc32', undefined, model.crc, 4);
return this;
};
// TapStreamWriter.prototype.write(model: TapRequestFrame) : TapStreamWriter{
// return this.writeTapRequestFrame(model)
// }
TapStreamWriter.prototype.writeTapRequestFrame = function (model) {
this.writeTapRequestFrameHeader(model.header);
this.writeBytes(model.payload);
return this;
};
TapStreamWriter.prototype.writeTapRequestFrameHeader = function (model) {
this.writeBitsInt(enumKeyOrValueToNumber(model.methodType, api.TapRequestFrame.MethodType), 8);
this.writeTapRequestFramePath(model.path);
return this;
};
TapStreamWriter.prototype.writeTapRequestFramePath = function (model) {
this.writeUnsigned(model.objectId, 2);
this.writeUnsigned(model.objectInstanceId, 2);
this.writeUnsigned(model.resourceId, 2);
return this;
};
// TapStreamWriter.prototype.write(model: TapResponseFrame) : TapStreamWriter{
// return this.writeTapResponseFrame(model)
// }
TapStreamWriter.prototype.writeTapResponseFrame = function (model) {
this.writeUnsigned(model.status, 1);
this.writeBytes(model.data);
return this;
};
/**
* Generated file. Do not edit
*/
var ApduRequestConverter = /** @class */ (function () {
function ApduRequestConverter() {
}
ApduRequestConverter.prototype.encode = function (model, stream) {
if (stream === void 0) { stream = new TapStreamWriter(); }
stream.writeApduRequest(model);
return stream.toBytes;
};
ApduRequestConverter.prototype.decode = function (data) {
var stream = data instanceof TapStreamReader ? data : TapStreamReader.create(data);
return stream.readApduRequest();
};
return ApduRequestConverter;
}());
var ApduResponseConverter = /** @class */ (function () {
function ApduResponseConverter() {
}
ApduResponseConverter.prototype.encode = function (model, stream) {
if (stream === void 0) { stream = new TapStreamWriter(); }
stream.writeApduResponse(model);
return stream.toBytes;
};
ApduResponseConverter.prototype.decode = function (data) {
var stream = data instanceof TapStreamReader ? data : TapStreamReader.create(data);
return stream.readApduResponse();
};
return ApduResponseConverter;
}());
var TapRequestEncryptedConverter = /** @class */ (function () {
function TapRequestEncryptedConverter() {
}
TapRequestEncryptedConverter.prototype.encode = function (model, stream) {
if (stream === void 0) { stream = new TapStreamWriter(); }
stream.writeTapRequestEncrypted(model);
return stream.toBytes;
};
TapRequestEncryptedConverter.prototype.decode = function (data) {
var stream = data instanceof TapStreamReader ? data : TapStreamReader.create(data);
return stream.readTapRequestEncrypted();
};
return TapRequestEncryptedConverter;
}());
var TapApduRequestConverter$1 = /** @class */ (function () {
function TapApduRequestConverter() {
}
TapApduRequestConverter.prototype.encode = function (model, stream) {
if (stream === void 0) { stream = new TapStreamWriter(); }
stream.writeTapApduRequest(model);
return stream.toBytes;
};
TapApduRequestConverter.prototype.decode = function (data) {
var stream = data instanceof TapStreamReader ? data : TapStreamReader.create(data);
return stream.readTapApduRequest();
};
return TapApduRequestConverter;
}());
var TapEncryptedFrameConverter = /** @class */ (function () {
function TapEncryptedFrameConverter() {
}
TapEncryptedFrameConverter.prototype.encode = function (model, stream) {
if (stream === void 0) { stream = new TapStreamWriter(); }
stream.writeTapEncryptedFrame(model);
return stream.toBytes;
};
TapEncryptedFrameConverter.prototype.decode = function (data) {
var stream = data instanceof TapStreamReader ? data : TapStreamReader.create(data);
return stream.readTapEncryptedFrame();
};
return TapEncryptedFrameConverter;
}());
var TapRequestFrameConverter = /** @class */ (function () {
function TapRequestFrameConverter() {
}
TapRequestFrameConverter.prototype.encode = function (model, stream) {
if (stream === void 0) { stream = new TapStreamWriter(); }
stream.writeTapRequestFrame(model);
return stream.toBytes;
};
TapRequestFrameConverter.prototype.decode = function (data) {
var stream = data instanceof TapStreamReader ? data : TapStreamReader.create(data);
return stream.readTapRequestFrame();
};
return TapRequestFrameConverter;
}());
var TapResponseFrameConverter = /** @class */ (function () {
function TapResponseFrameConverter() {
}
TapResponseFrameConverter.prototype.encode = function (model, stream) {
if (stream === void 0) { stream = new TapStreamWriter(); }
stream.writeTapResponseFrame(model);
return stream.toBytes;
};
TapResponseFrameConverter.prototype.decode = function (data) {
var stream = data instanceof TapStreamReader ? data : TapStreamReader.create(data);
return stream.readTapResponseFrame();
};
return TapResponseFrameConverter;
}());
function createApduFromTapRequest(request) {
var data = new TapRequestFrameConverter().encode(request); // TODO
// TODO check if size > 255 ?
var ins;
switch (request.header.methodType) {
case api.TapRequestFrame.MethodType.GET:
ins = api.TapApduRequest.MethodType.GET;
break;
case api.TapRequestFrame.MethodType.PUT:
case api.TapRequestFrame.MethodType.POST:
ins = api.TapApduRequest.MethodType.PUT_OR_POST;
break;
default:
throw new Error("Internal error: request type \"" + request.header.methodType + "\" is invalid");
}
return {
header: {
cla: api.TapApduRequest.Default.CLA,
ins: ins,
p1: 0,
p2: 0,
lc: data.length,
},
data: data,
};
}
exports.TapRequestFrameBuilder = /** @class */ (function () {
function TapRequestFrameBuilder() {
}
// public static fromBytes(bytes: Uint8Array): Header {
// const path = TapStreamReader.fromArray(bytes).readTapRequestPath();
// const header = new Header(path);
// if (bytes.length == 8) {
// // What is that ???
// header.resourceInstance =
// ((bytes[6] << 8) & Header.MAX_ID) + (bytes[7] & 0xff);
// header.resourceInstance &= Header.MAX_ID;
// }
// // return header;
// return header;
// }
TapRequestFrameBuilder.parsePath = function (path) {
if (!path || path.length === 0) {
throw new Error('Missing LWM2M path, it must not be empty'); // TODO better error
}
path = path.trim();
var result = path.match(TapRequestFrameBuilder.PATH_EXPRESSION);
if (!result || result.length === 0) {
throw new Error("Invalid LWM2M path \"" + path + "\", it does not match expected format"); // TODO better error
}
var header = {
objectId: this.validateId(parseInt(result[1])),
objectInstanceId: result[2] ? parseInt(result[2]) : 0xffff,
resourceId: parseInt(result[3]),
};
if (result[4]) {
header['resourceInstanceId'] = parseInt(result[4], 10);
}
return header;
};
TapRequestFrameBuilder.GET = function (url, body) {
return TapRequestFrameBuilder.create(api.TapRequestFrame.MethodType.GET, url, body);
};
TapRequestFrameBuilder.PUT = function (url, body) {
return TapRequestFrameBuilder.create(api.TapRequestFrame.MethodType.PUT, url, body);
};
TapRequestFrameBuilder.POST = function (url, body) {
return TapRequestFrameBuilder.create(api.TapRequestFrame.MethodType.POST, url, body);
};
TapRequestFrameBuilder.create = function (method, url, data) {
return {
header: {
path: TapRequestFrameBuilder.parsePath(url),
methodType: method,
},
payload: data || new Uint8Array(),
};
};
TapRequestFrameBuilder.validateId = function (id) {
if (id < 0 || id > TapRequestFrameBuilder.MAX_ID) {
throw new Error("Invalid identifier \"" + id + "\". It must be a number between " + id + " and " + TapRequestFrameBuilder.MAX_ID);
}
return id;
};
return TapRequestFrameBuilder;
}());
exports.TapRequestFrameBuilder.MAX_ID = 0xffff;
(function (TapRequestFrameBuilder) {
TapRequestFrameBuilder.PATH_EXPRESSION = /^\/?([0-9]+)\/([0-9]+)?\/([0-9]+)\/?([0-9]+)?$/;
})(exports.TapRequestFrameBuilder || (exports.TapRequestFrameBuilder = {}));
var TapRequestHelper = /** @class */ (function () {
function TapRequestHelper() {
}
// static toString(request: TapRequestFrame) {
// return `${TapRequestFrame.MethodType[request.header.methodType]} ${TapRequestHelper.pathToString(request.header.path)}`;
// }
TapRequestHelper.toString = function (request, options) {
var result = api.TapRequestFrame.MethodType[request.header.methodType] + " " + TapRequestHelper.pathToString(request.header.path, options);
if (request.payload && request.payload.length > 0) {
result += " 0x" + byteConverter.bufferToHexString(request.payload);
}
return result;
};
TapRequestHelper.pathToString = function (path, options) {
var resourceInstanceId = path['resourceInstanceId'];
return ('/' +
path.objectId +
'/' +
(path.objectInstanceId === exports.TapRequestFrameBuilder.MAX_ID
? (options === null || options === void 0 ? void 0 : options.printMaxId)
? path.objectInstanceId
: ''
: path.objectInstanceId) +
'/' +
path.resourceId +
(resourceInstanceId ? '/' + resourceInstanceId