@cloudpss/ubjson 0.4.32 → 0.4.34

package/src/common/encoder.ts

@@ -1,10 +1,10 @@
-import * as constants from './constants.js';
-import { StringEncoder } from './string-encoder.js';
+import { constants } from './constants.js';
+import { getStringByteLength, getEncodeInto } from './string-encoder.js';
 
 /** 编码至 ubjson */
 export abstract class EncoderBase {
-    /** 字符串编码 */
-    protected stringEncoder = new StringEncoder();
+    protected readonly stringByteLength = getStringByteLength();
+    protected readonly encodeInto = getEncodeInto();
     /** 当前写指针位置 */
     protected length = 0;
     /** 数据 */
@@ -17,305 +17,258 @@ export abstract class EncoderBase {
      * 确保 buffer 还有 capacity 的空闲空间
      */
     protected abstract ensureCapacity(capacity: number): void;
+
+    /** 编码至 ubjson */
+    protected writeValue(): void {
+        if (this.value === undefined) {
+            this.ensureCapacity(1);
+            this.buffer[this.length++] = constants.NO_OP;
+            return;
+        }
+        this.write(this.value);
+    }
     /** 写入一个对象 */
-    protected write(value: unknown): void {
+    private 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);
+                if (value.length === 1 && value.charCodeAt(0) < 128) {
+                    // 1 byte ascii char
+                    this.ensureCapacity(2);
+                    this.buffer[this.length++] = constants.CHAR;
+                    this.buffer[this.length++] = value.charCodeAt(0);
+                } else {
+                    this.ensureCapacity(2);
+                    this.buffer[this.length++] = constants.STRING;
+                    this.writeStringData(value);
                 }
-                return this.writeString(value);
+                return;
+            case 'number':
+                // eslint-disable-next-line unicorn/prefer-math-trunc
+                if ((value | 0) === value) {
+                    if (value >= 0 && value <= 255) {
+                        this.ensureCapacity(2);
+                        this.buffer[this.length++] = constants.UINT8;
+                        this.buffer[this.length++] = value;
+                    } else if (value >= -128 && value <= 127) {
+                        this.ensureCapacity(2);
+                        this.buffer[this.length++] = constants.INT8;
+                        this.buffer[this.length++] = value;
+                    } else if (value >= -32768 && value <= 32767) {
+                        this.ensureCapacity(3);
+                        this.buffer[this.length++] = constants.INT16;
+                        this.buffer[this.length++] = value >> 8;
+                        this.buffer[this.length++] = value & 0xff;
+                    } else {
+                        this.ensureCapacity(5);
+                        this.buffer[this.length++] = constants.INT32;
+                        this.view.setInt32(this.length, value);
+                        this.length += 4;
+                    }
+                } else if (Number.isNaN(value) || Math.fround(value) === value) {
+                    // 如果不会损失精度，使用 32 位浮点
+                    this.ensureCapacity(5);
+                    this.buffer[this.length++] = constants.FLOAT32;
+                    this.view.setFloat32(this.length, value);
+                    this.length += 4;
+                } else {
+                    this.ensureCapacity(9);
+                    this.buffer[this.length++] = constants.FLOAT64;
+                    this.view.setFloat64(this.length, value);
+                    this.length += 8;
+                }
+                return;
             case 'object': {
                 if (value === null) {
-                    return this.writeNull();
-                }
-                if (Array.isArray(value)) {
-                    return this.writeArray(value);
-                }
-                if (ArrayBuffer.isView(value)) {
-                    return this.writeTypedArray(value);
+                    this.ensureCapacity(1);
+                    this.buffer[this.length++] = constants.NULL;
+                } else if (Array.isArray(value)) {
+                    this.ensureCapacity(1);
+                    this.buffer[this.length++] = constants.ARRAY;
+                    const size = value.length;
+                    for (let index = 0; index < size; index++) {
+                        const element = value[index] as unknown;
+                        // 在数组中 undefined 和 function 也被视作 null 进行序列化
+                        if (element == null || typeof element == 'function') {
+                            this.ensureCapacity(1);
+                            this.buffer[this.length++] = constants.NULL;
+                        } else {
+                            this.write(element);
+                        }
+                    }
+                    this.ensureCapacity(1);
+                    this.buffer[this.length++] = constants.ARRAY_END;
+                } else if (!ArrayBuffer.isView(value)) {
+                    const toJSON = typeof (value as Record<string, unknown>)['toJSON'] == 'function';
+                    if (toJSON) {
+                        this.write((value as { toJSON: () => unknown }).toJSON());
+                        return;
+                    }
+                    this.ensureCapacity(1);
+                    this.buffer[this.length++] = constants.OBJECT;
+                    // 生成稳定的结果以便 hash 计算
+                    const keys = Object.keys(value).sort();
+                    const size = keys.length;
+                    for (let index = 0; index < size; index++) {
+                        const key = keys[index];
+                        const element = (value as Record<string, unknown>)[key];
+                        if (element === undefined || typeof element == 'function') continue;
+                        this.writeStringData(key);
+                        this.write(element);
+                    }
+                    this.ensureCapacity(1);
+                    this.buffer[this.length++] = constants.OBJECT_END;
+                } else {
+                    // ARRAY(1) + TYPE_MARKER(1) + TYPE(1) + COUNT_MARKER(1) + COUNT(MAX5) + DATA
+                    this.ensureCapacity(9 + value.byteLength);
+                    this.buffer[this.length++] = constants.ARRAY;
+                    this.buffer[this.length++] = constants.TYPE_MARKER;
+                    if (value instanceof Uint8Array || value instanceof Int8Array) {
+                        // fast path for typed arrays with `BYTES_PER_ELEMENT` of 1
+                        this.buffer[this.length++] = value instanceof Uint8Array ? constants.UINT8 : constants.INT8;
+                        this.buffer[this.length++] = constants.COUNT_MARKER;
+                        this.setLength(value.length);
+                        this.buffer.set(value, this.length);
+                        this.length += value.byteLength;
+                        return;
+                    }
+
+                    const arrayLength = (value as Int16Array | Int32Array | Float32Array | Float64Array).length;
+                    const elementSize = (value as Int16Array | Int32Array | Float32Array | Float64Array)
+                        .BYTES_PER_ELEMENT;
+                    if (value instanceof Int16Array) {
+                        this.buffer[this.length++] = constants.INT16;
+                        this.buffer[this.length++] = constants.COUNT_MARKER;
+                        this.setLength(arrayLength);
+                        for (let i = 0; i < arrayLength; i++) {
+                            this.view.setInt16(this.length, value[i]);
+                            this.length += elementSize;
+                        }
+                    } else if (value instanceof Int32Array) {
+                        this.buffer[this.length++] = constants.INT32;
+                        this.buffer[this.length++] = constants.COUNT_MARKER;
+                        this.setLength(arrayLength);
+                        for (let i = 0; i < arrayLength; i++) {
+                            this.view.setInt32(this.length, value[i]);
+                            this.length += elementSize;
+                        }
+                    } else if (value instanceof Float32Array) {
+                        this.buffer[this.length++] = constants.FLOAT32;
+                        this.buffer[this.length++] = constants.COUNT_MARKER;
+                        this.setLength(arrayLength);
+                        for (let i = 0; i < arrayLength; i++) {
+                            this.view.setFloat32(this.length, value[i]);
+                            this.length += elementSize;
+                        }
+                    } else if (value instanceof Float64Array) {
+                        this.buffer[this.length++] = constants.FLOAT64;
+                        this.buffer[this.length++] = constants.COUNT_MARKER;
+                        this.setLength(arrayLength);
+                        for (let i = 0; i < arrayLength; i++) {
+                            this.view.setFloat64(this.length, value[i]);
+                            this.length += elementSize;
+                        }
+                    } else {
+                        throw new TypeError(`Unsupported typed array type ${Object.prototype.toString.call(value)}`);
+                    }
                 }
-                return this.writeObject(value as Record<string, unknown>);
+                return;
             }
+            case 'boolean':
+                this.ensureCapacity(1);
+                this.buffer[this.length++] = value ? constants.TRUE : constants.FALSE;
+                return;
             default:
                 throw new Error(`Unsupported type ${Object.prototype.toString.call(value)}`);
         }
     }
-    /** 写入 marker */
-    protected writeMarker(marker: number): void {
-        this.ensureCapacity(1);
-        this.view.setUint8(this.length, marker);
-        this.length += 1;
-    }
-
-    /** 写入 marker */
-    protected writeNull(): void {
-        this.writeMarker(constants.NULL);
-    }
-
-    /** writeNoOp */
-    protected writeNoOp(): void {
-        this.writeMarker(constants.NO_OP);
-    }
-
-    /** writeBoolean */
-    protected writeBoolean(value: boolean): void {
-        this.writeMarker(value ? constants.TRUE : constants.FALSE);
-    }
-
-    /** writeInt8 */
-    protected writeInt8(value: number): void {
-        this.writeMarker(constants.INT8);
-        this.writeInt8Data(value);
-    }
-
-    /** writeInt8Data */
-    protected writeInt8Data(value: number): void {
-        this.ensureCapacity(1);
-        this.view.setInt8(this.length, value);
-        this.length += 1;
-    }
-
-    /** writeUint8 */
-    protected writeUint8(value: number): void {
-        this.writeMarker(constants.UINT8);
-        this.writeUint8Data(value);
-    }
-
-    /** writeUint8Data */
-    protected writeUint8Data(value: number): void {
-        this.ensureCapacity(1);
-        this.view.setUint8(this.length, value);
-        this.length += 1;
-    }
-
-    /** writeInt16 */
-    protected writeInt16(value: number): void {
-        this.writeMarker(constants.INT16);
-        this.writeInt16Data(value);
-    }
-
-    /** writeInt16Data */
-    protected writeInt16Data(value: number): void {
-        this.ensureCapacity(2);
-        this.view.setInt16(this.length, value);
-        this.length += 2;
-    }
-
-    /** writeInt32 */
-    protected writeInt32(value: number): void {
-        this.writeMarker(constants.INT32);
-        this.writeInt32Data(value);
-    }
-
-    /** writeInt32Data */
-    protected writeInt32Data(value: number): void {
-        this.ensureCapacity(4);
-        this.view.setInt32(this.length, value);
-        this.length += 4;
-    }
-
-    /** writeFloat32 */
-    protected writeFloat32(value: number): void {
-        this.writeMarker(constants.FLOAT32);
-        this.writeFloat32Data(value);
-    }
-
-    /** writeFloat32Data */
-    protected writeFloat32Data(value: number): void {
-        this.ensureCapacity(4);
-        this.view.setFloat32(this.length, value);
-        this.length += 4;
-    }
-
-    /** writeFloat64 */
-    protected writeFloat64(value: number): void {
-        this.writeMarker(constants.FLOAT64);
-        this.writeFloat64Data(value);
-    }
-
-    /** writeFloat64Data */
-    protected writeFloat64Data(value: number): void {
-        this.ensureCapacity(8);
-        this.view.setFloat64(this.length, value);
-        this.length += 8;
-    }
-
-    /** writeChar */
-    protected writeChar(value: string): void {
-        this.writeMarker(constants.CHAR);
-        this.writeCharData(value);
-    }
-
-    /** writeCharData */
-    protected writeCharData(value: string): void {
-        this.ensureCapacity(1);
-        this.view.setUint8(this.length, value.charCodeAt(0));
-        this.length += 1;
-    }
-
-    /** writeString */
-    protected writeString(value: string): void {
-        this.writeMarker(constants.STRING);
-        this.writeStringData(value);
-    }
 
     /** writeStringData */
-    protected writeStringData(value: string): void {
+    private writeStringData(value: string): void {
+        const strLength = value.length;
+        const maxUsage =
+            strLength < 65536
+                ? // 对于短字符串，直接计算最大使用空间
+                  strLength * 3
+                : this.stringByteLength(value);
+        // 一次性分配 setLength 和 encodeInto 的空间，避免无法回溯
+        // 额外分配 3 字节，避免 encodeInto 无法写入最后一个字符
+        this.ensureCapacity(maxUsage + 5 + 3);
+
+        // 预估头部大小
+        const headerSize = strLength < 128 ? 2 : strLength < 32768 ? 3 : 5;
+        const headerPos = this.length;
+        let bufLength;
         // 优化小字符串
-        if (value.length < 32 || this.stringEncoder.encodeInto == null) {
-            const buf = this.stringEncoder.encode(value);
-            this.writeInt(buf.length);
-            this.ensureCapacity(buf.length);
-            this.buffer.set(buf, this.length);
-            this.length += buf.length;
-            return;
-        }
-        let maxUsage = value.length;
-        if (value.length < 65536) {
-            // 对于短字符串，直接计算最大使用空间
-            maxUsage = value.length * 3;
+        if (strLength < 0x40 || !this.encodeInto) {
+            let c1, c2;
+            let strPosition = headerPos + headerSize;
+            const target = this.buffer;
+            for (let i = 0; i < strLength; i++) {
+                c1 = value.charCodeAt(i);
+                if (c1 < 0x80) {
+                    target[strPosition++] = c1;
+                } else if (c1 < 0x800) {
+                    target[strPosition++] = (c1 >> 6) | 0xc0;
+                    target[strPosition++] = (c1 & 0x3f) | 0x80;
+                } else if ((c1 & 0xfc00) === 0xd800 && ((c2 = value.charCodeAt(i + 1)) & 0xfc00) === 0xdc00) {
+                    c1 = 0x1_0000 + ((c1 & 0x03ff) << 10) + (c2 & 0x03ff);
+                    i++;
+                    target[strPosition++] = (c1 >> 18) | 0xf0;
+                    target[strPosition++] = ((c1 >> 12) & 0x3f) | 0x80;
+                    target[strPosition++] = ((c1 >> 6) & 0x3f) | 0x80;
+                    target[strPosition++] = (c1 & 0x3f) | 0x80;
+                } else {
+                    target[strPosition++] = (c1 >> 12) | 0xe0;
+                    target[strPosition++] = ((c1 >> 6) & 0x3f) | 0x80;
+                    target[strPosition++] = (c1 & 0x3f) | 0x80;
+                }
+            }
+            bufLength = strPosition - headerPos - headerSize;
         } else {
-            maxUsage = this.stringEncoder.byteLength(value);
+            bufLength = this.encodeInto(value, this.buffer, headerPos + headerSize);
         }
-        // 一次性分配 writeInt 和 encodeInto 的空间，避免无法回溯
-        // 额外分配 3 字节，避免 encodeInto 无法写入最后一个字符
-        this.ensureCapacity(maxUsage + 4 + 3);
-        const currentPos = this.length;
-        // 先写入最大大小
-        const lengthWriter = this.writeInt(maxUsage);
-        // 写入文本数据
-        const { written, read } = this.stringEncoder.encodeInto(value, this.buffer.subarray(this.length));
-        /* c8 ignore next 3 */
-        if (read !== value.length) {
-            throw new Error(`Failed to encode string with TextEncoder.encodeInto`);
+        if (bufLength < 128) {
+            this.buffer[this.length++] = constants.INT8;
+            this.buffer[this.length++] = bufLength;
+        } else if (bufLength < 32768) {
+            if (headerSize < 3) {
+                this.buffer.copyWithin(headerPos + 3, headerPos + headerSize, headerPos + headerSize + bufLength);
+            }
+            this.buffer[this.length++] = constants.INT16;
+            this.buffer[this.length++] = bufLength >> 8;
+            this.buffer[this.length++] = bufLength & 0xff;
+        } else {
+            if (headerSize < 5) {
+                this.buffer.copyWithin(headerPos + 5, headerPos + headerSize, headerPos + headerSize + bufLength);
+            }
+            this.buffer[this.length++] = constants.INT32;
+            this.view.setInt32(this.length, bufLength);
+            this.length += 4;
         }
-        // 回溯，写入实际大小
-        this.length = currentPos;
-        lengthWriter.call(this, written!);
-        // 移动指针到写入末尾
-        this.length += written!;
+        this.length += bufLength;
     }
 
     /**
-     * 写入整形数字，选取合适的大小
-     * @throws 无法在 int32 范围内表示
+     * 写入整形数字，选取合适的大小，需提前分配空间
      */
-    protected writeInt(value: number): (this: this, value: number) => void {
+    private setLength(value: number): number {
         // eslint-disable-next-line unicorn/prefer-math-trunc
         value = value | 0;
-        if (value >= -128 && value <= 127) {
-            this.writeInt8(value);
-            /* eslint-disable-next-line @typescript-eslint/unbound-method */
-            return this.writeInt8;
+        if ((value & 0x7f) === value) {
+            this.buffer[this.length++] = constants.INT8;
+            this.buffer[this.length++] = value;
+            return 1;
         }
         // 不使用 uint8 以保持兼容
-        // if (value >= 0 && value <= 255) {
-        //     this.writeUint8(value);
-        //     /* eslint-disable-next-line @typescript-eslint/unbound-method */
-        //     return this.writeUint8;
-        // }
-        if (value >= -32768 && value <= 32767) {
-            this.writeInt16(value);
-            /* eslint-disable-next-line @typescript-eslint/unbound-method */
-            return this.writeInt16;
-        }
-        if (value >= -2_147_483_648 && value <= 2_147_483_647) {
-            this.writeInt32(value);
-            /* eslint-disable-next-line @typescript-eslint/unbound-method */
-            return this.writeInt32;
-        }
-        /* c8 ignore next 2 */
-        throw new Error(`Unsupported int value ${value}: out of range`);
-    }
-
-    /** 写入数字，选取合适的大小 */
-    protected writeNumber(value: number): void {
-        if (Number.isInteger(value) && value >= -2_147_483_648 && value <= 2_147_483_647) {
-            if (value >= 0 && value <= 255) return this.writeUint8(value);
-            this.writeInt(value);
-            return;
-        }
-        if (!(Number.isNaN(value) || Math.fround(value) === value)) {
-            return this.writeFloat64(value);
-        }
-        // 如果不会损失精度，则使用 32 位浮点
-        return this.writeFloat32(value);
-    }
-
-    /** writeObject */
-    protected writeObject(value: Record<string, unknown>): void {
-        this.writeMarker(constants.OBJECT);
-        // 生成稳定的结果以便 hash 计算
-        for (const key of Object.keys(value).sort()) {
-            const element = value[key];
-            if (element === undefined) continue;
-            this.writeStringData(key);
-            this.write(element);
-        }
-        this.writeMarker(constants.OBJECT_END);
-    }
-
-    /** writeArray */
-    protected writeArray(value: unknown[]): void {
-        this.writeMarker(constants.ARRAY);
-        for (const v of value) {
-            // 在数组中 undefined 也被视作 null 进行序列化
-            if (v == null) this.writeNull();
-            else this.write(v);
-        }
-        this.writeMarker(constants.ARRAY_END);
-    }
-
-    /** writeArray */
-    protected 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;
-        }
-        /** 用于写入的 setter */
-        let setValue;
-        if (value instanceof Int16Array) {
-            this.writeMarker(constants.INT16);
-            /* eslint-disable-next-line @typescript-eslint/unbound-method */
-            setValue = this.view.setInt16;
-        } else if (value instanceof Int32Array) {
-            this.writeMarker(constants.INT32);
-            /* eslint-disable-next-line @typescript-eslint/unbound-method */
-            setValue = this.view.setInt32;
-        } else if (value instanceof Float32Array) {
-            this.writeMarker(constants.FLOAT32);
-            /* eslint-disable-next-line @typescript-eslint/unbound-method */
-            setValue = this.view.setFloat32;
-        } else if (value instanceof Float64Array) {
-            this.writeMarker(constants.FLOAT64);
-            /* eslint-disable-next-line @typescript-eslint/unbound-method */
-            setValue = this.view.setFloat64;
-        } else {
-            throw new TypeError(`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;
+        if ((value & 0x7fff) === value) {
+            this.buffer[this.length++] = constants.INT16;
+            this.buffer[this.length++] = value >> 8;
+            this.buffer[this.length++] = value & 0xff;
+            return 2;
         }
+        this.buffer[this.length++] = constants.INT32;
+        this.view.setInt32(this.length, value);
+        this.length += 4;
+        return 4;
     }
 }