@cloudpss/ubjson 0.3.0-alpha.21

package/dist/index.js

@@ -0,0 +1,3 @@
+export { encode } from './encoder.js';
+export { decode } from './decoder.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC"}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@cloudpss/ubjson",
+  "version": "0.3.0-alpha.21",
+  "author": "CloudPSS",
+  "license": "MIT",
+  "keywords": [
+    "ubjson",
+    "universal binary json",
+    "json",
+    "binary"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "default": "./dist/index.js"
+  },
+  "scripts": {
+    "start": "yarn clean && tsc --watch",
+    "build": "yarn clean && tsc",
+    "prepublishOnly": "yarn build",
+    "clean": "rimraf dist",
+    "benchmark": "node ./benchmark",
+    "test": "c8 tape-es \"./test/*\""
+  },
+  "devDependencies": {
+    "c8": "^7.10.0",
+    "tape": "^5.2.2",
+    "tape-es": "^1.2.15"
+  }
+}

package/src/constants.ts

@@ -0,0 +1,22 @@
+export const NULL = 'Z'.charCodeAt(0);
+export const NO_OP = 'N'.charCodeAt(0);
+export const TRUE = 'T'.charCodeAt(0);
+export const FALSE = 'F'.charCodeAt(0);
+export const INT8 = 'i'.charCodeAt(0);
+export const UINT8 = 'U'.charCodeAt(0);
+export const INT16 = 'I'.charCodeAt(0);
+export const INT32 = 'l'.charCodeAt(0);
+export const INT64 = 'L'.charCodeAt(0);
+export const FLOAT32 = 'd'.charCodeAt(0);
+export const FLOAT64 = 'D'.charCodeAt(0);
+export const HIGH_PRECISION_NUMBER = 'H'.charCodeAt(0);
+export const CHAR = 'C'.charCodeAt(0);
+export const STRING = 'S'.charCodeAt(0);
+
+export const ARRAY = '['.charCodeAt(0);
+export const ARRAY_END = ']'.charCodeAt(0);
+export const OBJECT = '{'.charCodeAt(0);
+export const OBJECT_END = '}'.charCodeAt(0);
+
+export const TYPE_MARKER = '$'.charCodeAt(0);
+export const COUNT_MARKER = '#'.charCodeAt(0);

package/src/decoder.ts

@@ -0,0 +1,278 @@
+import * as constants from './constants.js';
+
+const textDecoder = new TextDecoder();
+
+/** decoder */
+class Decoder {
+    private readonly view: DataView;
+    private offset = 0;
+    constructor(readonly data: Uint8Array) {
+        this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    }
+    /** 解码 */
+    decode(): unknown {
+        this.offset = 0;
+        return this.read();
+    }
+
+    /** 检查是否有给定字节数的未读数据 */
+    private ensureData(byteLength: number): void {
+        if (this.offset + byteLength > this.data.byteLength) {
+            throw new Error('Unexpected EOF');
+        }
+    }
+
+    /** 读取 marker，跳过 noop */
+    private readMarker(): number {
+        let marker = constants.NO_OP;
+        do {
+            if (this.offset >= this.data.byteLength) break;
+            marker = this.view.getUint8(this.offset++);
+        } while (marker === constants.NO_OP);
+        return marker;
+    }
+    /** 读取数据 */
+    private read(marker = this.readMarker()): unknown {
+        switch (marker) {
+            case constants.NO_OP:
+                return undefined;
+            case constants.NULL:
+                return null;
+            case constants.TRUE:
+                return true;
+            case constants.FALSE:
+                return false;
+            case constants.UINT8:
+                return this.readUint8Data();
+            case constants.INT8:
+                return this.readInt8Data();
+            case constants.INT16:
+                return this.readInt16Data();
+            case constants.INT32:
+                return this.readInt32Data();
+            case constants.INT64:
+                return this.readInt64Data();
+            case constants.FLOAT32:
+                return this.readFloat32Data();
+            case constants.FLOAT64:
+                return this.readFloat64Data();
+            case constants.HIGH_PRECISION_NUMBER:
+                return this.readHighPrecisionNumberData();
+            case constants.CHAR:
+                return this.readCharData();
+            case constants.STRING:
+                return this.readStringData();
+            case constants.ARRAY:
+                return this.readArray();
+            case constants.OBJECT:
+                return this.readObject();
+        }
+        throw new Error(`Unexpected marker '${String.fromCharCode(marker)}'(${marker})`);
+    }
+
+    /** 读取一个大于 0 的整数 */
+    private readIntLength(): number {
+        const marker = this.readMarker();
+        let length;
+        switch (marker) {
+            case constants.INT8:
+                length = this.readInt8Data();
+                break;
+            case constants.INT16:
+                length = this.readInt16Data();
+                break;
+            case constants.INT32:
+                length = this.readInt32Data();
+                break;
+            /* c8 ignore next 3 */
+            case constants.INT64:
+                length = this.readInt64Data();
+                break;
+        }
+        if (length === undefined) {
+            throw new Error(`Unexpected marker '${String.fromCharCode(marker)}'(${marker}) for int length`);
+        }
+        if (length < 0) throw new Error('Invalid length');
+        return length;
+    }
+    /** readStringData */
+    private readStringData(): string {
+        const length = this.readIntLength();
+        this.ensureData(length);
+        const buffer = this.data.subarray(this.offset, this.offset + length);
+        this.offset += length;
+        return textDecoder.decode(buffer);
+    }
+    /** readHighPrecisionNumberData */
+    private readHighPrecisionNumberData(): never {
+        const length = this.readIntLength();
+        this.ensureData(length);
+        throw new Error('Unsupported type high precision number');
+        // const buffer = this.data.subarray(this.offset, this.offset + length);
+        // this.offset += length;
+        // return buffer.slice();
+    }
+    /** readStringData */
+    private readCharData(): string {
+        return String.fromCharCode(this.readUint8Data());
+    }
+    /** readInt8Data */
+    private readInt8Data(): number {
+        this.ensureData(1);
+        const result = this.view.getInt8(this.offset);
+        this.offset += 1;
+        return result;
+    }
+    /** readUint8Data */
+    private readUint8Data(): number {
+        this.ensureData(1);
+        const result = this.view.getUint8(this.offset);
+        this.offset += 1;
+        return result;
+    }
+    /** readInt16Data */
+    private readInt16Data(): number {
+        this.ensureData(2);
+        const result = this.view.getInt16(this.offset);
+        this.offset += 2;
+        return result;
+    }
+    /** readInt32Data */
+    private readInt32Data(): number {
+        this.ensureData(4);
+        const result = this.view.getInt32(this.offset);
+        this.offset += 4;
+        return result;
+    }
+    /** readInt64Data */
+    private readInt64Data(): never {
+        this.ensureData(8);
+        throw new Error('Unsupported type int64');
+        // const result = this.view.getBigInt64(this.offset);
+        // this.offset += 8;
+        // return result;
+    }
+    /** readFloat32Data */
+    private readFloat32Data(): number {
+        this.ensureData(4);
+        const result = this.view.getFloat32(this.offset);
+        this.offset += 4;
+        return result;
+    }
+    /** readFloat64Data */
+    private readFloat64Data(): number {
+        this.ensureData(8);
+        const result = this.view.getFloat64(this.offset);
+        this.offset += 8;
+        return result;
+    }
+
+    /** 读取 Optimized Format 数据 */
+    private readOptimizedFormatMarkers(): { type?: number; count: number } | undefined {
+        let type;
+        let count;
+        switch (this.readMarker()) {
+            case constants.TYPE_MARKER:
+                type = this.readMarker();
+                if (this.readMarker() !== constants.COUNT_MARKER) {
+                    throw new Error('Expected count marker');
+                }
+            /* fall through */
+            case constants.COUNT_MARKER:
+                count = this.readIntLength();
+                break;
+            default:
+                // 不是 '$' 或 '#'，回溯
+                this.offset--;
+                return undefined;
+        }
+        return { type, count };
+    }
+
+    /** 读取数组 */
+    private readArray(): unknown[] | ArrayBufferView {
+        const markers = this.readOptimizedFormatMarkers();
+        if (markers == null) {
+            const array = [];
+            // 直到 ']'
+            while (this.readMarker() !== constants.ARRAY_END) {
+                this.offset--;
+                array.push(this.read());
+            }
+            return array;
+        }
+
+        const { count, type } = markers;
+        switch (type) {
+            case constants.NULL:
+                return new Array<null>(count).fill(null);
+            case constants.TRUE:
+                return new Array<true>(count).fill(true);
+            case constants.FALSE:
+                return new Array<false>(count).fill(false);
+            case constants.UINT8:
+                this.ensureData(count);
+                this.offset += count;
+                return new Uint8Array(this.data.buffer, this.data.byteOffset + this.offset - count, count).slice();
+            case constants.INT8:
+                this.ensureData(count);
+                this.offset += count;
+                return new Int8Array(this.data.buffer, this.data.byteOffset + this.offset - count, count).slice();
+            case constants.INT16:
+                this.ensureData(count * 2);
+                return Int16Array.from({ length: count }, () => this.readInt16Data());
+            case constants.INT32:
+                this.ensureData(count * 4);
+                return Int32Array.from({ length: count }, () => this.readInt32Data());
+            /* c8 ignore next 3 */
+            case constants.INT64:
+                this.ensureData(count * 8);
+                return BigInt64Array.from({ length: count }, () => this.readInt64Data());
+            case constants.FLOAT32:
+                this.ensureData(count * 4);
+                return Float32Array.from({ length: count }, () => this.readFloat32Data());
+            case constants.FLOAT64: {
+                this.ensureData(count * 8);
+                const result = new Float64Array(count);
+                for (let i = 0; i < count; i++) {
+                    result[i] = this.readFloat64Data();
+                }
+                return result;
+            }
+        }
+        const array = new Array<unknown>(count);
+        for (let i = 0; i < count; i++) {
+            array[i] = this.read(type);
+        }
+        return array;
+    }
+
+    /** 读对象 */
+    private readObject(): Record<string, unknown> {
+        const markers = this.readOptimizedFormatMarkers();
+        if (markers == null) {
+            // 直到 '}'
+            const object: Array<[string, unknown]> = [];
+            while (this.readMarker() !== constants.OBJECT_END) {
+                this.offset--;
+                const key = this.readStringData();
+                object.push([key, this.read()]);
+            }
+            return Object.fromEntries(object);
+        }
+
+        const { count, type } = markers;
+        const object = new Array<[string, unknown]>(count);
+        for (let i = 0; i < count; i++) {
+            const key = this.readStringData();
+            object[i] = [key, this.read(type)];
+        }
+        return Object.fromEntries(object);
+    }
+}
+
+/** 解码 */
+export function decode(value: Uint8Array): unknown {
+    const decoder = new Decoder(value);
+    return decoder.decode();
+}

package/src/encoder.ts

@@ -0,0 +1,340 @@
+/* eslint-disable @typescript-eslint/unbound-method */
+import * as constants from './constants.js';
+
+const INITIAL_SIZE = 1024 * 8;
+const MAX_SIZE = 1024 * 1024 * 128;
+const RESIZE_FACTOR = 4;
+const RESIZE_FACTOR_2 = 2;
+
+const textEncoder = new TextEncoder();
+
+/* c8 ignore next 3 */
+const hasOwn =
+    (Object as unknown as { /** hasOwn */ hasOwn(obj: object, property: string): boolean }).hasOwn ??
+    Object.prototype.hasOwnProperty.call.bind(Object.prototype.hasOwnProperty);
+
+/** 编码至 ubjson */
+class Encoder {
+    /** 当前写指针位置 */
+    private length = 0;
+    /** 数据 */
+    private buffer: Uint8Array;
+    /** buffer 的 DataView */
+    private view: DataView;
+
+    constructor() {
+        const buffer = new Uint8Array(INITIAL_SIZE);
+        this.buffer = buffer;
+        this.view = new DataView(buffer.buffer);
+    }
+
+    /**
+     * 确保 buffer 还有 capacity 的空闲空间
+     */
+    private ensureCapacity(capacity: number): void {
+        let nextCapacity = this.length + capacity;
+        // 无需扩容
+        if (this.buffer.byteLength >= nextCapacity) return;
+        /* c8 ignore next 3 */
+        if (nextCapacity > MAX_SIZE) {
+            throw new Error('Buffer has exceed max size');
+        }
+
+        if (nextCapacity < this.buffer.byteLength * RESIZE_FACTOR) {
+            nextCapacity = (this.buffer.byteLength * RESIZE_FACTOR) | 0;
+        } else {
+            nextCapacity = (this.buffer.byteLength / RESIZE_FACTOR_2 + nextCapacity) | 0;
+        }
+        /* c8 ignore next 3 */
+        if (nextCapacity > MAX_SIZE) {
+            nextCapacity = MAX_SIZE;
+        }
+
+        const newBuffer = new Uint8Array(nextCapacity);
+        newBuffer.set(this.buffer, 0);
+        this.buffer = newBuffer;
+        this.view = new DataView(newBuffer.buffer);
+    }
+    /** 获取写入结果 */
+    finish(): Uint8Array {
+        return this.buffer.slice(0, this.length);
+    }
+    /** 写入一个对象 */
+    write(value: unknown): void {
+        switch (typeof value) {
+            case 'undefined':
+                return this.writeNoOp();
+            case 'boolean':
+                return this.writeBoolean(value);
+            case 'number':
+                return this.writeNumber(value);
+            case 'string':
+                if (value.length === 1 && value.charCodeAt(0) < 255) {
+                    // 1 byte string
+                    return this.writeChar(value);
+                }
+                return this.writeString(value);
+            case 'object': {
+                if (value === null) {
+                    return this.writeNull();
+                }
+                if (Array.isArray(value)) {
+                    return this.writeArray(value);
+                }
+                if (ArrayBuffer.isView(value)) {
+                    return this.writeTypedArray(value);
+                }
+                return this.writeObject(value as Record<string, unknown>);
+            }
+        }
+        throw new Error(`Unsupported type ${Object.prototype.toString.call(value)}`);
+    }
+    /** 写入 marker */
+    private writeMarker(marker: number): void {
+        this.ensureCapacity(1);
+        this.view.setUint8(this.length, marker);
+        this.length += 1;
+    }
+
+    /** 写入 marker */
+    private writeNull(): void {
+        this.writeMarker(constants.NULL);
+    }
+
+    /** writeNoOp */
+    private writeNoOp(): void {
+        this.writeMarker(constants.NO_OP);
+    }
+
+    /** writeBoolean */
+    private writeBoolean(value: boolean): void {
+        this.writeMarker(value ? constants.TRUE : constants.FALSE);
+    }
+
+    /** writeInt8 */
+    private writeInt8(value: number): void {
+        this.writeMarker(constants.INT8);
+        this.writeInt8Data(value);
+    }
+
+    /** writeInt8Data */
+    private writeInt8Data(value: number): void {
+        this.ensureCapacity(1);
+        this.view.setInt8(this.length, value);
+        this.length += 1;
+    }
+
+    /** writeUint8 */
+    private writeUint8(value: number): void {
+        this.writeMarker(constants.UINT8);
+        this.writeUint8Data(value);
+    }
+
+    /** writeUint8Data */
+    private writeUint8Data(value: number): void {
+        this.ensureCapacity(1);
+        this.view.setUint8(this.length, value);
+        this.length += 1;
+    }
+
+    /** writeInt16 */
+    private writeInt16(value: number): void {
+        this.writeMarker(constants.INT16);
+        this.writeInt16Data(value);
+    }
+
+    /** writeInt16Data */
+    private writeInt16Data(value: number): void {
+        this.ensureCapacity(2);
+        this.view.setInt16(this.length, value);
+        this.length += 2;
+    }
+
+    /** writeInt32 */
+    private writeInt32(value: number): void {
+        this.writeMarker(constants.INT32);
+        this.writeInt32Data(value);
+    }
+
+    /** writeInt32Data */
+    private writeInt32Data(value: number): void {
+        this.ensureCapacity(4);
+        this.view.setInt32(this.length, value);
+        this.length += 4;
+    }
+
+    /** writeFloat32 */
+    private writeFloat32(value: number): void {
+        this.writeMarker(constants.FLOAT32);
+        this.writeFloat32Data(value);
+    }
+
+    /** writeFloat32Data */
+    private writeFloat32Data(value: number): void {
+        this.ensureCapacity(4);
+        this.view.setFloat32(this.length, value);
+        this.length += 4;
+    }
+
+    /** writeFloat64 */
+    private writeFloat64(value: number): void {
+        this.writeMarker(constants.FLOAT64);
+        this.writeFloat64Data(value);
+    }
+
+    /** writeFloat64Data */
+    private writeFloat64Data(value: number): void {
+        this.ensureCapacity(8);
+        this.view.setFloat64(this.length, value);
+        this.length += 8;
+    }
+
+    /** writeChar */
+    private writeChar(value: string): void {
+        this.writeMarker(constants.CHAR);
+        this.writeCharData(value);
+    }
+
+    /** writeCharData */
+    private writeCharData(value: string): void {
+        this.ensureCapacity(1);
+        this.view.setUint8(this.length, value.charCodeAt(0));
+        this.length += 1;
+    }
+
+    /** writeString */
+    private writeString(value: string): void {
+        this.writeMarker(constants.STRING);
+        this.writeStringData(value);
+    }
+
+    /** writeStringData */
+    private writeStringData(value: string): void {
+        if (textEncoder.encodeInto != null) {
+            const maxUsage = value.length * 3;
+            const currentPos = this.length;
+            // 先写入最大大小
+            const lengthWriter = this.writeInt(maxUsage);
+            this.ensureCapacity(maxUsage);
+            // 写入文本数据
+            const { written } = textEncoder.encodeInto(value, this.buffer.subarray(this.length));
+            // 回溯，写入实际大小
+            this.length = currentPos;
+            lengthWriter.call(this, written as number);
+            // 移动指针到写入末尾
+            this.length += written as number;
+            return;
+        }
+        const data = textEncoder.encode(value);
+        this.writeInt(data.length);
+        this.ensureCapacity(data.length);
+        this.buffer.set(data, this.length);
+        this.length += data.length;
+    }
+
+    /**
+     * 写入整形数字，选取合适的大小
+     *
+     * @throws 无法在 int32 范围内表示
+     */
+    private writeInt(value: number): (this: this, value: number) => void {
+        value = value | 0;
+        if (value >= -128 && value <= 127) {
+            this.writeInt8(value);
+            return this.writeInt8;
+        }
+        if (value >= -32768 && value <= 32767) {
+            this.writeInt16(value);
+            return this.writeInt16;
+        }
+        if (value >= -2147483648 && value <= 2147483647) {
+            this.writeInt32(value);
+            return this.writeInt32;
+        }
+        /* c8 ignore next 2 */
+        throw new Error(`Unsupported int value ${value}: out of range`);
+    }
+
+    /** 写入数字，选取合适的大小 */
+    private writeNumber(value: number): void {
+        if (Number.isInteger(value) && value >= -2147483648 && value <= 2147483647) {
+            if (value >= 0 && value <= 255) return this.writeUint8(value);
+            this.writeInt(value);
+            return;
+        }
+        if (!Number.isFinite(value) || Math.fround(value) === value) {
+            return this.writeFloat32(value);
+        }
+        return this.writeFloat64(value);
+    }
+
+    /** writeObject */
+    private writeObject(value: Record<string, unknown>): void {
+        this.writeMarker(constants.OBJECT);
+        for (const key in value) {
+            if (!hasOwn(value, key)) continue;
+            const element = value[key];
+            if (element === undefined) continue;
+            this.writeStringData(key);
+            this.write(element);
+        }
+        this.writeMarker(constants.OBJECT_END);
+    }
+
+    /** writeArray */
+    private writeArray(value: unknown[]): void {
+        this.writeMarker(constants.ARRAY);
+        for (const v of value) {
+            if (v == null) this.writeNull();
+            else this.write(v);
+        }
+        this.writeMarker(constants.ARRAY_END);
+    }
+
+    /** writeArray */
+    private writeTypedArray(value: ArrayBufferView): void {
+        this.writeMarker(constants.ARRAY);
+        this.writeMarker(constants.TYPE_MARKER);
+        if (value instanceof Uint8Array || value instanceof Int8Array) {
+            // fast path for typed arrays with `BYTES_PER_ELEMENT` of 1
+            this.writeMarker(value instanceof Uint8Array ? constants.UINT8 : constants.INT8);
+            this.writeMarker(constants.COUNT_MARKER);
+            this.writeInt(value.length);
+            this.ensureCapacity(value.byteLength);
+            this.buffer.set(value, this.length);
+            this.length += value.byteLength;
+            return;
+        }
+        let setValue;
+        if (value instanceof Int16Array) {
+            this.writeMarker(constants.INT16);
+            setValue = this.view.setInt16;
+        } else if (value instanceof Int32Array) {
+            this.writeMarker(constants.INT32);
+            setValue = this.view.setInt32;
+        } else if (value instanceof Float32Array) {
+            this.writeMarker(constants.FLOAT32);
+            setValue = this.view.setFloat32;
+        } else if (value instanceof Float64Array) {
+            this.writeMarker(constants.FLOAT64);
+            setValue = this.view.setFloat64;
+        } else {
+            throw new Error(`Unsupported typed array type ${Object.prototype.toString.call(value)}`);
+        }
+        this.writeMarker(constants.COUNT_MARKER);
+        this.writeInt(value.length);
+        this.ensureCapacity(value.byteLength);
+        // 不要在前面 bind，this.ensureCapacity 有可能导致 this.view 指向新的对象
+        for (const v of value) {
+            setValue.call(this.view, this.length, v);
+            this.length += value.BYTES_PER_ELEMENT;
+        }
+    }
+}
+
+/** 编码 */
+export function encode(value: unknown): Uint8Array {
+    const encoder = new Encoder();
+    encoder.write(value);
+    return encoder.finish();
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { encode } from './encoder.js';
+export { decode } from './decoder.js';