@colyseus/schema 3.0.0-alpha.0 → 3.0.0-alpha.10

package/src/encoding/decode.ts

@@ -22,6 +22,7 @@
  */
 
 import { SWITCH_TO_STRUCTURE } from "./spec";
+import type { BufferLike } from "./encode";
 
 /**
  * msgpack implementation highly based on notepack.io
@@ -30,9 +31,9 @@ import { SWITCH_TO_STRUCTURE } from "./spec";
 
 export interface Iterator { offset: number; }
 
-function utf8Read(bytes, offset, length) {
+export function utf8Read(bytes: BufferLike, it: Iterator, length: number) {
   var string = '', chr = 0;
-  for (var i = offset, end = offset + length; i < end; i++) {
+  for (var i = it.offset, end = it.offset + length; i < end; i++) {
     var byte = bytes[i];
     if ((byte & 0x80) === 0x00) {
       string += String.fromCharCode(byte);
@@ -71,48 +72,49 @@ function utf8Read(bytes, offset, length) {
     // (do not throw error to avoid server/client from crashing due to hack attemps)
     // throw new Error('Invalid byte ' + byte.toString(16));
   }
+  it.offset += length;
   return string;
 }
 
-export function int8 (bytes: number[], it: Iterator) {
+export function int8 (bytes: BufferLike, it: Iterator) {
     return uint8(bytes, it) << 24 >> 24;
 };
 
-export function uint8 (bytes: number[], it: Iterator) {
+export function uint8 (bytes: BufferLike, it: Iterator) {
     return bytes[it.offset++];
 };
 
-export function int16 (bytes: number[], it: Iterator) {
+export function int16 (bytes: BufferLike, it: Iterator) {
     return uint16(bytes, it) << 16 >> 16;
 };
 
-export function uint16 (bytes: number[], it: Iterator) {
+export function uint16 (bytes: BufferLike, it: Iterator) {
     return bytes[it.offset++] | bytes[it.offset++] << 8;
 };
 
-export function int32 (bytes: number[], it: Iterator) {
+export function int32 (bytes: BufferLike, it: Iterator) {
     return bytes[it.offset++] | bytes[it.offset++] << 8 | bytes[it.offset++] << 16 | bytes[it.offset++] << 24;
 };
 
-export function uint32 (bytes: number[], it: Iterator) {
+export function uint32 (bytes: BufferLike, it: Iterator) {
     return int32(bytes, it) >>> 0;
 };
 
-export function float32(bytes: number[], it: Iterator) {
+export function float32(bytes: BufferLike, it: Iterator) {
   return readFloat32(bytes, it);
 }
 
-export function float64(bytes: number[], it: Iterator) {
+export function float64(bytes: BufferLike, it: Iterator) {
   return readFloat64(bytes, it);
 }
 
-export function int64(bytes: number[], it: Iterator) {
+export function int64(bytes: BufferLike, it: Iterator) {
   const low = uint32(bytes, it);
   const high = int32(bytes, it) * Math.pow(2, 32);
   return high + low;
 };
 
-export function uint64(bytes: number[], it: Iterator) {
+export function uint64(bytes: BufferLike, it: Iterator) {
   const low = uint32(bytes, it);
   const high = uint32(bytes, it) * Math.pow(2, 32);
   return high + low;
@@ -124,22 +126,22 @@ const _int32 = new Int32Array(2);
 const _float32 = new Float32Array(_int32.buffer);
 const _float64 = new Float64Array(_int32.buffer);
 
-export function readFloat32 (bytes: number[], it: Iterator) {
+export function readFloat32 (bytes: BufferLike, it: Iterator) {
     _int32[0] = int32(bytes, it);
     return _float32[0];
 };
 
-export function readFloat64 (bytes: number[], it: Iterator) {
+export function readFloat64 (bytes: BufferLike, it: Iterator) {
     _int32[_isLittleEndian ? 0 : 1] = int32(bytes, it);
     _int32[_isLittleEndian ? 1 : 0] = int32(bytes, it);
     return _float64[0];
 };
 
-export function boolean (bytes: number[], it: Iterator) {
+export function boolean (bytes: BufferLike, it: Iterator) {
     return uint8(bytes, it) > 0;
 };
 
-export function string (bytes, it: Iterator) {
+export function string (bytes: BufferLike, it: Iterator) {
   const prefix = bytes[it.offset++];
   let length: number;
 
@@ -157,13 +159,10 @@ export function string (bytes, it: Iterator) {
     length = uint32(bytes, it);
   }
 
-  const value = utf8Read(bytes, it.offset, length);
-  it.offset += length;
-
-  return value;
+  return utf8Read(bytes, it, length);
 }
 
-export function stringCheck(bytes, it: Iterator) {
+export function stringCheck(bytes: BufferLike, it: Iterator) {
   const prefix = bytes[it.offset];
   return (
     // fixstr
@@ -177,7 +176,7 @@ export function stringCheck(bytes, it: Iterator) {
   );
 }
 
-export function number (bytes, it: Iterator) {
+export function number (bytes: BufferLike, it: Iterator) {
   const prefix = bytes[it.offset++];
 
   if (prefix < 0x80) {
@@ -230,7 +229,7 @@ export function number (bytes, it: Iterator) {
   }
 };
 
-export function numberCheck (bytes, it: Iterator) {
+export function numberCheck (bytes: BufferLike, it: Iterator) {
   const prefix = bytes[it.offset];
   // positive fixint - 0x00 - 0x7f
   // float 32        - 0xca
@@ -249,7 +248,7 @@ export function numberCheck (bytes, it: Iterator) {
   );
 }
 
-export function arrayCheck (bytes, it: Iterator) {
+export function arrayCheck (bytes: BufferLike, it: Iterator) {
   return bytes[it.offset] < 0xa0;
 
   // const prefix = bytes[it.offset] ;
@@ -268,7 +267,7 @@ export function arrayCheck (bytes, it: Iterator) {
   // return prefix;
 }
 
-export function switchStructureCheck(bytes, it: Iterator) {
+export function switchStructureCheck(bytes: BufferLike, it: Iterator) {
   return (
       // previous byte should be `SWITCH_TO_STRUCTURE`
       bytes[it.offset - 1] === SWITCH_TO_STRUCTURE &&

package/src/encoding/encode.ts

@@ -22,6 +22,9 @@
  */
 
 import type { TextEncoder } from "util";
+import type { Iterator } from "./decode";
+
+export type BufferLike = number[] | ArrayBufferLike;
 
 /**
  * msgpack implementation highly based on notepack.io
@@ -32,28 +35,32 @@ let textEncoder: TextEncoder;
 // @ts-ignore
 try { textEncoder = new TextEncoder(); } catch (e) { }
 
-function utf8Length(str) {
-  var c = 0, length = 0;
-  for (var i = 0, l = str.length; i < l; i++) {
-    c = str.charCodeAt(i);
-    if (c < 0x80) {
-      length += 1;
+const hasBufferByteLength = (typeof Buffer !== 'undefined' && Buffer.byteLength);
+
+export const utf8Length = (hasBufferByteLength)
+    ? Buffer.byteLength // node
+    : function (str: string, _?: any) {
+        var c = 0, length = 0;
+        for (var i = 0, l = str.length; i < l; i++) {
+            c = str.charCodeAt(i);
+            if (c < 0x80) {
+                length += 1;
+            }
+            else if (c < 0x800) {
+                length += 2;
+            }
+            else if (c < 0xd800 || c >= 0xe000) {
+                length += 3;
+            }
+            else {
+                i++;
+                length += 4;
+            }
+        }
+        return length;
     }
-    else if (c < 0x800) {
-      length += 2;
-    }
-    else if (c < 0xd800 || c >= 0xe000) {
-      length += 3;
-    }
-    else {
-      i++;
-      length += 4;
-    }
-  }
-  return length;
-}
 
-export function utf8Write(view, str, it) {
+export function utf8Write(view: BufferLike, str: string, it: Iterator) {
   var c = 0;
   for (var i = 0, l = str.length; i < l; i++) {
     c = str.charCodeAt(i);
@@ -80,32 +87,32 @@ export function utf8Write(view, str, it) {
   }
 }
 
-export function int8(bytes, value, it) {
+export function int8(bytes: BufferLike, value: number, it: Iterator) {
     bytes[it.offset++] = value & 255;
 };
 
-export function uint8(bytes, value, it) {
+export function uint8(bytes: BufferLike, value: number, it: Iterator) {
     bytes[it.offset++] = value & 255;
 };
 
-export function int16(bytes, value, it) {
+export function int16(bytes: BufferLike, value: number, it: Iterator) {
     bytes[it.offset++] = value & 255;
     bytes[it.offset++] = (value >> 8) & 255;
 };
 
-export function uint16(bytes, value, it) {
+export function uint16(bytes: BufferLike, value: number, it: Iterator) {
     bytes[it.offset++] = value & 255;
     bytes[it.offset++] = (value >> 8) & 255;
 };
 
-export function int32(bytes, value, it) {
+export function int32(bytes: BufferLike, value: number, it: Iterator) {
   bytes[it.offset++] = value & 255;
   bytes[it.offset++] = (value >> 8) & 255;
   bytes[it.offset++] = (value >> 16) & 255;
   bytes[it.offset++] = (value >> 24) & 255;
 };
 
-export function uint32(bytes, value, it) {
+export function uint32(bytes: BufferLike, value: number, it: Iterator) {
   const b4 = value >> 24;
   const b3 = value >> 16;
   const b2 = value >> 8;
@@ -116,25 +123,25 @@ export function uint32(bytes, value, it) {
   bytes[it.offset++] = b4 & 255;
 };
 
-export function int64(bytes, value, it) {
+export function int64(bytes: BufferLike, value: number, it: Iterator) {
   const high = Math.floor(value / Math.pow(2, 32));
   const low = value >>> 0;
   uint32(bytes, low, it);
   uint32(bytes, high, it);
 };
 
-export function uint64(bytes, value, it) {
+export function uint64(bytes: BufferLike, value: number, it: Iterator) {
   const high = (value / Math.pow(2, 32)) >> 0;
   const low = value >>> 0;
   uint32(bytes, low, it);
   uint32(bytes, high, it);
 };
 
-export function float32(bytes, value, it) {
+export function float32(bytes: BufferLike, value: number, it: Iterator) {
   writeFloat32(bytes, value, it);
 }
 
-export function float64(bytes, value, it) {
+export function float64(bytes: BufferLike, value: number, it: Iterator) {
   writeFloat64(bytes, value, it);
 }
 
@@ -144,27 +151,26 @@ const _int32 = new Int32Array(2);
 const _float32 = new Float32Array(_int32.buffer);
 const _float64 = new Float64Array(_int32.buffer);
 
-export function writeFloat32(bytes, value, it) {
+export function writeFloat32(bytes: BufferLike, value: number, it: Iterator) {
   _float32[0] = value;
   int32(bytes, _int32[0], it);
 };
 
-export function writeFloat64(bytes, value, it) {
+export function writeFloat64(bytes: BufferLike, value: number, it: Iterator) {
   _float64[0] = value;
   int32(bytes, _int32[_isLittleEndian ? 0 : 1], it);
   int32(bytes, _int32[_isLittleEndian ? 1 : 0], it);
 };
 
-export function boolean(bytes, value, it) {
+export function boolean(bytes: BufferLike, value: number, it: Iterator) {
   bytes[it.offset++] = value ? 1 : 0; // uint8
 };
 
-export function string(bytes: Buffer, value, it) {
+export function string(bytes: BufferLike, value: string, it: Iterator) {
   // encode `null` strings as empty.
   if (!value) { value = ""; }
 
-  // let length = utf8Length(value);
-  let length = Buffer.byteLength(value, "utf8");
+  let length = utf8Length(value, "utf8");
   let size = 0;
 
   // fixstr
@@ -198,7 +204,7 @@ export function string(bytes: Buffer, value, it) {
   return size + length;
 }
 
-export function number(bytes, value, it) {
+export function number(bytes: BufferLike, value: number, it: Iterator) {
   if (isNaN(value)) {
     return number(bytes, 0, it);