@colyseus/schema 2.0.31 → 3.0.0-alpha.0

package/src/encoder/StateView.ts

@@ -0,0 +1,229 @@
+import { ChangeTree, Ref } from "./ChangeTree";
+import { $changes } from "../types/symbols";
+import { DEFAULT_VIEW_TAG } from "../annotations";
+import { OPERATION } from "../encoding/spec";
+import { Metadata } from "../Metadata";
+
+export class StateView {
+    /**
+     * List of ChangeTree's that are visible to this view
+     */
+    items: WeakSet<ChangeTree> = new WeakSet<ChangeTree>();
+
+    /**
+     * List of ChangeTree's that are invisible to this view
+     */
+    invisible: WeakSet<ChangeTree> = new WeakSet<ChangeTree>();
+
+    tags?: WeakMap<ChangeTree, Set<number>>; // TODO: use bit manipulation instead of Set<number> ()
+
+    /**
+     * Manual "ADD" operations for changes per ChangeTree, specific to this view.
+     * (This is used to force encoding a property, even if it was not changed)
+     */
+    changes = new Map<ChangeTree, Map<number, OPERATION>>();
+
+    // TODO: allow to set multiple tags at once
+    add(obj: Ref, tag: number = DEFAULT_VIEW_TAG) {
+        if (!obj[$changes]) {
+            console.warn("StateView#add(), invalid object:", obj);
+            return this;
+        }
+
+        let changeTree: ChangeTree = obj[$changes];
+        this.items.add(changeTree);
+
+        // Add children of this ChangeTree to this view
+        changeTree.forEachChild((change, _) =>
+            this.add(change.ref, tag));
+
+        // FIXME: ArraySchema/MapSchema does not have metadata
+        const metadata: Metadata = obj.constructor[Symbol.metadata];
+
+        // add parent ChangeTree's, if they are invisible to this view
+        // TODO: REFACTOR addParent()
+        this.addParent(changeTree, tag);
+
+        //
+        // TODO: when adding an item of a MapSchema, the changes may not
+        // be set (only the parent's changes are set)
+        //
+        let changes = this.changes.get(changeTree);
+        if (changes === undefined) {
+            changes = new Map<number, OPERATION>();
+            this.changes.set(changeTree, changes)
+        }
+
+        // set tag
+        if (tag !== DEFAULT_VIEW_TAG) {
+            if (!this.tags) {
+                this.tags = new WeakMap<ChangeTree, Set<number>>();
+            }
+            let tags: Set<number>;
+            if (!this.tags.has(changeTree)) {
+                tags = new Set<number>();
+                this.tags.set(changeTree, tags);
+            } else {
+                tags = this.tags.get(changeTree);
+            }
+            tags.add(tag);
+
+            // console.log("BY TAG:", tag);
+
+            // Ref: add tagged properties
+            metadata?.[-3]?.[tag]?.forEach((index) => {
+                if (changeTree.getChange(index) !== OPERATION.DELETE) {
+                    changes.set(index, OPERATION.ADD)
+                }
+            });
+
+        } else {
+
+            // console.log("DEFAULT TAG", changeTree.allChanges);
+
+            // // add default tag properties
+            // metadata?.[-3]?.[DEFAULT_VIEW_TAG]?.forEach((index) => {
+            //     if (changeTree.getChange(index) !== OPERATION.DELETE) {
+            //         changes.set(index, OPERATION.ADD);
+            //     }
+            // });
+
+            const allChangesSet = (changeTree.isFiltered || changeTree.isPartiallyFiltered)
+                ? changeTree.allFilteredChanges
+                : changeTree.allChanges;
+            const it = allChangesSet.keys();
+            const isInvisible = this.invisible.has(changeTree);
+
+            for (const index of it) {
+                if (
+                    (isInvisible || metadata?.[metadata?.[index]].tag === tag) &&
+                    changeTree.getChange(index) !== OPERATION.DELETE
+                ) {
+                    changes.set(index, OPERATION.ADD);
+                }
+            }
+        }
+
+        // TODO: avoid unnecessary iteration here
+        while (
+            changeTree.parent &&
+            (changeTree = changeTree.parent[$changes]) &&
+            (changeTree.isFiltered || changeTree.isPartiallyFiltered)
+        ) {
+            this.items.add(changeTree);
+        }
+
+        return this;
+    }
+
+    protected addParent(changeTree: ChangeTree, tag: number) {
+        const parentRef = changeTree.parent;
+        if (!parentRef) { return; }
+
+        const parentChangeTree = parentRef[$changes];
+        const parentIndex = changeTree.parentIndex;
+
+        if (!this.invisible.has(parentChangeTree)) {
+            // parent is already available, no need to add it!
+            return;
+        }
+
+        this.addParent(parentChangeTree, tag);
+
+        // add parent's tag properties
+        if (parentChangeTree.getChange(parentIndex) !== OPERATION.DELETE) {
+
+            let parentChanges = this.changes.get(parentChangeTree);
+            if (parentChanges === undefined) {
+                parentChanges = new Map<number, OPERATION>();
+                this.changes.set(parentChangeTree, parentChanges);
+            }
+
+            // console.log("add parent change", {
+            //     parentIndex,
+            //     parentChanges,
+            //     parentChange: (
+            //         parentChangeTree.getChange(parentIndex) &&
+            //         OPERATION[parentChangeTree.getChange(parentIndex)]
+            //     ),
+            // })
+
+            if (!this.tags) { this.tags = new WeakMap<ChangeTree, Set<number>>(); }
+            let tags: Set<number>;
+            if (!this.tags.has(parentChangeTree)) {
+                tags = new Set<number>();
+                this.tags.set(parentChangeTree, tags);
+            } else {
+                tags = this.tags.get(parentChangeTree);
+            }
+            tags.add(tag);
+
+            parentChanges.set(parentIndex, OPERATION.ADD);
+        }
+
+    }
+
+    remove(obj: Ref, tag: number = DEFAULT_VIEW_TAG) {
+        const changeTree = obj[$changes];
+        if (!changeTree) {
+            console.warn("StateView#remove(), invalid object:", obj);
+            return this;
+        }
+
+        this.items.delete(changeTree);
+
+        const ref = changeTree.ref;
+        const metadata: Metadata = ref.constructor[Symbol.metadata];
+
+        let changes = this.changes.get(changeTree);
+        if (changes === undefined) {
+            changes = new Map<number, OPERATION>();
+            this.changes.set(changeTree, changes)
+        }
+
+        if (tag === DEFAULT_VIEW_TAG) {
+            // parent is collection (Map/Array)
+            const parent = changeTree.parent;
+            if (!Metadata.isValidInstance(parent)) {
+                const parentChangeTree = parent[$changes];
+                let changes = this.changes.get(parentChangeTree);
+                if (changes === undefined) {
+                    changes = new Map<number, OPERATION>();
+                    this.changes.set(parentChangeTree, changes)
+                }
+                // DELETE / DELETE BY REF ID
+                changes.set(changeTree.parentIndex, OPERATION.DELETE);
+
+            } else {
+                // delete all "tagged" properties.
+                metadata[-2].forEach((index) =>
+                    changes.set(index, OPERATION.DELETE));
+            }
+
+
+        } else {
+            // delete only tagged properties
+            metadata[-3][tag].forEach((index) =>
+                changes.set(index, OPERATION.DELETE));
+        }
+
+        // remove tag
+        if (this.tags && this.tags.has(changeTree)) {
+            const tags = this.tags.get(changeTree);
+            if (tag === undefined) {
+                // delete all tags
+                this.tags.delete(changeTree);
+            } else {
+                // delete specific tag
+                tags.delete(tag);
+
+                // if tag set is empty, delete it entirely
+                if (tags.size === 0) {
+                    this.tags.delete(changeTree);
+                }
+            }
+        }
+
+        return this;
+    }
+}

package/src/encoding/assert.ts

@@ -0,0 +1,58 @@
+import { Schema } from "../Schema";
+import { CollectionSchema } from "../types/custom/CollectionSchema";
+import { MapSchema } from "../types/custom/MapSchema";
+import { SetSchema } from "../types/custom/SetSchema";
+import { ArraySchema } from "../types/custom/ArraySchema";
+
+export class EncodeSchemaError extends Error {}
+
+export function assertType(value: any, type: string, klass: Schema, field: string | number) {
+    let typeofTarget: string;
+    let allowNull: boolean = false;
+
+    switch (type) {
+        case "number":
+        case "int8":
+        case "uint8":
+        case "int16":
+        case "uint16":
+        case "int32":
+        case "uint32":
+        case "int64":
+        case "uint64":
+        case "float32":
+        case "float64":
+            typeofTarget = "number";
+            if (isNaN(value)) {
+                console.log(`trying to encode "NaN" in ${klass.constructor.name}#${field}`);
+            }
+            break;
+        case "string":
+            typeofTarget = "string";
+            allowNull = true;
+            break;
+        case "boolean":
+            // boolean is always encoded as true/false based on truthiness
+            return;
+    }
+
+    if (typeof (value) !== typeofTarget && (!allowNull || (allowNull && value !== null))) {
+        let foundValue = `'${JSON.stringify(value)}'${(value && value.constructor && ` (${value.constructor.name})`) || ''}`;
+        throw new EncodeSchemaError(`a '${typeofTarget}' was expected, but ${foundValue} was provided in ${klass.constructor.name}#${field}`);
+    }
+}
+
+export function assertInstanceType(
+    value: Schema,
+    type: typeof Schema
+        | typeof ArraySchema
+        | typeof MapSchema
+        | typeof CollectionSchema
+        | typeof SetSchema,
+    klass: Schema,
+    field: string | number,
+) {
+    if (!(value instanceof type)) {
+        throw new EncodeSchemaError(`a '${type.name}' was expected, but '${value && (value as any).constructor.name}' was provided in ${klass.constructor.name}#${field}`);
+    }
+}

package/src/encoding/decode.ts

@@ -21,7 +21,7 @@
  * SOFTWARE
  */
 
-import { SWITCH_TO_STRUCTURE } from "../spec";
+import { SWITCH_TO_STRUCTURE } from "./spec";
 
 /**
  * msgpack implementation highly based on notepack.io

package/src/encoding/encode.ts

@@ -21,11 +21,16 @@
  * SOFTWARE
  */
 
+import type { TextEncoder } from "util";
+
 /**
  * msgpack implementation highly based on notepack.io
  * https://github.com/darrachequesne/notepack
  */
 
+let textEncoder: TextEncoder;
+// @ts-ignore
+try { textEncoder = new TextEncoder(); } catch (e) { }
 
 function utf8Length(str) {
   var c = 0, length = 0;
@@ -48,89 +53,89 @@ function utf8Length(str) {
   return length;
 }
 
-export function utf8Write(view, offset, str) {
+export function utf8Write(view, str, it) {
   var c = 0;
   for (var i = 0, l = str.length; i < l; i++) {
     c = str.charCodeAt(i);
     if (c < 0x80) {
-      view[offset++] = c;
+      view[it.offset++] = c;
     }
     else if (c < 0x800) {
-      view[offset++] = 0xc0 | (c >> 6);
-      view[offset++] = 0x80 | (c & 0x3f);
+      view[it.offset++] = 0xc0 | (c >> 6);
+      view[it.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);
+      view[it.offset++] = 0xe0 | (c >> 12);
+      view[it.offset++] = 0x80 | (c >> 6 & 0x3f);
+      view[it.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);
+      view[it.offset++] = 0xf0 | (c >> 18);
+      view[it.offset++] = 0x80 | (c >> 12 & 0x3f);
+      view[it.offset++] = 0x80 | (c >> 6 & 0x3f);
+      view[it.offset++] = 0x80 | (c & 0x3f);
     }
   }
 }
 
-export function int8(bytes, value) {
-  bytes.push(value & 255);
+export function int8(bytes, value, it) {
+    bytes[it.offset++] = value & 255;
 };
 
-export function uint8(bytes, value) {
-  bytes.push(value & 255);
+export function uint8(bytes, value, it) {
+    bytes[it.offset++] = value & 255;
 };
 
-export function int16(bytes, value) {
-  bytes.push(value & 255);
-  bytes.push((value >> 8) & 255);
+export function int16(bytes, value, it) {
+    bytes[it.offset++] = value & 255;
+    bytes[it.offset++] = (value >> 8) & 255;
 };
 
-export function uint16(bytes, value) {
-  bytes.push(value & 255);
-  bytes.push((value >> 8) & 255);
+export function uint16(bytes, value, it) {
+    bytes[it.offset++] = value & 255;
+    bytes[it.offset++] = (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 int32(bytes, value, it) {
+  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) {
+export function uint32(bytes, value, it) {
   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);
+  bytes[it.offset++] = b1 & 255;
+  bytes[it.offset++] = b2 & 255;
+  bytes[it.offset++] = b3 & 255;
+  bytes[it.offset++] = b4 & 255;
 };
 
-export function int64(bytes, value) {
+export function int64(bytes, value, it) {
   const high = Math.floor(value / Math.pow(2, 32));
   const low = value >>> 0;
-  uint32(bytes, low);
-  uint32(bytes, high);
+  uint32(bytes, low, it);
+  uint32(bytes, high, it);
 };
 
-export function uint64(bytes, value) {
+export function uint64(bytes, value, it) {
   const high = (value / Math.pow(2, 32)) >> 0;
   const low = value >>> 0;
-  uint32(bytes, low);
-  uint32(bytes, high);
+  uint32(bytes, low, it);
+  uint32(bytes, high, it);
 };
 
-export function float32(bytes, value) {
-  writeFloat32(bytes, value);
+export function float32(bytes, value, it) {
+  writeFloat32(bytes, value, it);
 }
 
-export function float64(bytes, value) {
-  writeFloat64(bytes, value);
+export function float64(bytes, value, it) {
+  writeFloat64(bytes, value, it);
 }
 
 // force little endian to facilitate decoding on multiple implementations
@@ -139,69 +144,70 @@ const _int32 = new Int32Array(2);
 const _float32 = new Float32Array(_int32.buffer);
 const _float64 = new Float64Array(_int32.buffer);
 
-export function writeFloat32(bytes, value) {
+export function writeFloat32(bytes, value, it) {
   _float32[0] = value;
-  int32(bytes, _int32[0]);
+  int32(bytes, _int32[0], it);
 };
 
-export function writeFloat64(bytes, value) {
+export function writeFloat64(bytes, value, it) {
   _float64[0] = value;
-  int32(bytes, _int32[_isLittleEndian ? 0 : 1]);
-  int32(bytes, _int32[_isLittleEndian ? 1 : 0]);
+  int32(bytes, _int32[_isLittleEndian ? 0 : 1], it);
+  int32(bytes, _int32[_isLittleEndian ? 1 : 0], it);
 };
 
-export function boolean(bytes, value) {
-  return uint8(bytes, value ? 1 : 0);
+export function boolean(bytes, value, it) {
+  bytes[it.offset++] = value ? 1 : 0; // uint8
 };
 
-export function string(bytes, value) {
+export function string(bytes: Buffer, value, it) {
   // encode `null` strings as empty.
   if (!value) { value = ""; }
 
-  let length = utf8Length(value);
+  // let length = utf8Length(value);
+  let length = Buffer.byteLength(value, "utf8");
   let size = 0;
 
   // fixstr
   if (length < 0x20) {
-    bytes.push(length | 0xa0);
+    bytes[it.offset++] = length | 0xa0;
     size = 1;
   }
   // str 8
   else if (length < 0x100) {
-    bytes.push(0xd9);
-    uint8(bytes, length);
+    bytes[it.offset++] = 0xd9;
+    bytes[it.offset++] = length % 255;
     size = 2;
   }
   // str 16
   else if (length < 0x10000) {
-    bytes.push(0xda);
-    uint16(bytes, length);
+    bytes[it.offset++] = 0xda;
+    uint16(bytes, length, it);
     size = 3;
   }
   // str 32
   else if (length < 0x100000000) {
-    bytes.push(0xdb);
-    uint32(bytes, length);
+    bytes[it.offset++] = 0xdb;
+    uint32(bytes, length, it);
     size = 5;
   } else {
     throw new Error('String too long');
   }
 
-  utf8Write(bytes, bytes.length, value);
+  utf8Write(bytes, value, it);
 
   return size + length;
 }
 
-export function number(bytes, value) {
+export function number(bytes, value, it) {
   if (isNaN(value)) {
-    return number(bytes, 0);
+    return number(bytes, 0, it);
 
   } else if (!isFinite(value)) {
-    return number(bytes, (value > 0) ? Number.MAX_SAFE_INTEGER : -Number.MAX_SAFE_INTEGER);
+    return number(bytes, (value > 0) ? Number.MAX_SAFE_INTEGER : -Number.MAX_SAFE_INTEGER, it);
 
   } else if (value !== (value|0)) {
-    bytes.push(0xcb);
-    writeFloat64(bytes, value);
+    bytes[it.offset++] = 0xcb;
+    writeFloat64(bytes, value, it);
     return 9;
 
     // TODO: encode float 32?
@@ -216,68 +222,68 @@ export function number(bytes, value) {
   if (value >= 0) {
     // positive fixnum
     if (value < 0x80) {
-      uint8(bytes, value);
+      bytes[it.offset++] = value & 255; // uint8
       return 1;
     }
 
     // uint 8
     if (value < 0x100) {
-      bytes.push(0xcc);
-      uint8(bytes, value);
+      bytes[it.offset++] = 0xcc;
+      bytes[it.offset++] = value & 255; // uint8
       return 2;
     }
 
     // uint 16
     if (value < 0x10000) {
-      bytes.push(0xcd);
-      uint16(bytes, value);
+      bytes[it.offset++] = 0xcd;
+      uint16(bytes, value, it);
       return 3;
     }
 
     // uint 32
     if (value < 0x100000000) {
-      bytes.push(0xce);
-      uint32(bytes, value);
+      bytes[it.offset++] = 0xce;
+      uint32(bytes, value, it);
       return 5;
     }
 
     // uint 64
-    bytes.push(0xcf);
-    uint64(bytes, value);
+    bytes[it.offset++] = 0xcf;
+    uint64(bytes, value, it);
     return 9;
 
   } else {
 
     // negative fixnum
     if (value >= -0x20) {
-      bytes.push(0xe0 | (value + 0x20));
+      bytes[it.offset++] = 0xe0 | (value + 0x20);
       return 1;
     }
 
     // int 8
     if (value >= -0x80) {
-      bytes.push(0xd0);
-      int8(bytes, value);
+      bytes[it.offset++] = 0xd0;
+      int8(bytes, value, it);
       return 2;
     }
 
     // int 16
     if (value >= -0x8000) {
-      bytes.push(0xd1);
-      int16(bytes, value);
+      bytes[it.offset++] = 0xd1;
+      int16(bytes, value, it);
       return 3;
     }
 
     // int 32
     if (value >= -0x80000000) {
-      bytes.push(0xd2);
-      int32(bytes, value);
+      bytes[it.offset++] = 0xd2;
+      int32(bytes, value, it);
       return 5;
     }
 
     // int 64
-    bytes.push(0xd3);
-    int64(bytes, value);
+    bytes[it.offset++] = 0xd3;
+    int64(bytes, value, it);
     return 9;
   }
-}
+}

package/src/encoding/spec.ts

@@ -0,0 +1,29 @@
+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 = 128,            // (10000000) add new structure/primitive
+    REPLACE = 0,          // (00000001) replace structure/primitive
+    DELETE = 64,          // (01000000) delete field
+    DELETE_AND_MOVE = 96, // () add new structure/primitive
+    MOVE_AND_ADD = 160,   // () add new structure/primitive
+    DELETE_AND_ADD = 192, // (11000000) DELETE field, followed by an ADD
+
+    /**
+     * Collection operations
+     */
+    CLEAR = 10,
+
+    /**
+     * ArraySchema operations
+     */
+    PUSH = 11,
+    UNSHIFT = 12,
+    REVERSE = 15,
+    MOVE = 32,
+    DELETE_BY_REFID = 33, // This operation is only used at ENCODING time. During DECODING, DELETE_BY_REFID is converted to DELETE
+
+}