libshv-js 3.9.0 → 3.9.2

package/dist/chainpack.js

@@ -0,0 +1,555 @@
+/* eslint-disable no-bitwise */
+import { utf8ToString } from './cpon';
+import { Decimal, Double, RpcValueWithMetaData, UInt, withOffset, shvMapType } from './rpcvalue';
+import { UnpackContext, PackContext } from './cpcontext';
+var PackingSchema;
+(function (PackingSchema) {
+    PackingSchema[PackingSchema["IntThreshold"] = 64] = "IntThreshold";
+    PackingSchema[PackingSchema["Null"] = 128] = "Null";
+    PackingSchema[PackingSchema["UInt"] = 129] = "UInt";
+    PackingSchema[PackingSchema["Int"] = 130] = "Int";
+    PackingSchema[PackingSchema["Double"] = 131] = "Double";
+    PackingSchema[PackingSchema["Bool"] = 132] = "Bool";
+    PackingSchema[PackingSchema["Blob"] = 133] = "Blob";
+    PackingSchema[PackingSchema["String"] = 134] = "String";
+    PackingSchema[PackingSchema["List"] = 136] = "List";
+    PackingSchema[PackingSchema["Map"] = 137] = "Map";
+    PackingSchema[PackingSchema["IMap"] = 138] = "IMap";
+    PackingSchema[PackingSchema["MetaMap"] = 139] = "MetaMap";
+    PackingSchema[PackingSchema["Decimal"] = 140] = "Decimal";
+    PackingSchema[PackingSchema["DateTime"] = 141] = "DateTime";
+    PackingSchema[PackingSchema["CString"] = 142] = "CString";
+    PackingSchema[PackingSchema["False"] = 253] = "False";
+    PackingSchema[PackingSchema["True"] = 254] = "True";
+    PackingSchema[PackingSchema["Term"] = 255] = "Term";
+})(PackingSchema || (PackingSchema = {}));
+const SHV_EPOCH_MSEC = 1_517_529_600_000;
+const INVALID_MIN_OFFSET_FROM_UTC = (-64 * 15);
+const divInt = (n, d) => {
+    const r = n % d;
+    return [(n - r) / d, r];
+};
+const uint8ArrayBoBigint = (bytes, type) => {
+    let isNeg = false;
+    if (type === 'Int') {
+        if (bytes.length < 5) {
+            const signMask = 0x80 >> bytes.length;
+            isNeg = Boolean(bytes[0] & signMask);
+            bytes[0] &= ~signMask;
+        }
+        else {
+            isNeg = Boolean(bytes[1] & 128);
+            bytes[1] &= ~128;
+        }
+    }
+    let ret = 0n;
+    for (const byte of bytes) {
+        ret = (ret * 256n) + BigInt(byte);
+    }
+    if (isNeg) {
+        ret = -ret;
+    }
+    return ret;
+};
+const numberToUint8Array = (num) => {
+    let bytes = new Uint8Array(8);
+    let len = 0;
+    do {
+        const res = divInt(num, 256n);
+        num = res[0];
+        bytes[len++] = Number(res[1]);
+    } while (num !== 0n);
+    bytes = bytes.subarray(0, len);
+    bytes.reverse();
+    return bytes;
+};
+const significantBitsCount = (num) => {
+    let ret = 0;
+    while (num > 0) {
+        ret++;
+        num >>= 1n;
+    }
+    return ret;
+};
+class ChainPackReader {
+    ctx;
+    constructor(data) {
+        this.ctx = data instanceof UnpackContext ? data : new UnpackContext(data);
+    }
+    /* eslint-disable complexity */
+    read() {
+        let meta;
+        let codePointAt = this.ctx.getByte();
+        if (codePointAt === PackingSchema.MetaMap) {
+            meta = this.readMetaMap();
+            codePointAt = this.ctx.getByte();
+        }
+        const implReturn = (x) => {
+            const ret = meta !== undefined ? new RpcValueWithMetaData(meta, x) : x;
+            return ret;
+        };
+        if (codePointAt < PackingSchema.Null) {
+            if (codePointAt >= PackingSchema.IntThreshold) {
+                return implReturn(codePointAt - 64);
+            }
+            return implReturn(new UInt(codePointAt));
+        }
+        switch (codePointAt) {
+            case PackingSchema.Null: {
+                return implReturn(undefined);
+            }
+            case PackingSchema.True: {
+                return implReturn(true);
+            }
+            case PackingSchema.False: {
+                return implReturn(false);
+            }
+            case PackingSchema.Int: {
+                return implReturn(this.readIntData());
+            }
+            case PackingSchema.UInt: {
+                return implReturn(new UInt(this.readUIntData()));
+            }
+            case PackingSchema.Double: {
+                const data = new Uint8Array(8);
+                for (let i = 0; i < 8; i++) {
+                    data[i] = this.ctx.getByte();
+                }
+                return implReturn(new Double(new DataView(data.buffer).getFloat64(0, true))); // little endian
+            }
+            case PackingSchema.Decimal: {
+                const mant = this.readIntData();
+                const exp = this.readIntData();
+                return implReturn(new Decimal(mant, exp));
+            }
+            case PackingSchema.DateTime: {
+                let bi = this.readUIntDataHelper('UInt');
+                const hasTzOffset = bi & 1n;
+                const hasNotMsec = bi & 2n;
+                bi >>= 2n;
+                let offset = 0;
+                if (hasTzOffset !== 0n) {
+                    offset = Number(bi & 0x7fn);
+                    if ((offset & 0x40) !== 0) {
+                        // sign extension
+                        offset -= 128;
+                    }
+                    bi >>= 7n;
+                }
+                offset *= 15;
+                if (offset === INVALID_MIN_OFFSET_FROM_UTC) {
+                    return implReturn(undefined);
+                }
+                let msec = Number(bi);
+                if (hasNotMsec !== 0n) {
+                    msec *= 1000;
+                }
+                msec += SHV_EPOCH_MSEC;
+                msec -= offset * 60_000;
+                return withOffset(new Date(msec), offset ?? undefined);
+            }
+            case PackingSchema.Map: {
+                return implReturn(this.readMap());
+            }
+            case PackingSchema.IMap: {
+                return implReturn(this.readIMap());
+            }
+            case PackingSchema.List: {
+                return implReturn(this.readList());
+            }
+            case PackingSchema.Blob: {
+                const strLen = this.readUIntData();
+                const arr = new Uint8Array(strLen);
+                for (let i = 0; i < strLen; i++) {
+                    arr[i] = this.ctx.getByte();
+                }
+                return implReturn(arr.buffer);
+            }
+            case PackingSchema.String: {
+                const strLen = this.readUIntData();
+                const arr = new Uint8Array(strLen);
+                for (let i = 0; i < strLen; i++) {
+                    arr[i] = this.ctx.getByte();
+                }
+                return implReturn(utf8ToString(arr.buffer));
+            }
+            case PackingSchema.CString: {
+                // variation of CponReader.readCString()
+                const pctx = new PackContext();
+                while (true) {
+                    let b = this.ctx.getByte();
+                    if (b === '\\'.codePointAt(0)) {
+                        b = this.ctx.getByte();
+                        switch (b) {
+                            case '\\'.codePointAt(0):
+                                pctx.putByte('\\'.codePointAt(0));
+                                break;
+                            case '0'.codePointAt(0):
+                                pctx.putByte(0);
+                                break;
+                            default:
+                                pctx.putByte(b);
+                                break;
+                        }
+                    }
+                    else if (b === 0) {
+                        // end of string
+                        break;
+                    }
+                    else {
+                        pctx.putByte(b);
+                    }
+                }
+                return implReturn(utf8ToString(pctx.buffer()));
+            }
+            default:
+                throw new TypeError('ChainPack - Invalid type info: ' + codePointAt);
+        }
+    }
+    /* eslint-enable complexity */
+    readUIntDataHelper(type) {
+        let num = 0;
+        const head = this.ctx.getByte();
+        let bytesToReadCnt;
+        switch (0) {
+            case head & 128: {
+                bytesToReadCnt = 0;
+                num = head & 127;
+                break;
+            }
+            case head & 64: {
+                bytesToReadCnt = 1;
+                num = head & 63;
+                break;
+            }
+            case head & 32: {
+                bytesToReadCnt = 2;
+                num = head & 31;
+                break;
+            }
+            case head & 16: {
+                bytesToReadCnt = 3;
+                num = head & 15;
+                break;
+            }
+            default: {
+                bytesToReadCnt = (head & 0xF) + 4;
+            }
+        }
+        const bytes = new Uint8Array(bytesToReadCnt + 1);
+        bytes[0] = num;
+        for (let i = 0; i < bytesToReadCnt; i++) {
+            const r = this.ctx.getByte();
+            bytes[i + 1] = r;
+        }
+        return uint8ArrayBoBigint(bytes, type);
+    }
+    readIntData() {
+        const val = this.readUIntDataHelper('Int');
+        if (val <= Number.MIN_SAFE_INTEGER) {
+            return Number.MIN_SAFE_INTEGER;
+        }
+        if (val >= Number.MAX_SAFE_INTEGER) {
+            return Number.MAX_SAFE_INTEGER;
+        }
+        return Number(val);
+    }
+    readUIntData() {
+        const val = this.readUIntDataHelper('UInt');
+        if (val >= Number.MAX_SAFE_INTEGER) {
+            return Number.MAX_SAFE_INTEGER;
+        }
+        return Number(val);
+    }
+    readList() {
+        const lst = [];
+        while (true) {
+            const b = this.ctx.peekByte();
+            if (b === PackingSchema.Term) {
+                this.ctx.getByte();
+                break;
+            }
+            lst.push(this.read());
+        }
+        return lst;
+    }
+    readMetaMap() {
+        return this.implReadMap('metamap');
+    }
+    readMap() {
+        return this.implReadMap('map');
+    }
+    readIMap() {
+        return this.implReadMap('imap');
+    }
+    implReadMap(mapType) {
+        const map = {
+            [shvMapType]: mapType,
+        };
+        while (true) {
+            const b = this.ctx.peekByte();
+            if (b === PackingSchema.Term) {
+                this.ctx.getByte();
+                break;
+            }
+            const key = this.read();
+            const val = this.read();
+            if (map[shvMapType] === 'metamap' && typeof key === 'string') {
+                map[key] = val;
+            }
+            else if (map[shvMapType] === 'metamap' && typeof key === 'number') {
+                map[Number(key)] = val;
+            }
+            else if (map[shvMapType] === 'map' && typeof key === 'string') {
+                map[key] = val;
+            }
+            else if (map[shvMapType] === 'imap' && typeof key === 'number') {
+                map[Number(key)] = val;
+            }
+            else {
+                throw new TypeError('Malformed map, invalid key');
+            }
+        }
+        return map;
+    }
+}
+class ChainPackWriter {
+    ctx;
+    constructor() {
+        this.ctx = new PackContext();
+    }
+    write(rpcVal) {
+        if (rpcVal instanceof RpcValueWithMetaData) {
+            this.writeMeta(rpcVal.meta);
+            rpcVal = rpcVal.value;
+        }
+        switch (true) {
+            case rpcVal === undefined:
+                this.ctx.putByte(PackingSchema.Null);
+                break;
+            case typeof rpcVal === 'boolean':
+                this.ctx.putByte(rpcVal ? PackingSchema.True : PackingSchema.False);
+                break;
+            case typeof rpcVal === 'string':
+                this.writeJSString(rpcVal);
+                break;
+            case rpcVal instanceof ArrayBuffer:
+                this.writeBlob(rpcVal);
+                break;
+            case rpcVal instanceof UInt:
+                this.writeUInt(rpcVal);
+                break;
+            case typeof rpcVal === 'number':
+                this.writeInt(rpcVal);
+                break;
+            case rpcVal instanceof Decimal:
+                this.writeDecimal(rpcVal);
+                break;
+            case Array.isArray(rpcVal):
+                this.writeList(rpcVal);
+                break;
+            case rpcVal instanceof Date:
+                this.writeDateTime(rpcVal);
+                break;
+            case rpcVal instanceof Double:
+                this.writeDouble(rpcVal);
+                break;
+            case typeof rpcVal === 'object':
+                switch (rpcVal[shvMapType]) {
+                    case 'imap':
+                        this.writeIMap(rpcVal);
+                        break;
+                    case 'map':
+                        this.writeMap(rpcVal);
+                        break;
+                }
+                break;
+            default:
+                console.log('Can\'t serialize', rpcVal);
+                throw new Error('Can\'t serialize');
+        }
+    }
+    writeUIntDataHelper(num, type) {
+        const isNegative = num < 0;
+        if (isNegative) {
+            num = -num;
+        }
+        const significantBits = significantBitsCount(num) + ( /* one more needed for sign bit */type === 'Int' ? 1 : 0);
+        const bytesNeeded = significantBits <= 28 ? Math.trunc((significantBits - 1) / 7) + 1 : Math.trunc((significantBits - 1) / 8) + 2;
+        switch (bytesNeeded) {
+            case 0:
+                throw new Error(`Failed to count bytes needed for ${num}`);
+            case 1:
+                if (isNegative) {
+                    num |= 64n;
+                }
+                break;
+            case 2:
+                num |= 128n << 8n;
+                if (isNegative) {
+                    num |= 32n << 8n;
+                }
+                break;
+            case 3:
+                num |= 192n << 16n;
+                if (isNegative) {
+                    num |= 16n << 16n;
+                }
+                break;
+            case 4:
+                num |= 224n << 24n;
+                if (isNegative) {
+                    num |= 8n << 24n;
+                }
+                break;
+            default:
+                num |= 240n << BigInt((bytesNeeded - 1) * 8);
+                num |= BigInt(bytesNeeded - 4 /* n is offset by 4 */ - 1 /* for the control byte */) << BigInt((bytesNeeded - 1) * 8);
+                if (isNegative) {
+                    num |= 128n << BigInt((bytesNeeded - 2) * 8);
+                }
+                break;
+        }
+        const bytes = numberToUint8Array(num);
+        for (const byte of bytes) {
+            this.ctx.putByte(byte);
+        }
+    }
+    writeUIntData(num) {
+        this.writeUIntDataHelper(BigInt(num), 'UInt');
+    }
+    writeIntData(snum) {
+        this.writeUIntDataHelper(BigInt(snum), 'Int');
+    }
+    writeInt(n) {
+        if (Number(n) >= 0 && Number(n) < 64) {
+            this.ctx.putByte(Number(n) + 64);
+            return;
+        }
+        this.ctx.putByte(PackingSchema.Int);
+        this.writeIntData(Number(n));
+    }
+    writeUInt(n) {
+        if (Number(n) < 64) {
+            this.ctx.putByte(Number(n));
+            return;
+        }
+        this.ctx.putByte(PackingSchema.UInt);
+        this.writeUIntData(Number(n));
+    }
+    writeJSString(str) {
+        this.ctx.putByte(PackingSchema.String);
+        const pctx = new PackContext();
+        pctx.writeStringUtf8(str);
+        this.writeUIntData(pctx.length);
+        for (let i = 0; i < pctx.length; i++) {
+            this.ctx.putByte(pctx.data[i]);
+        }
+    }
+    writeDecimal(val) {
+        this.ctx.putByte(PackingSchema.Decimal);
+        this.writeIntData(val.mantisa);
+        this.writeIntData(val.exponent);
+    }
+    writeBlob(blob) {
+        this.ctx.putByte(PackingSchema.Blob);
+        const arr = new Uint8Array(blob);
+        this.writeUIntData(arr.length);
+        for (const element of arr) {
+            this.ctx.putByte(element);
+        }
+    }
+    writeDateTime(dt) {
+        this.ctx.putByte(PackingSchema.DateTime);
+        let msecs = (dt.getTime() + (60_000 * (dt.utc_offset ?? 0))) - SHV_EPOCH_MSEC;
+        if (msecs < 0) {
+            throw new RangeError('DateTime prior to 2018-02-02 are not supported in current ChainPack implementation.');
+        }
+        const ms = msecs % 1000;
+        if (ms === 0) {
+            msecs /= 1000;
+        }
+        let bi = BigInt(msecs);
+        if (dt.utc_offset !== undefined && dt.utc_offset !== 0) {
+            bi <<= 7n;
+            bi |= BigInt((dt.utc_offset / 15) & 0x7F);
+        }
+        bi <<= 2n;
+        if (dt.utc_offset !== undefined && dt.utc_offset !== 0) {
+            bi |= 1n;
+        }
+        if (ms === 0) {
+            bi |= 2n;
+        }
+        // save as signed int
+        this.writeUIntDataHelper(bi, 'UInt');
+    }
+    writeDouble(double) {
+        this.ctx.putByte(PackingSchema.Double);
+        const buffer = new ArrayBuffer(8);
+        const view = new DataView(buffer);
+        view.setFloat64(0, double.value, true);
+        const data = new Uint8Array(buffer);
+        for (let i = 0; i < 8; i++) {
+            this.ctx.putByte(data[i]);
+        }
+    }
+    writeList(lst) {
+        this.ctx.putByte(PackingSchema.List);
+        for (const element of lst) {
+            this.write(element);
+        }
+        this.ctx.putByte(PackingSchema.Term);
+    }
+    writeMeta(map) {
+        this.ctx.putByte(PackingSchema.MetaMap);
+        this.writeMapContent(map);
+    }
+    writeIMap(map) {
+        this.ctx.putByte(PackingSchema.IMap);
+        this.writeMapContent(map);
+    }
+    writeMap(map) {
+        this.ctx.putByte(PackingSchema.Map);
+        this.writeMapContent(map);
+    }
+    writeMapContent(map) {
+        for (const [key, value] of Object.entries(map)) {
+            if (value === undefined) {
+                continue;
+            }
+            if (map[shvMapType] === 'imap') {
+                const intKey = Number(key);
+                if (Number.isNaN(intKey)) {
+                    throw new TypeError('Invalid NaN IMap key');
+                }
+                this.writeInt(intKey);
+            }
+            else if (map[shvMapType] === 'metamap') {
+                const intKey = Number(key);
+                if (Number.isNaN(intKey)) {
+                    this.writeJSString(key.toString());
+                }
+                else {
+                    this.writeInt(intKey);
+                }
+            }
+            else {
+                this.writeJSString(key.toString());
+            }
+            this.write(value);
+        }
+        this.ctx.putByte(PackingSchema.Term);
+    }
+}
+const toChainPack = (value) => {
+    const wr = new ChainPackWriter();
+    wr.write(value);
+    return wr.ctx.buffer();
+};
+const fromChainPack = (buffer) => {
+    const reader = new ChainPackReader(buffer);
+    return reader.read();
+};
+const CHAINPACK_PROTOCOL_TYPE = 1;
+export { toChainPack, fromChainPack, ChainPackReader, ChainPackWriter, CHAINPACK_PROTOCOL_TYPE };

package/dist/cpcontext.d.ts

@@ -0,0 +1,18 @@
+declare class UnpackContext {
+    index: number;
+    private readonly data;
+    constructor(buf: ArrayBufferLike);
+    getByte(): number;
+    peekByte(): number;
+    getBytes(str: string): void;
+}
+declare class PackContext {
+    static CHUNK_LEN: number;
+    data: Uint8Array<ArrayBuffer>;
+    length: number;
+    putByte(b: number): void;
+    writeStringUtf8(str: string): void;
+    writeCharCodeUtf8(charcode: number): void;
+    buffer(): ArrayBuffer;
+}
+export { PackContext, UnpackContext };

package/dist/cpcontext.js

@@ -0,0 +1,74 @@
+class UnpackContext {
+    index;
+    data;
+    constructor(buf) {
+        this.data = new Uint8Array(buf);
+        this.index = 0;
+    }
+    getByte() {
+        if (this.index >= this.data.length) {
+            throw new RangeError('unexpected end of data');
+        }
+        return this.data[this.index++];
+    }
+    peekByte() {
+        if (this.index >= this.data.length) {
+            return -1;
+        }
+        return this.data[this.index];
+    }
+    getBytes(str) {
+        for (let i = 0; i < str.length; i++) {
+            if (str.codePointAt(i) !== this.getByte()) {
+                throw new TypeError(`'${str}' expected`);
+            }
+        }
+    }
+}
+const transfer = (source, length) => {
+    if (length <= source.byteLength) {
+        return source.slice(0, length);
+    }
+    const sourceView = new Uint8Array(source);
+    const destView = new Uint8Array(new ArrayBuffer(length));
+    destView.set(sourceView);
+    return destView.buffer;
+};
+class PackContext {
+    static CHUNK_LEN = 1024;
+    data = new Uint8Array(0);
+    length = 0;
+    putByte(b) {
+        if (this.length >= this.data.length) {
+            const buffer = transfer(this.data.buffer, this.data.length + PackContext.CHUNK_LEN);
+            this.data = new Uint8Array(buffer);
+        }
+        this.data[this.length++] = b;
+    }
+    writeStringUtf8(str) {
+        for (let i = 0; i < str.length; i++) {
+            const charcode = str.codePointAt(i);
+            this.writeCharCodeUtf8(charcode);
+        }
+    }
+    writeCharCodeUtf8(charcode) {
+        /* eslint-disable no-bitwise */
+        if (charcode < 0x80) {
+            this.putByte(charcode);
+        }
+        else if (charcode < 0x8_00) {
+            this.putByte(0xC0 | (charcode >> 6));
+            this.putByte(0x80 | (charcode & 0x3F));
+        }
+        else if (charcode < 0xD8_00 || charcode >= 0xE0_00) {
+            this.putByte(0xE0 | (charcode >> 12));
+            this.putByte(0x80 | ((charcode >> 6) & 0x3F));
+            this.putByte(0x80 | (charcode & 0x3F));
+        }
+        /* eslint-enable no-bitwise */
+    }
+    buffer() {
+        return this.data.buffer.slice(0, this.length);
+    }
+}
+export { PackContext, UnpackContext };

package/dist/cpon.d.ts

@@ -0,0 +1,55 @@
+import { type RpcValue, type RpcValueType, type DateTime, type List, Decimal, Double, type IMap, type Int, type MetaMap, RpcValueWithMetaData, type ShvMap, UInt } from './rpcvalue';
+import { PackContext, UnpackContext } from './cpcontext';
+export declare const stringifyDate: (dt: DateTime) => string;
+declare const utf8ToString: (bytearray: ArrayBuffer) => string;
+declare class CponReader {
+    ctx: UnpackContext;
+    constructor(unpackContext: UnpackContext);
+    read(): RpcValue;
+    skipWhitespace(): void;
+    readDateTime(): DateTime;
+    readDateTimeInner(): DateTime;
+    readCString(): string;
+    readBlobEsc(): ArrayBuffer;
+    readBlobHex(): ArrayBuffer;
+    readList(): (string | number | boolean | Double | Decimal | ArrayBuffer | DateTime | UInt<number> | List | ShvMap<Record<string, any>> | IMap<Record<number, any>> | RpcValueWithMetaData<MetaMap<Record<string | number, RpcValue>>, RpcValueType> | undefined)[];
+    readMetaMap(): MetaMap;
+    readMap(): ShvMap;
+    readIMap(): IMap;
+    readInt(): number;
+    readNumber(): number | Decimal | UInt<number>;
+    private implReadMap;
+}
+declare class CponWriter {
+    private readonly indentString?;
+    private oneLiners;
+    ctx: PackContext;
+    nestLevel: number;
+    constructor(indentString?: string | undefined, oneLiners?: OneLiners);
+    write(rpcVal: RpcValue): void;
+    writeJSString(str: string): void;
+    writeBlob(buffer: ArrayBuffer): void;
+    writeDateTime(dt: DateTime): void;
+    writeBool(b: boolean): void;
+    writeMeta(map: MetaMap): void;
+    writeIMap(map: IMap): void;
+    writeMap(map: ShvMap): void;
+    writeMapContent(map: MetaMap | ShvMap | IMap, delimiterStart: string, delimiterEnd: string): void;
+    writeList(lst: RpcValue[]): void;
+    writeUInt(num: UInt): void;
+    writeInt(num: Int): void;
+    writeDouble(num: Double): void;
+    writeDecimal(val: Decimal): void;
+    private doIndentIfNotOneliner;
+    private isOneLiner;
+    private increaseIndentIfNotOneLiner;
+    private decreaseIndentIfNotOneLiner;
+}
+export declare enum OneLiners {
+    Yes = 0,
+    No = 1
+}
+declare const toCpon: (value: RpcValue, indentString?: string, oneLiners?: OneLiners) => string;
+declare const fromCpon: (str: string | Uint8Array) => RpcValue;
+declare const CPON_PROTOCOL_TYPE = 2;
+export { utf8ToString, CponWriter, CponReader, CPON_PROTOCOL_TYPE, toCpon, fromCpon };