@colyseus/schema 2.0.4 → 2.0.6

package/src/encoding/decode.ts

@@ -0,0 +1,278 @@
+/**
+ * Copyright (c) 2018 Endel Dreyer
+ * Copyright (c) 2014 Ion Drive Software Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE
+ */
+
+import { SWITCH_TO_STRUCTURE } from "../spec";
+
+/**
+ * msgpack implementation highly based on notepack.io
+ * https://github.com/darrachequesne/notepack
+ */
+
+export interface Iterator { offset: number; }
+
+function utf8Read(bytes, offset, length) {
+  var string = '', chr = 0;
+  for (var i = offset, end = offset + length; i < end; i++) {
+    var byte = bytes[i];
+    if ((byte & 0x80) === 0x00) {
+      string += String.fromCharCode(byte);
+      continue;
+    }
+    if ((byte & 0xe0) === 0xc0) {
+      string += String.fromCharCode(
+        ((byte & 0x1f) << 6) |
+        (bytes[++i] & 0x3f)
+      );
+      continue;
+    }
+    if ((byte & 0xf0) === 0xe0) {
+      string += String.fromCharCode(
+        ((byte & 0x0f) << 12) |
+        ((bytes[++i] & 0x3f) << 6) |
+        ((bytes[++i] & 0x3f) << 0)
+      );
+      continue;
+    }
+    if ((byte & 0xf8) === 0xf0) {
+      chr = ((byte & 0x07) << 18) |
+        ((bytes[++i] & 0x3f) << 12) |
+        ((bytes[++i] & 0x3f) << 6) |
+        ((bytes[++i] & 0x3f) << 0);
+      if (chr >= 0x010000) { // surrogate pair
+        chr -= 0x010000;
+        string += String.fromCharCode((chr >>> 10) + 0xD800, (chr & 0x3FF) + 0xDC00);
+      } else {
+        string += String.fromCharCode(chr);
+      }
+      continue;
+    }
+
+    console.error('Invalid byte ' + byte.toString(16));
+    // (do not throw error to avoid server/client from crashing due to hack attemps)
+    // throw new Error('Invalid byte ' + byte.toString(16));
+  }
+  return string;
+}
+
+export function int8 (bytes: number[], it: Iterator) {
+    return uint8(bytes, it) << 24 >> 24;
+};
+
+export function uint8 (bytes: number[], it: Iterator) {
+    return bytes[it.offset++];
+};
+
+export function int16 (bytes: number[], it: Iterator) {
+    return uint16(bytes, it) << 16 >> 16;
+};
+
+export function uint16 (bytes: number[], it: Iterator) {
+    return bytes[it.offset++] | bytes[it.offset++] << 8;
+};
+
+export function int32 (bytes: number[], 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) {
+    return int32(bytes, it) >>> 0;
+};
+
+export function float32(bytes: number[], it: Iterator) {
+  return readFloat32(bytes, it);
+}
+
+export function float64(bytes: number[], it: Iterator) {
+  return readFloat64(bytes, it);
+}
+
+export function int64(bytes: number[], 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) {
+  const low = uint32(bytes, it);
+  const high = uint32(bytes, it) * Math.pow(2, 32);
+  return high + low;
+};
+
+// force little endian to facilitate decoding on multiple implementations
+const _isLittleEndian = true;  // new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
+const _int32 = new Int32Array(2);
+const _float32 = new Float32Array(_int32.buffer);
+const _float64 = new Float64Array(_int32.buffer);
+
+export function readFloat32 (bytes: number[], it: Iterator) {
+    _int32[0] = int32(bytes, it);
+    return _float32[0];
+};
+
+export function readFloat64 (bytes: number[], 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) {
+    return uint8(bytes, it) > 0;
+};
+
+export function string (bytes, it: Iterator) {
+  const prefix = bytes[it.offset++];
+  let length: number;
+
+  if (prefix < 0xc0) {
+    // fixstr
+    length = prefix & 0x1f;
+
+  } else if (prefix === 0xd9) {
+    length = uint8(bytes, it);
+
+  } else if (prefix === 0xda) {
+    length = uint16(bytes, it);
+
+  } else if (prefix === 0xdb) {
+    length = uint32(bytes, it);
+  }
+
+  const value = utf8Read(bytes, it.offset, length);
+  it.offset += length;
+
+  return value;
+}
+
+export function stringCheck(bytes, it: Iterator) {
+  const prefix = bytes[it.offset];
+  return (
+    // fixstr
+    (prefix < 0xc0 && prefix > 0xa0) ||
+    // str 8
+    prefix === 0xd9 ||
+    // str 16
+    prefix === 0xda ||
+    // str 32
+    prefix === 0xdb
+  );
+}
+
+export function number (bytes, it: Iterator) {
+  const prefix = bytes[it.offset++];
+
+  if (prefix < 0x80) {
+    // positive fixint
+    return prefix;
+
+  } else if (prefix === 0xca) {
+    // float 32
+    return readFloat32(bytes, it);
+
+  } else if (prefix === 0xcb) {
+    // float 64
+    return readFloat64(bytes, it);
+
+  } else if (prefix === 0xcc) {
+    // uint 8
+    return uint8(bytes, it);
+
+  } else if (prefix === 0xcd) {
+    // uint 16
+    return uint16(bytes, it);
+
+  } else if (prefix === 0xce) {
+    // uint 32
+    return uint32(bytes, it);
+
+  } else if (prefix === 0xcf) {
+    // uint 64
+    return uint64(bytes, it);
+
+  } else if (prefix === 0xd0) {
+    // int 8
+    return int8(bytes, it);
+
+  } else if (prefix === 0xd1) {
+    // int 16
+    return int16(bytes, it);
+
+  } else if (prefix === 0xd2) {
+    // int 32
+    return int32(bytes, it);
+
+  } else if (prefix === 0xd3) {
+    // int 64
+    return int64(bytes, it);
+
+  } else if (prefix > 0xdf) {
+    // negative fixint
+    return (0xff - prefix + 1) * -1
+  }
+};
+
+export function numberCheck (bytes, it: Iterator) {
+  const prefix = bytes[it.offset];
+  // positive fixint - 0x00 - 0x7f
+  // float 32        - 0xca
+  // float 64        - 0xcb
+  // uint 8          - 0xcc
+  // uint 16         - 0xcd
+  // uint 32         - 0xce
+  // uint 64         - 0xcf
+  // int 8           - 0xd0
+  // int 16          - 0xd1
+  // int 32          - 0xd2
+  // int 64          - 0xd3
+  return (
+    prefix < 0x80 ||
+    (prefix >= 0xca && prefix <= 0xd3)
+  );
+}
+
+export function arrayCheck (bytes, it: Iterator) {
+  return bytes[it.offset] < 0xa0;
+
+  // const prefix = bytes[it.offset] ;
+
+  // if (prefix < 0xa0) {
+  //   return prefix;
+
+  // // array
+  // } else if (prefix === 0xdc) {
+  //   it.offset += 2;
+
+  // } else if (0xdd) {
+  //   it.offset += 4;
+  // }
+
+  // return prefix;
+}
+
+export function switchStructureCheck(bytes, it: Iterator) {
+  return (
+      // previous byte should be `SWITCH_TO_STRUCTURE`
+      bytes[it.offset - 1] === SWITCH_TO_STRUCTURE &&
+      // next byte should be a number
+      (bytes[it.offset] < 0x80 || (bytes[it.offset] >= 0xca && bytes[it.offset] <= 0xd3))
+  );
+}

package/src/encoding/encode.ts

@@ -0,0 +1,283 @@
+/**
+ * Copyright (c) 2018 Endel Dreyer
+ * Copyright (c) 2014 Ion Drive Software Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE
+ */
+
+/**
+ * msgpack implementation highly based on notepack.io
+ * https://github.com/darrachequesne/notepack
+ */
+
+
+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;
+    }
+    else if (c < 0x800) {
+      length += 2;
+    }
+    else if (c < 0xd800 || c >= 0xe000) {
+      length += 3;
+    }
+    else {
+      i++;
+      length += 4;
+    }
+  }
+  return length;
+}
+
+export function utf8Write(view, offset, str) {
+  var c = 0;
+  for (var i = 0, l = str.length; i < l; i++) {
+    c = str.charCodeAt(i);
+    if (c < 0x80) {
+      view[offset++] = c;
+    }
+    else if (c < 0x800) {
+      view[offset++] = 0xc0 | (c >> 6);
+      view[offset++] = 0x80 | (c & 0x3f);
+    }
+    else if (c < 0xd800 || c >= 0xe000) {
+      view[offset++] = 0xe0 | (c >> 12);
+      view[offset++] = 0x80 | (c >> 6 & 0x3f);
+      view[offset++] = 0x80 | (c & 0x3f);
+    }
+    else {
+      i++;
+      c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
+      view[offset++] = 0xf0 | (c >> 18);
+      view[offset++] = 0x80 | (c >> 12 & 0x3f);
+      view[offset++] = 0x80 | (c >> 6 & 0x3f);
+      view[offset++] = 0x80 | (c & 0x3f);
+    }
+  }
+}
+
+export function int8(bytes, value) {
+  bytes.push(value & 255);
+};
+
+export function uint8(bytes, value) {
+  bytes.push(value & 255);
+};
+
+export function int16(bytes, value) {
+  bytes.push(value & 255);
+  bytes.push((value >> 8) & 255);
+};
+
+export function uint16(bytes, value) {
+  bytes.push(value & 255);
+  bytes.push((value >> 8) & 255);
+};
+
+export function int32(bytes, value) {
+  bytes.push(value & 255);
+  bytes.push((value >> 8) & 255);
+  bytes.push((value >> 16) & 255);
+  bytes.push((value >> 24) & 255);
+};
+
+export function uint32(bytes, value) {
+  const b4 = value >> 24;
+  const b3 = value >> 16;
+  const b2 = value >> 8;
+  const b1 = value;
+  bytes.push(b1 & 255);
+  bytes.push(b2 & 255);
+  bytes.push(b3 & 255);
+  bytes.push(b4 & 255);
+};
+
+export function int64(bytes, value) {
+  const high = Math.floor(value / Math.pow(2, 32));
+  const low = value >>> 0;
+  uint32(bytes, low);
+  uint32(bytes, high);
+};
+
+export function uint64(bytes, value) {
+  const high = (value / Math.pow(2, 32)) >> 0;
+  const low = value >>> 0;
+  uint32(bytes, low);
+  uint32(bytes, high);
+};
+
+export function float32(bytes, value) {
+  writeFloat32(bytes, value);
+}
+
+export function float64(bytes, value) {
+  writeFloat64(bytes, value);
+}
+
+// force little endian to facilitate decoding on multiple implementations
+const _isLittleEndian = true;  // new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
+const _int32 = new Int32Array(2);
+const _float32 = new Float32Array(_int32.buffer);
+const _float64 = new Float64Array(_int32.buffer);
+
+export function writeFloat32(bytes, value) {
+  _float32[0] = value;
+  int32(bytes, _int32[0]);
+};
+
+export function writeFloat64(bytes, value) {
+  _float64[0] = value;
+  int32(bytes, _int32[_isLittleEndian ? 0 : 1]);
+  int32(bytes, _int32[_isLittleEndian ? 1 : 0]);
+};
+
+export function boolean(bytes, value) {
+  return uint8(bytes, value ? 1 : 0);
+};
+
+export function string(bytes, value) {
+  // encode `null` strings as empty.
+  if (!value) { value = ""; }
+
+  let length = utf8Length(value);
+  let size = 0;
+
+  // fixstr
+  if (length < 0x20) {
+    bytes.push(length | 0xa0);
+    size = 1;
+  }
+  // str 8
+  else if (length < 0x100) {
+    bytes.push(0xd9);
+    uint8(bytes, length);
+    size = 2;
+  }
+  // str 16
+  else if (length < 0x10000) {
+    bytes.push(0xda);
+    uint16(bytes, length);
+    size = 3;
+  }
+  // str 32
+  else if (length < 0x100000000) {
+    bytes.push(0xdb);
+    uint32(bytes, length);
+    size = 5;
+  } else {
+    throw new Error('String too long');
+  }
+
+  utf8Write(bytes, bytes.length, value);
+
+  return size + length;
+}
+
+export function number(bytes, value) {
+  if (isNaN(value)) {
+    return number(bytes, 0);
+
+  } else if (!isFinite(value)) {
+    return number(bytes, (value > 0) ? Number.MAX_SAFE_INTEGER : -Number.MAX_SAFE_INTEGER);
+
+  } else if (value !== (value|0)) {
+    bytes.push(0xcb);
+    writeFloat64(bytes, value);
+    return 9;
+
+    // TODO: encode float 32?
+    // is it possible to differentiate between float32 / float64 here?
+
+    // // float 32
+    // bytes.push(0xca);
+    // writeFloat32(bytes, value);
+    // return 5;
+  }
+
+  if (value >= 0) {
+    // positive fixnum
+    if (value < 0x80) {
+      uint8(bytes, value);
+      return 1;
+    }
+
+    // uint 8
+    if (value < 0x100) {
+      bytes.push(0xcc);
+      uint8(bytes, value);
+      return 2;
+    }
+
+    // uint 16
+    if (value < 0x10000) {
+      bytes.push(0xcd);
+      uint16(bytes, value);
+      return 3;
+    }
+
+    // uint 32
+    if (value < 0x100000000) {
+      bytes.push(0xce);
+      uint32(bytes, value);
+      return 5;
+    }
+
+    // uint 64
+    bytes.push(0xcf);
+    uint64(bytes, value);
+    return 9;
+
+  } else {
+
+    // negative fixnum
+    if (value >= -0x20) {
+      bytes.push(0xe0 | (value + 0x20));
+      return 1;
+    }
+
+    // int 8
+    if (value >= -0x80) {
+      bytes.push(0xd0);
+      int8(bytes, value);
+      return 2;
+    }
+
+    // int 16
+    if (value >= -0x8000) {
+      bytes.push(0xd1);
+      int16(bytes, value);
+      return 3;
+    }
+
+    // int 32
+    if (value >= -0x80000000) {
+      bytes.push(0xd2);
+      int32(bytes, value);
+      return 5;
+    }
+
+    // int 64
+    bytes.push(0xd3);
+    int64(bytes, value);
+    return 9;
+  }
+}

package/src/filters/index.ts

@@ -0,0 +1,23 @@
+import { ChangeTree } from "../changes/ChangeTree";
+import { ClientWithSessionId } from "../annotations";
+
+export class ClientState {
+    refIds = new WeakSet<ChangeTree>();
+    containerIndexes = new WeakMap<ChangeTree, Set<number>>();
+    // containerIndexes = new Map<ChangeTree, Set<number>>();
+
+    addRefId(changeTree: ChangeTree) {
+        if (!this.refIds.has(changeTree)) {
+            this.refIds.add(changeTree);
+            this.containerIndexes.set(changeTree, new Set());
+        }
+    }
+
+    static get(client: ClientWithSessionId) {
+        if (client.$filterState === undefined) {
+            client.$filterState = new ClientState();
+        }
+
+        return client.$filterState as ClientState;
+    }
+}

package/src/index.ts

@@ -0,0 +1,59 @@
+export { Schema, DataChange } from "./Schema";
+
+import { MapSchema } from "./types/MapSchema"
+export { MapSchema };
+
+import { ArraySchema } from "./types/ArraySchema";
+export { ArraySchema };
+
+import { CollectionSchema } from "./types/CollectionSchema";
+export { CollectionSchema };
+
+import { SetSchema } from "./types/SetSchema";
+export { SetSchema };
+
+import { registerType } from "./types/typeRegistry";
+export { registerType };
+
+registerType("map", { constructor: MapSchema });
+registerType("array", { constructor: ArraySchema });
+registerType("set", { constructor: SetSchema });
+registerType("collection", { constructor: CollectionSchema, });
+
+// Utils
+export { dumpChanges } from "./utils";
+
+// Encoder / Decoder
+export { Iterator } from "./encoding/decode";
+import * as encode from "./encoding/encode";
+import * as decode from "./encoding/decode";
+export { encode, decode };
+
+// Reflection
+export {
+    Reflection,
+    ReflectionType,
+    ReflectionField,
+} from "./Reflection";
+
+export {
+    // Annotations
+    type,
+    deprecated,
+    filter,
+    filterChildren,
+    defineTypes,
+    hasFilter,
+
+    // Internals
+    SchemaDefinition,
+
+    // Types
+    Context,
+    PrimitiveType,
+    Definition,
+    DefinitionType,
+    FilterCallback,
+} from "./annotations";
+
+export { OPERATION } from "./spec";

package/src/spec.ts

@@ -0,0 +1,49 @@
+// export const SWITCH_TO_STRUCTURE = 193; (easily collides with DELETE_AND_ADD + fieldIndex = 2)
+export const SWITCH_TO_STRUCTURE = 255; // (decoding collides with DELETE_AND_ADD + fieldIndex = 63)
+export const TYPE_ID = 213;
+
+/**
+ * Encoding Schema field operations.
+ */
+export enum OPERATION {
+    // add new structure/primitive
+    ADD = 128,
+
+    // replace structure/primitive
+    REPLACE = 0,
+
+    // delete field
+    DELETE = 64,
+
+    // DELETE field, followed by an ADD
+    DELETE_AND_ADD = 192, // 11100000
+
+    // TOUCH is used to determine hierarchy of nested Schema structures during serialization.
+    // touches are NOT encoded.
+    TOUCH = 1, // 00000000
+
+    // MapSchema Operations
+    CLEAR = 10,
+}
+
+// export enum OPERATION {
+//     // add new structure/primitive
+//     // (128)
+//     ADD = 128, // 10000000,
+
+//     // replace structure/primitive
+//     REPLACE = 1,// 00000001
+
+//     // delete field
+//     DELETE = 192, // 11000000
+
+//     // DELETE field, followed by an ADD
+//     DELETE_AND_ADD = 224, // 11100000
+
+//     // TOUCH is used to determine hierarchy of nested Schema structures during serialization.
+//     // touches are NOT encoded.
+//     TOUCH = 0, // 00000000
+
+//     // MapSchema Operations
+//     CLEAR = 10,
+// }