@xelis/sdk 0.11.15 → 0.11.16

package/dist/esm/data/value.js

@@ -4,7 +4,7 @@ var ErrMaxStringSize = "string max limit is 255 bytes";
 var MaxBlobSize = 65535;
 var ErrMaxBlobSize = "blob max size is 65535 bytes";
 function ErrUnsupportedValue(value) {
-    return "unsupported value type ".concat(value);
+    return `unsupported value type ${value}`;
 }
 function getUIntTypeByValue(value) {
     if (value < 0)
@@ -33,16 +33,16 @@ export var ValueType;
     ValueType[ValueType["Hash"] = 7] = "Hash";
     ValueType[ValueType["Blob"] = 8] = "Blob";
 })(ValueType || (ValueType = {}));
-var Value = /** @class */ (function () {
-    function Value(vType, data) {
+export class Value {
+    constructor(vType, data) {
         this.vType = vType;
         this.data = data;
     }
-    Value["new"] = function (data) {
-        if (typeof data === "string") {
+    static new(data) {
+        if (typeof data === `string`) {
             return new Value(ValueType.String, data);
         }
-        else if (typeof data === "boolean") {
+        else if (typeof data === `boolean`) {
             return new Value(ValueType.Bool, data);
         }
         else if (Array.isArray(data)) {
@@ -52,7 +52,7 @@ var Value = /** @class */ (function () {
             return new Value(ValueType.Hash, data);
         }
         else if (typeof data === "number" || typeof data === "bigint") {
-            var eType = getUIntTypeByValue(data);
+            let eType = getUIntTypeByValue(data);
             switch (eType) {
                 case ValueType.U8:
                     return new Value(ValueType.U8, data);
@@ -69,81 +69,79 @@ var Value = /** @class */ (function () {
             }
         }
         throw "unsupported data type";
-    };
-    return Value;
-}());
-export { Value };
-var ValueReader = /** @class */ (function () {
-    function ValueReader(data) {
+    }
+}
+export class ValueReader {
+    constructor(data) {
         this.data = Array.from(data);
     }
-    ValueReader.prototype.read = function () {
-        var eType = this.readByte();
+    read() {
+        let eType = this.readByte();
         switch (eType) {
             case ElementType.Value:
                 return Element.value(this.readValue());
             case ElementType.Array:
-                var arrSize = this.readByte();
-                var elements = [];
-                for (var i = 0; i < arrSize; i++) {
+                let arrSize = this.readByte();
+                let elements = [];
+                for (let i = 0; i < arrSize; i++) {
                     elements.push(this.read());
                 }
                 return Element.array(elements);
             case ElementType.Fields:
-                var fieldsSize = this.readByte();
-                var map = new Map();
-                for (var i = 0; i < fieldsSize; i++) {
+                let fieldsSize = this.readByte();
+                let map = new Map();
+                for (let i = 0; i < fieldsSize; i++) {
                     map.set(this.readValue(), this.read());
                 }
                 return Element.fields(map);
             default:
                 throw "invalid element type";
         }
-    };
-    ValueReader.prototype.readByte = function () {
+    }
+    readByte() {
         return this.data.splice(0, 1)[0];
-    };
-    ValueReader.prototype.readU16 = function () {
-        var arr = new Uint8Array(this.data.splice(0, 2));
-        var view = new DataView(arr.buffer);
+    }
+    readU16() {
+        let arr = new Uint8Array(this.data.splice(0, 2));
+        let view = new DataView(arr.buffer);
         return view.getUint16(0, false);
-    };
-    ValueReader.prototype.readU32 = function () {
-        var arr = new Uint8Array(this.data.splice(0, 4));
-        var view = new DataView(arr.buffer);
+    }
+    readU32() {
+        let arr = new Uint8Array(this.data.splice(0, 4));
+        let view = new DataView(arr.buffer);
         return view.getUint32(0, false);
-    };
-    ValueReader.prototype.readU64 = function () {
-        var arr = new Uint8Array(this.data.splice(0, 8));
-        var view = new DataView(arr.buffer);
+    }
+    readU64() {
+        let arr = new Uint8Array(this.data.splice(0, 8));
+        let view = new DataView(arr.buffer);
         return view.getBigUint64(0, false);
-    };
-    ValueReader.prototype.readU128 = function () {
-        var data = this.data.splice(0, 16);
-        var value = BigInt(0);
-        for (var i = 0; i < 16; i++) {
+    }
+    readU128() {
+        let data = this.data.splice(0, 16);
+        let value = BigInt(0);
+        for (let i = 0; i < 16; i++) {
             value = (value << BigInt(8)) | BigInt(data[i]);
         }
         return value;
-    };
-    ValueReader.prototype.readString = function () {
-        var size = this.readByte();
-        var decoder = new TextDecoder();
-        var data = new Uint8Array(this.data.splice(0, size));
+    }
+    readString() {
+        let size = this.readByte();
+        let decoder = new TextDecoder();
+        let data = new Uint8Array(this.data.splice(0, size));
         return decoder.decode(data);
-    };
-    ValueReader.prototype.readBool = function () {
+    }
+    readBool() {
         return this.readByte() === 1 ? true : false;
-    };
-    ValueReader.prototype.readHash = function () {
+    }
+    readHash() {
         return this.data.splice(0, 32);
-    };
-    ValueReader.prototype.readBlob = function () {
-        var size = this.readByte();
+    }
+    readBlob() {
+        let size = this.readByte();
         return this.data.splice(0, size);
-    };
-    ValueReader.prototype.readValue = function () {
-        var vType = this.readByte();
+    }
+    readValue() {
+        let vType = this.readByte();
         switch (vType) {
             case ValueType.U8:
                 return new Value(vType, this.readByte());
@@ -166,17 +164,14 @@ var ValueReader = /** @class */ (function () {
             default:
                 throw "";
         }
-    };
-    return ValueReader;
-}());
-export { ValueReader };
-var ValueWriter = /** @class */ (function () {
-    function ValueWriter() {
+    }
+}
+export class ValueWriter {
+    constructor() {
         this.data = [];
     }
-    ValueWriter.prototype.write = function (dataElement) {
-        var _this = this;
-        var eType = dataElement.validate();
+    write(dataElement) {
+        let eType = dataElement.validate();
         switch (eType) {
             case ElementType.Value:
                 this.writeU8(ElementType.Value);
@@ -184,100 +179,99 @@ var ValueWriter = /** @class */ (function () {
                 break;
             case ElementType.Array:
                 this.writeU8(ElementType.Array);
-                var array = dataElement.array;
+                let array = dataElement.array;
                 this.writeU8(array.length);
-                array.forEach(function (element) {
-                    _this.write(element);
+                array.forEach((element) => {
+                    this.write(element);
                 });
                 break;
             case ElementType.Fields:
                 this.writeU8(ElementType.Fields);
-                var fields = dataElement.fields;
+                let fields = dataElement.fields;
                 this.writeU8(fields.size);
-                fields.forEach(function (element, key) {
-                    _this.writeValue(key);
-                    _this.write(element);
+                fields.forEach((element, key) => {
+                    this.writeValue(key);
+                    this.write(element);
                 });
                 break;
         }
-    };
-    ValueWriter.prototype.appendData = function (data) {
-        var _a;
-        (_a = this.data).push.apply(_a, Array.from(data));
-    };
-    ValueWriter.prototype.appendBuffer = function (buf) {
+    }
+    appendData(data) {
+        this.data.push(...Array.from(data));
+    }
+    appendBuffer(buf) {
         this.appendData(new Uint8Array(buf));
-    };
-    ValueWriter.prototype.writeU8 = function (value) {
+    }
+    writeU8(value) {
         if (typeof value !== "number") {
             throw "value is not a number";
         }
         this.appendBuffer(new Uint8Array([value]));
-    };
-    ValueWriter.prototype.writeU16 = function (value) {
+    }
+    writeU16(value) {
         if (typeof value !== "number") {
             throw "value is not a number";
         }
-        var buf = new ArrayBuffer(2);
-        var view = new DataView(buf);
+        let buf = new ArrayBuffer(2);
+        let view = new DataView(buf);
         view.setUint16(0, value, false);
         this.appendBuffer(buf);
-    };
-    ValueWriter.prototype.writeU32 = function (value) {
+    }
+    writeU32(value) {
         if (typeof value !== "number") {
             throw "value is not a number";
         }
-        var buf = new ArrayBuffer(4);
-        var view = new DataView(buf);
+        let buf = new ArrayBuffer(4);
+        let view = new DataView(buf);
         view.setUint32(0, value, false);
         this.appendBuffer(buf);
-    };
-    ValueWriter.prototype.writeU64 = function (value) {
+    }
+    writeU64(value) {
         if (typeof value !== "bigint") {
             throw "value is not a bigint";
         }
-        var buf = new ArrayBuffer(8);
-        var view = new DataView(buf);
+        let buf = new ArrayBuffer(8);
+        let view = new DataView(buf);
         view.setBigUint64(0, value, false);
         this.appendBuffer(buf);
-    };
-    ValueWriter.prototype.writeU128 = function (value) {
+    }
+    writeU128(value) {
         if (typeof value !== "bigint") {
             throw "value is not a bigint";
         }
-        var bytes = [];
-        for (var i = 0; i < 16; i++) {
-            var byte = Number((value >> BigInt(8 * (15 - i))) & BigInt(0xFF));
+        let bytes = [];
+        for (let i = 0; i < 16; i++) {
+            let byte = Number((value >> BigInt(8 * (15 - i))) & BigInt(0xFF));
             bytes.push(byte);
         }
         this.appendData(new Uint8Array(bytes));
-    };
-    ValueWriter.prototype.writeString = function (value) {
+    }
+    writeString(value) {
         if (typeof value !== "string") {
             throw "value is not string";
         }
-        var encoder = new TextEncoder();
-        var data = encoder.encode(value);
+        let encoder = new TextEncoder();
+        let data = encoder.encode(value);
         if (data.length > MaxStringSize) {
             throw ErrMaxStringSize;
         }
         this.writeU8(data.length);
         this.appendData(data);
-    };
-    ValueWriter.prototype.writeBool = function (value) {
+    }
+    writeBool(value) {
         if (typeof value !== "boolean") {
             throw "value is not a boolean";
         }
         this.writeU8(value ? 1 : 0);
-    };
-    ValueWriter.prototype.writeBlob = function (value) {
+    }
+    writeBlob(value) {
         this.writeU8(value.length);
         this.appendData(new Uint8Array(value));
-    };
-    ValueWriter.prototype.writeHash = function (value) {
+    }
+    writeHash(value) {
         this.appendData(value);
-    };
-    ValueWriter.prototype.writeValue = function (value) {
+    }
+    writeValue(value) {
         switch (value.vType) {
             case ValueType.Bool:
                 this.writeU8(ValueType.Bool);
@@ -318,7 +312,5 @@ var ValueWriter = /** @class */ (function () {
             default:
                 throw ErrUnsupportedValue(value);
         }
-    };
-    return ValueWriter;
-}());
-export { ValueWriter };
+    }
+}

package/dist/esm/react/daemon.js

@@ -1,86 +1,76 @@
-var __spreadArray = (this && this.__spreadArray) || function (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));
-};
 import React, { createContext, useContext, useEffect, useState } from 'react';
 import DaemonWS from '../daemon/websocket.js';
-export var INITIATING = -1;
-var Context = createContext({
+export const INITIATING = -1;
+const Context = createContext({
     err: undefined,
     daemon: undefined,
     readyState: INITIATING
 });
-export var NodeSocketProvider = function (props) {
-    var children = props.children, endpoint = props.endpoint, timeout = props.timeout;
-    var _a = useState(INITIATING), readyState = _a[0], setReadyState = _a[1];
-    var _b = useState(), err = _b[0], setErr = _b[1];
-    var _c = useState(), daemon = _c[0], setDaemon = _c[1];
-    useEffect(function () {
-        var daemon = new DaemonWS(endpoint);
+export const NodeSocketProvider = (props) => {
+    const { children, endpoint, timeout } = props;
+    const [readyState, setReadyState] = useState(INITIATING);
+    const [err, setErr] = useState();
+    const [daemon, setDaemon] = useState();
+    useEffect(() => {
+        const daemon = new DaemonWS(endpoint);
         setDaemon(daemon);
-        return function () { return daemon.socket.close(); };
+        return () => daemon.socket.close();
     }, [endpoint]);
-    useEffect(function () {
+    useEffect(() => {
         if (!timeout)
             return;
         if (daemon)
             daemon.callTimeout = timeout;
     }, [timeout]);
-    useEffect(function () {
+    useEffect(() => {
         if (!daemon)
             return;
         setReadyState(daemon.socket.readyState);
-        var onOpen = function () {
+        const onOpen = () => {
             setReadyState(daemon.socket.readyState);
             setErr(undefined);
         };
-        var onClose = function (event) {
+        const onClose = (event) => {
             if (!daemon.socket)
                 return;
             setReadyState(daemon.socket.readyState);
             setErr(new Error(event.reason));
         };
-        var onError = function (err) {
+        const onError = (err) => {
             if (!daemon.socket)
                 return;
             setReadyState(daemon.socket.readyState);
             setErr(new Error(err.message));
         };
-        daemon.socket.addEventListener("open", onOpen);
-        daemon.socket.addEventListener("close", onClose);
-        daemon.socket.addEventListener("error", onError);
-        return function () {
+        daemon.socket.addEventListener(`open`, onOpen);
+        daemon.socket.addEventListener(`close`, onClose);
+        daemon.socket.addEventListener(`error`, onError);
+        return () => {
             if (!daemon.socket)
                 return;
-            daemon.socket.removeEventListener("open", onOpen);
-            daemon.socket.removeEventListener("close", onClose);
-            daemon.socket.removeEventListener("error", onError);
+            daemon.socket.removeEventListener(`open`, onOpen);
+            daemon.socket.removeEventListener(`close`, onClose);
+            daemon.socket.removeEventListener(`error`, onError);
         };
     }, [daemon]);
-    return React.createElement(Context.Provider, { value: { daemon: daemon, err: err, readyState: readyState } }, children);
+    return React.createElement(Context.Provider, { value: { daemon, err, readyState } }, children);
 };
-export var useNodeSocketSubscribe = function (_a, dependencies) {
-    var event = _a.event, onLoad = _a.onLoad, onData = _a.onData;
-    var nodeSocket = useNodeSocket();
-    useEffect(function () {
+export const useNodeSocketSubscribe = ({ event, onLoad, onData }, dependencies) => {
+    const nodeSocket = useNodeSocket();
+    useEffect(() => {
         if (!nodeSocket.daemon)
             return;
         if (nodeSocket.readyState !== WebSocket.OPEN)
             return;
-        if (typeof onLoad === "function")
+        if (typeof onLoad === `function`)
             onLoad();
         nodeSocket.daemon.listen(event, onData);
-        return function () {
+        return () => {
             if (!nodeSocket.daemon)
                 return;
             nodeSocket.daemon.closeListener(event, onData);
         };
-    }, __spreadArray([nodeSocket], dependencies, true));
+    }, [nodeSocket, ...dependencies]);
 };
-export var useNodeSocket = function () { return useContext(Context); };
+export const useNodeSocket = () => useContext(Context);
 export default useNodeSocket;