@wener/utils 1.1.47 → 1.1.49

package/src/io/ByteBuffer.ts

@@ -1,4 +1,3 @@
-import { isDefined } from '../langs/isDefined';
 import { ArrayBuffers } from './ArrayBuffers';
 
 type AnyBuffer = BufferSource | ArrayBufferLike;
@@ -35,18 +34,40 @@ function asBuffer(o: AnyBuffer) {
 /**
  * @see {@link https://www.egret.uk/docs/egretengine/engine/egret.ByteArray egret.ByteArray}
  * @see {@link https://github.com/protobufjs/bytebuffer.js protobufjs/bytebuffer.js}
- * @see {@link https://netty.io/4.1/api/io/netty/buffer/ByteBuf.html ByteBuf}
+ * @see {@link https://netty.io/4.1/api/io/netty/buffer/ByteBuf.html io.netty.buffer.ByteBuf}
+ * @see {@link https://nodejs.org/api/buffer.html node:buffer}
+ * @see {@link https://www.postgresql.org/docs/current/datatype.html PostgreSQL Data Types}
  */
 export class ByteBuffer {
   position = 0;
 
   #buffer: ArrayBufferLike;
   #view: DataView;
+  #bytes: Uint8Array;
+  // #endian: 'big' | 'little' = 'big';
+  #bigEndian = true;
 
   constructor(buffer: AnyBuffer = new ArrayBuffer(0, { maxByteLength: 1024 })) {
     this.#buffer = asBuffer(buffer);
     // NOTE prefer view over buffer, avoid the slice overhead ?
     this.#view = new DataView(this.#buffer);
+    this.#bytes = new Uint8Array(this.#buffer);
+  }
+
+  get littleEndian() {
+    return !this.#bigEndian;
+  }
+
+  set littleEndian(v: boolean) {
+    this.#bigEndian = !v;
+  }
+
+  get bigEndian() {
+    return this.#bigEndian;
+  }
+
+  set bigEndian(v: boolean) {
+    this.#bigEndian = v;
   }
 
   get view() {
@@ -60,6 +81,11 @@ export class ByteBuffer {
   set buffer(buffer: AnyBuffer) {
     this.#buffer = asBuffer(buffer);
     this.#view = new DataView(this.#buffer);
+    this.#bytes = new Uint8Array(this.#buffer);
+  }
+
+  get bytes(): Uint8Array {
+    return this.#bytes;
   }
 
   get length() {
@@ -70,13 +96,8 @@ export class ByteBuffer {
     this.resize(length);
   }
 
-  private willWrite(length: number) {
-    if (this.remaining() < length) {
-      this.resize(this.length + length);
-    }
-  }
-
   resize(newLength: number) {
+    // 1.2 for buffer growth
     this.buffer = ArrayBuffers.resize(this.buffer, newLength, Math.ceil(newLength * 1.2));
   }
 
@@ -87,9 +108,14 @@ export class ByteBuffer {
 
   writeBytes(bytes: ArrayBufferLike, len: number = bytes.byteLength) {
     this.willWrite(len);
-    if (len !== bytes.byteLength) bytes = bytes.slice(0, len);
-    new Uint8Array(this.buffer).set(new Uint8Array(bytes), this.position);
-    this.position += bytes.byteLength;
+    // ensure len first
+    this.bytes.set(new Uint8Array(bytes).subarray(0, len), this.position);
+    if (len > bytes.byteLength) {
+      // fill zero
+      this.bytes.fill(0, this.position + bytes.byteLength, this.position + len);
+    }
+
+    this.position += len;
   }
 
   writeInt8(value: number) {
@@ -106,49 +132,56 @@ export class ByteBuffer {
 
   writeInt16(value: number) {
     this.willWrite(2);
-    this.view.setInt16(this.position, value);
+    this.view.setInt16(this.position, value, this.littleEndian);
     this.position += 2;
   }
 
   writeUint16(value: number) {
     this.willWrite(2);
-    this.view.setUint16(this.position, value);
+    this.view.setUint16(this.position, value, this.littleEndian);
     this.position += 2;
   }
 
+  writeUint24(value: number) {
+    this.willWrite(3);
+    this.view.setUint8(this.position, value & 0xff);
+    this.view.setUint16(this.position + 1, value >> 8, this.littleEndian);
+    this.position += 3;
+  }
+
   writeInt32(value: number) {
     this.willWrite(4);
-    this.view.setInt32(this.position, value);
+    this.view.setInt32(this.position, value, this.littleEndian);
     this.position += 4;
   }
 
   writeUint32(value: number) {
     this.willWrite(4);
-    this.view.setUint32(this.position, value);
+    this.view.setUint32(this.position, value, this.littleEndian);
     this.position += 4;
   }
 
-  writeInt64(value: bigint) {
+  writeInt64(value: bigint | number) {
     this.willWrite(8);
-    this.view.setBigInt64(this.position, value);
+    this.view.setBigInt64(this.position, bigintOf(value), this.littleEndian);
     this.position += 8;
   }
 
-  writeUint64(value: bigint) {
+  writeUint64(value: bigint | number) {
     this.willWrite(8);
-    this.view.setBigUint64(this.position, value);
+    this.view.setBigUint64(this.position, bigintOf(value), this.littleEndian);
     this.position += 8;
   }
 
   writeFloat32(value: number) {
     this.willWrite(4);
-    this.view.setFloat32(this.position, value);
+    this.view.setFloat32(this.position, value, this.littleEndian);
     this.position += 4;
   }
 
   writeFloat64(value: number) {
     this.willWrite(8);
-    this.view.setFloat64(this.position, value);
+    this.view.setFloat64(this.position, value, this.littleEndian);
     this.position += 8;
   }
 
@@ -157,13 +190,32 @@ export class ByteBuffer {
   }
 
   writeString(value: string): void;
+
   writeString(value: string, len?: number): void;
+
   writeString(value: string, len?: number) {
-    let encoder = new TextEncoder();
-    let bytes = encoder.encode(value);
+    let bytes = this.encodeText(value);
     this.writeBytes(bytes, len);
   }
 
+  readSizeString(n?: number) {
+    return this.readString(requireNumber(this.readUint(n)));
+  }
+
+  writeSizeString(value: string, n?: number) {
+    let out = this.encodeText(value);
+    this.writeUint(out.length, n);
+    this.writeBytes(out);
+  }
+
+  encodeText(value: string) {
+    return new TextEncoder().encode(value);
+  }
+
+  decodeText(bytes: ArrayBufferLike) {
+    return new TextDecoder().decode(bytes);
+  }
+
   readByte() {
     return this.view.getUint8(this.position++);
   }
@@ -186,67 +238,82 @@ export class ByteBuffer {
     return value;
   }
 
+  readUnsignedByte() {
+    return this.readUint8();
+  }
+
+  readThrough(end: number) {
+    // readUntil 不包含 end
+    let idx = this.bytes.indexOf(end, this.position);
+    if (idx === -1) {
+      throw new Error(`Byte ${end} not found starting from position ${this.position}`);
+    }
+    let bytes = this.buffer.slice(this.position, idx + 1);
+    this.position = idx + 1;
+    return bytes;
+  }
+
   readInt16() {
-    let value = this.view.getInt16(this.position);
+    let value = this.view.getInt16(this.position, this.littleEndian);
     this.position += 2;
     return value;
   }
 
   readUint16() {
-    let value = this.view.getUint16(this.position);
+    let value = this.view.getUint16(this.position, this.littleEndian);
     this.position += 2;
     return value;
   }
 
   readInt32() {
-    let value = this.view.getInt32(this.position);
+    let value = this.view.getInt32(this.position, this.littleEndian);
     this.position += 4;
     return value;
   }
 
   readUint32() {
-    let value = this.view.getUint32(this.position);
+    let value = this.view.getUint32(this.position, this.littleEndian);
     this.position += 4;
     return value;
   }
 
   readInt64() {
-    let value = this.view.getBigInt64(this.position);
+    let value = this.view.getBigInt64(this.position, this.littleEndian);
     this.position += 8;
     return safeNumber(value);
   }
 
   readUint64() {
-    let value = this.view.getBigUint64(this.position);
+    let value = this.view.getBigUint64(this.position, this.littleEndian);
     this.position += 8;
     return safeNumber(value);
   }
 
   readFloat32() {
-    let value = this.view.getFloat32(this.position);
+    let value = this.view.getFloat32(this.position, this.littleEndian);
     this.position += 4;
     return value;
   }
 
   readFloat64() {
-    let value = this.view.getFloat64(this.position);
+    let value = this.view.getFloat64(this.position, this.littleEndian);
     this.position += 8;
     return value;
   }
 
   readBoolean() {
+    // or !== 0?
     return this.readByte() === 1;
   }
 
-  readString(length: number) {
+  readString(length: number): string {
     let bytes = this.readBytes(length);
-    let decoder = new TextDecoder();
     let a = new Uint8Array(bytes);
     let idx = a.indexOf(0);
     if (idx !== -1) {
       bytes = bytes.slice(0, idx);
     }
-    return decoder.decode(bytes);
+    return this.decodeText(bytes);
   }
 
   readHexString(length: number) {
@@ -254,17 +321,35 @@ export class ByteBuffer {
     return ArrayBuffers.toHex(bytes);
   }
 
+  writeHexString(value: string, len?: number) {
+    this.writeBytes(ArrayBuffers.fromHex(value), len);
+  }
+
   writeInt24(value: number) {
+    // fixme byte order
     this.writeUint8(value & 0xff);
     this.writeUint16(value >> 8);
   }
 
   readInt24() {
-    return this.readUint8() | (this.readUint16() << 8);
+    // fixme recheck
+    let value = this.readUint24();
+    if (value & 0x800000) {
+      // If the sign bit is set, extend the sign
+      value |= 0xff000000;
+    }
+    return value;
+  }
+
+  readUint24() {
+    // fixme recheck
+    return this.readUint8() | (this.readUint8() << 8) | (this.readUint8() << 16);
   }
 
   writeZero(length: number) {
-    this.writeBytes(new Uint8Array(length).buffer);
+    this.willWrite(length);
+    this.bytes.fill(0, this.position, this.position + length);
+    this.position += length;
   }
 
   writeValue(typ: TypedValue['type'], val: TypedValue['value']): void;
@@ -286,16 +371,26 @@ export class ByteBuffer {
       case 'int16':
         this.writeInt16(value);
         break;
+      case 'uint24':
+        this.writeUint24(value);
+        break;
+      case 'int24':
+        this.writeInt24(value);
+        break;
       case 'uint32':
+      case 'uint':
         this.writeUint32(value);
         break;
       case 'int32':
+      case 'int':
         this.writeInt32(value);
         break;
       case 'float32':
+      case 'float':
         this.writeFloat32(value);
         break;
       case 'float64':
+      case 'double':
         this.writeFloat64(value);
         break;
       case 'string':
@@ -312,20 +407,130 @@ export class ByteBuffer {
     }
   }
 
-  readInt() {
-    return this.readInt32();
+  readUnsignedShort() {
+    return this.readUint16();
+  }
+
+  readShort() {
+    return this.readInt16();
+  }
+
+  readInt(bytesOrBits: number = 32) {
+    switch (bytesOrBits) {
+      case 1:
+      case 8:
+        return this.readInt8();
+      case 2:
+      case 16:
+        return this.readInt16();
+      case 3:
+      case 24:
+        return this.readInt24();
+      case 4:
+      case 32:
+        return this.readInt32();
+      // skip 8 byte for bits
+      case 64:
+        return this.readInt64();
+      default:
+        throw new Error(`Unknown int${bytesOrBits}`);
+    }
+  }
+
+  readUint(bytesOrBits: number = 32) {
+    switch (bytesOrBits) {
+      case 1:
+      case 8:
+        return this.readUint8();
+      case 2:
+      case 16:
+        return this.readUint16();
+      case 3:
+      case 24:
+        return this.readUint24();
+      case 4:
+      case 32:
+        return this.readUint32();
+      // skip 8 byte for bits
+      case 64:
+        return this.readUint64();
+      default:
+        throw new Error(`Unexpected int size: ${bytesOrBits}`);
+    }
+  }
+
+  writeUint(value: number, bytesOrBits: number = 32) {
+    switch (bytesOrBits) {
+      case 1:
+      case 8:
+        this.writeUint8(value);
+        break;
+      case 2:
+      case 16:
+        this.writeUint16(value);
+        break;
+      case 3:
+      case 24:
+        this.writeUint24(value);
+        break;
+      case 4:
+      case 32:
+        this.writeUint32(value);
+        break;
+      case 64:
+        this.writeUint64(value);
+        break;
+      default:
+        throw new Error(`Unexpected uint size: ${bytesOrBits}`);
+    }
   }
 
-  readFloat() {
-    return this.readFloat32();
+  readFloat(n: number = 32) {
+    switch (n) {
+      case 4:
+      case 32:
+        return this.readFloat32();
+      case 8:
+      case 64:
+        return this.readFloat64();
+      default:
+        throw new Error(`Unexpected float size: ${n}`);
+    }
+  }
+
+  writeFloat(value: number, n: number = 32) {
+    switch (n) {
+      case 4:
+      case 32:
+        this.writeFloat32(value);
+        break;
+      case 8:
+      case 64:
+        this.writeFloat64(value);
+        break;
+      default:
+        throw new Error(`Unexpected float size: ${n}`);
+    }
   }
 
   readDouble() {
     return this.readFloat64();
   }
 
+  writeDouble(value: number) {
+    this.writeFloat64(value);
+  }
+
   remaining() {
-    return this.view.byteLength - this.position;
+    return this.length - this.position;
+  }
+
+  hasRemaining() {
+    return this.remaining() > 0;
+  }
+
+  readRemaining() {
+    return this.readBytes(this.remaining());
   }
 
   toUint8Array() {
@@ -339,6 +544,12 @@ export class ByteBuffer {
   toBase64() {
     return ArrayBuffers.toBase64(this.buffer);
   }
+
+  private willWrite(length: number) {
+    if (this.remaining() < length) {
+      this.resize(this.position + length);
+    }
+  }
 }
 
 export interface TypedValue {
@@ -349,9 +560,15 @@ export interface TypedValue {
     | 'int8'
     | 'uint16'
     | 'int16'
+    | 'uint24'
+    | 'int24'
+    | 'int'
+    | 'uint'
     | 'uint32'
     | 'int32'
+    | 'float'
     | 'float32'
+    | 'double'
     | 'float64'
     | 'string'
     | 'boolean';
@@ -365,3 +582,17 @@ function safeNumber(n: bigint) {
   }
   return Number(n);
 }
+
+function bigintOf(n: number | bigint) {
+  if (typeof n === 'bigint') {
+    return n;
+  }
+  return BigInt(n);
+}
+
+function requireNumber(n: number | bigint) {
+  if (typeof n !== 'number') {
+    throw new Error(`Expected number, got ${n}`);
+  }
+  return n;
+}

package/src/langs/getGlobalStates.ts

@@ -0,0 +1,21 @@
+import { computeIfAbsent, getGlobalThis } from '@wener/utils';
+
+let _holder: any;
+
+export function setGlobalStates(states: Record<string, any>) {
+  _holder = states;
+}
+
+export function getGlobalStates(): Record<string, any>;
+export function getGlobalStates<T>(key: string, create: () => T): T;
+export function getGlobalStates<T>(key: string): T | undefined;
+export function getGlobalStates(key?: string, create?: () => any): any {
+  _holder ||= (getGlobalThis() as any).__GLOBAL_STATES__ ||= {};
+  if (key) {
+    if (!create) {
+      return _holder[key];
+    }
+    return computeIfAbsent(_holder, key, create);
+  }
+  return _holder;
+}

package/src/langs/getObjectId.ts

@@ -0,0 +1,20 @@
+import { getGlobalStates } from './getGlobalStates';
+
+export function getObjectId(k: any): number {
+  const state = getGlobalStates('ObjectId', () => {
+    return {
+      id: 0,
+      map: new WeakMap(),
+    };
+  });
+
+  const { map } = state;
+
+  if (map.has(k)) {
+    return map.get(k);
+  }
+
+  const id = state.id++;
+  map.set(k, id);
+  return id;
+}

package/src/langs/isNullish.ts

@@ -0,0 +1,3 @@
+export function isNullish(value: any): value is null | undefined {
+  return value === null || value === undefined;
+}

package/src/langs/mixin.test.ts

@@ -0,0 +1,43 @@
+import { expect, test } from 'vitest';
+import { mixin } from './mixin';
+
+export type Constructor<T = {}> = new (...args: any[]) => T;
+
+test('mixin', () => {
+  // @ts-ignore
+  class User extends mixin(BaseResource, createBarFields()) {}
+
+  let usr = new User();
+  // type not working
+  // @ts-ignore
+  expect(usr.foo, 'foo');
+  expect(usr).toEqual({
+    foo: 'foo',
+    bar: 'bar',
+    id: '',
+  });
+});
+
+class BaseResource {
+  id?: string = '';
+}
+
+function createBarFields() {
+  return <TBase extends Constructor>(Base: TBase) => {
+    // nested type not working
+    // @ts-ignore
+    class HasBarMixin extends mixin(Base, withFooFields) {
+      bar?: string = 'bar';
+    }
+
+    return HasBarMixin;
+  };
+}
+
+function withFooFields<TBase extends Constructor>(Base: TBase) {
+  class HasFieldFooMixin extends Base {
+    foo?: string = 'foo';
+  }
+
+  return HasFieldFooMixin;
+}

package/src/logging/slog.ts

@@ -1,4 +1,4 @@
-import { Logger, LogLevel } from './Logger';
+import type { Logger, LogLevel } from './Logger';
 
 enum Level {
   trace = -8,

package/src/maths/clamp.test.ts

@@ -13,7 +13,11 @@ test('clamp', () => {
     [[null, { min: 1, max: 10 }], 1],
     [[null, { min: 1, max: 10, default: 5 }], 5],
     [[2n, 1, 10, 5], 2n],
+    [[1, 2], 2], //  min
+    [[1, undefined, 0], 0], // max
+    [[], undefined],
+    [[null], undefined],
   ]) {
-    expect(clamp.apply(null, a as any)).toBe(b);
+    expect(clamp.apply(null, a as any), `${a} -> ${b}`).toBe(b);
   }
 });

package/src/maths/clamp.ts

@@ -1,23 +1,23 @@
-// export function clamp<T>(value: T | null | undefined, o: { min: T; max: T; default?: T }): T;
+import { isDefined } from '../langs/isDefined';
+import { isNullish } from '../langs/isNullish';
 
+// export function clamp<T>(value: T | null | undefined, opts: { min?: T; max?: T; default?: T }): T;
 export function clamp<T>(value: T | null | undefined, min: T, max: T, def?: T): T;
 export function clamp<T>(value: T | null | undefined, ...o: any[]): T {
   let min: T, max: T, def: T;
-  if (o.length === 1) {
+  if (o.length === 1 && o[0] && typeof o[0] === 'object') {
     ({ min, max, default: def = min! } = o[0]);
   } else {
     [min, max, def = min!] = o;
   }
-  if (value === null || value === undefined) {
+  if (isNullish(value)) {
     return def;
   }
-  if (value < min) {
+  if (isDefined(min) && value < min) {
     return min;
   }
-  if (value > max) {
+  if (isDefined(max) && value > max) {
     return max;
   }
   return value;
 }
-
-// type Comparable = number | string | Date | BigInt;

package/src/maths/random.ts

@@ -1,6 +1,6 @@
 /// javascript pseudo random
 export function createRandom(o: { seed?: string | number } = {}) {
-  let seed = typeof o.seed === 'string' ? 0 : o.seed ?? 0;
+  let seed = typeof o.seed === 'string' ? 0 : (o.seed ?? 0);
   if (typeof o.seed === 'string') {
     let sum = 0;
     for (let i = 0; i < o.seed.length; i++) {

package/src/mitt/README.md

@@ -0,0 +1 @@
+- https://github.com/developit/mitt/blob/main/src/index.ts