@colyseus/schema 1.0.35 → 1.0.36

package/src/codegen/types.ts

@@ -0,0 +1,164 @@
+import * as fs from "fs";
+
+const VERSION = JSON.parse(fs.readFileSync(__dirname + "/../../package.json").toString()).version;
+const COMMENT_HEADER = `
+THIS FILE HAS BEEN GENERATED AUTOMATICALLY
+DO NOT CHANGE IT MANUALLY UNLESS YOU KNOW WHAT YOU'RE DOING
+
+GENERATED USING @colyseus/schema ${VERSION}
+`;
+
+export function getCommentHeader(singleLineComment: string = "//") {
+    return `${COMMENT_HEADER.split("\n").map(line => `${singleLineComment} ${line}`).join("\n")}`;
+}
+
+export class Context {
+    classes: Class[] = [];
+    interfaces: Interface[] = [];
+
+    getStructures() {
+        return {
+            classes: this.classes.filter(klass => {
+                if (this.isSchemaClass(klass)) {
+                    return true;
+
+                } else {
+                    let parentClass = klass;
+                    while (parentClass = this.getParentClass(parentClass)) {
+                        if (this.isSchemaClass(parentClass)) {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }),
+            interfaces: this.interfaces,
+        };
+    }
+
+    addStructure(structure: IStructure) {
+        structure.context = this;
+
+        if (structure instanceof Class) {
+            this.classes.push(structure);
+
+        } else if (structure instanceof Interface) {
+            this.interfaces.push(structure);
+        }
+    }
+
+    private getParentClass(klass: Class) {
+        return this.classes.find(c => c.name === klass.extends);
+    }
+
+    private isSchemaClass(klass: Class) {
+        let isSchema: boolean = false;
+
+        let currentClass = klass;
+        while (!isSchema && currentClass) {
+            //
+            // TODO: ideally we should check for actual @colyseus/schema module
+            // reference rather than arbitrary strings.
+            //
+            isSchema = (
+                currentClass.extends === "Schema" ||
+                currentClass.extends === "schema.Schema" ||
+                currentClass.extends === "Schema.Schema"
+            );
+
+            //
+            // When extending from `schema.Schema`, it is required to
+            // normalize as "Schema" for code generation.
+            //
+            if (currentClass === klass && isSchema) {
+                klass.extends = "Schema";
+            }
+
+            currentClass = this.getParentClass(currentClass);
+        }
+
+        return isSchema;
+    }
+}
+
+export interface IStructure {
+    context: Context;
+    name: string;
+    properties: Property[];
+    addProperty(property: Property);
+}
+
+export class Interface implements IStructure {
+    context: Context;
+    name: string;
+    properties: Property[] = [];
+
+    addProperty(property: Property) {
+        if (property.type.indexOf("[]") >= 0) {
+            // is array!
+            property.childType = property.type.match(/([^\[]+)/i)[1];
+            property.type = "array";
+            this.properties.push(property);
+
+        } else {
+            this.properties.push(property);
+        }
+    }
+}
+
+export class Class implements IStructure {
+    context: Context;
+    name: string;
+    properties: Property[] = [];
+    extends: string;
+
+    addProperty(property: Property) {
+        property.index = this.properties.length;
+        this.properties.push(property);
+    }
+
+    postProcessing() {
+        /**
+         * Ensure the proprierties `index` are correct using inheritance
+         */
+        let parentKlass: Class = this;
+
+        while (
+            parentKlass &&
+            (parentKlass = this.context.classes.find(k => k.name === parentKlass.extends))
+        ) {
+            this.properties.forEach(prop => {
+                prop.index += parentKlass.properties.length;
+            });
+        }
+    }
+}
+
+export class Property {
+    index: number;
+    name: string;
+    type: string;
+    childType: string;
+    deprecated?: boolean;
+}
+
+export interface File {
+    name: string
+    content: string;
+}
+
+export function getInheritanceTree(klass: Class, allClasses: Class[], includeSelf: boolean = true) {
+    let currentClass = klass;
+    let inheritanceTree: Class[] = [];
+
+    if (includeSelf) {
+        inheritanceTree.push(currentClass);
+    }
+
+    while (currentClass.extends !== "Schema") {
+        currentClass = allClasses.find(klass => klass.name == currentClass.extends);
+        inheritanceTree.push(currentClass);
+    }
+
+    return inheritanceTree;
+}

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;
+  }
+}