libshv-js 3.16.1 → 3.20.0

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/{src/cpcontext.ts → dist/cpcontext.js}

@@ -1,29 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnpackContext = exports.PackContext = void 0;
 class UnpackContext {
-    index: number;
-    private readonly data: Uint8Array;
-
-    constructor(buf: ArrayBufferLike) {
+    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: string) {
+    getBytes(str) {
         for (let i = 0; i < str.length; i++) {
             if (str.codePointAt(i) !== this.getByte()) {
                 throw new TypeError(`'${str}' expected`);
@@ -31,57 +28,51 @@ class UnpackContext {
         }
     }
 }
-
-const transfer = (source: ArrayBuffer, length: number) => {
+exports.UnpackContext = UnpackContext;
+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: number) {
+    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: string) {
+    writeStringUtf8(str) {
         for (let i = 0; i < str.length; i++) {
-            const charcode = str.codePointAt(i)!;
+            const charcode = str.codePointAt(i);
             this.writeCharCodeUtf8(charcode);
         }
     }
-
-    writeCharCodeUtf8(charcode: number) {
+    writeCharCodeUtf8(charcode) {
         /* eslint-disable no-bitwise */
         if (charcode < 0x80) {
             this.putByte(charcode);
-        } else if (charcode < 0x8_00) {
+        }
+        else if (charcode < 0x8_00) {
             this.putByte(0xC0 | (charcode >> 6));
             this.putByte(0x80 | (charcode & 0x3F));
-        } else if (charcode < 0xD8_00 || charcode >= 0xE0_00) {
+        }
+        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};
+exports.PackContext = PackContext;

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 };