@colyseus/schema 3.0.0-alpha.9 → 3.0.0

package/src/encoder/Root.ts

@@ -0,0 +1,93 @@
+import { OPERATION } from "../encoding/spec";
+import { TypeContext } from "../types/TypeContext";
+import { spliceOne } from "../types/utils";
+import { ChangeTree, setOperationAtIndex } from "./ChangeTree";
+
+export class Root {
+    protected nextUniqueId: number = 0;
+
+    refCount: {[id: number]: number} = {};
+    changeTrees: {[refId: number]: ChangeTree} = {};
+
+    // all changes
+    allChanges: ChangeTree[] = [];
+    allFilteredChanges: ChangeTree[] = [];// TODO: do not initialize it if filters are not used
+
+    // pending changes to be encoded
+    changes: ChangeTree[] = [];
+    filteredChanges: ChangeTree[] = [];// TODO: do not initialize it if filters are not used
+
+    constructor(public types: TypeContext) { }
+
+    getNextUniqueId() {
+        return this.nextUniqueId++;
+    }
+
+    add(changeTree: ChangeTree) {
+        // FIXME: move implementation of `ensureRefId` to `Root` class
+        changeTree.ensureRefId();
+
+        const isNewChangeTree = (this.changeTrees[changeTree.refId] === undefined);
+        if (isNewChangeTree) { this.changeTrees[changeTree.refId] = changeTree; }
+
+        const previousRefCount = this.refCount[changeTree.refId];
+        if (previousRefCount === 0) {
+            //
+            // When a ChangeTree is re-added, it means that it was previously removed.
+            // We need to re-add all changes to the `changes` map.
+            //
+            const ops = changeTree.allChanges.operations;
+            let len = ops.length;
+            while (len--) {
+                changeTree.indexedOperations[ops[len]] = OPERATION.ADD;
+                setOperationAtIndex(changeTree.changes, len);
+            }
+        }
+
+        this.refCount[changeTree.refId] = (previousRefCount || 0) + 1;
+
+        return isNewChangeTree;
+    }
+
+    remove(changeTree: ChangeTree) {
+        const refCount = (this.refCount[changeTree.refId]) - 1;
+
+        if (refCount <= 0) {
+            //
+            // Only remove "root" reference if it's the last reference
+            //
+            changeTree.root = undefined;
+            delete this.changeTrees[changeTree.refId];
+
+            this.removeChangeFromChangeSet("allChanges", changeTree);
+            this.removeChangeFromChangeSet("changes", changeTree);
+
+            if (changeTree.filteredChanges) {
+                this.removeChangeFromChangeSet("allFilteredChanges", changeTree);
+                this.removeChangeFromChangeSet("filteredChanges", changeTree);
+            }
+
+            this.refCount[changeTree.refId] = 0;
+
+        } else {
+            this.refCount[changeTree.refId] = refCount;
+        }
+
+        changeTree.forEachChild((child, _) => this.remove(child));
+
+        return refCount;
+    }
+
+    removeChangeFromChangeSet(changeSetName: "allChanges" | "changes" | "filteredChanges" | "allFilteredChanges", changeTree: ChangeTree) {
+        const changeSet = this[changeSetName];
+        const index = changeSet.indexOf(changeTree);
+        if (index !== -1) {
+            spliceOne(changeSet, index);
+            // changeSet[index] = undefined;
+        }
+    }
+
+    clear() {
+        this.changes.length = 0;
+    }
+}

package/src/encoder/StateView.ts

@@ -1,11 +1,11 @@
-import { ChangeTree, Ref } from "./ChangeTree";
-import { $changes } from "../types/symbols";
+import { ChangeSet, ChangeTree, IndexedOperations, Ref } from "./ChangeTree";
+import { $changes, $fieldIndexesByViewTag, $viewFieldIndexes } from "../types/symbols";
 import { DEFAULT_VIEW_TAG } from "../annotations";
 import { OPERATION } from "../encoding/spec";
 import { Metadata } from "../Metadata";
-import type { Schema } from "../Schema";
 
-export function createView(root: Schema) {
+export function createView() {
+    return new StateView();
 }
 
 export class StateView {
@@ -25,37 +25,35 @@ export class StateView {
      * 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>>();
+    changes: { [refId: number]: IndexedOperations } = {};
 
     // TODO: allow to set multiple tags at once
-    add(obj: Ref, tag: number = DEFAULT_VIEW_TAG) {
+    add(obj: Ref, tag: number = DEFAULT_VIEW_TAG, checkIncludeParent: boolean = true) {
         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
+        // FIXME: ArraySchema/MapSchema do not have metadata
         const metadata: Metadata = obj.constructor[Symbol.metadata];
+        const changeTree: ChangeTree = obj[$changes];
+        this.items.add(changeTree);
 
-        // add parent ChangeTree's, if they are invisible to this view
-        // TODO: REFACTOR addParent()
-        this.addParent(changeTree, tag);
+        // add parent ChangeTree's
+        // - if it was invisible to this view
+        // - if it were previously filtered out
+        if (checkIncludeParent && changeTree.parent) {
+            this.addParent(changeTree.parent[$changes], changeTree.parentIndex, 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);
+        let changes = this.changes[changeTree.refId];
         if (changes === undefined) {
-            changes = new Map<number, OPERATION>();
-            this.changes.set(changeTree, changes)
+            changes = {};
+            this.changes[changeTree.refId] = changes;
         }
 
         // set tag
@@ -72,99 +70,93 @@ export class StateView {
             }
             tags.add(tag);
 
-            // console.log("BY TAG:", tag);
-
             // Ref: add tagged properties
-            metadata?.[-3]?.[tag]?.forEach((index) => {
+            metadata?.[$fieldIndexesByViewTag]?.[tag]?.forEach((index) => {
                 if (changeTree.getChange(index) !== OPERATION.DELETE) {
-                    changes.set(index, OPERATION.ADD)
+                    changes[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)
+            const isInvisible = this.invisible.has(changeTree);
+            const changeSet = (changeTree.filteredChanges !== undefined)
                 ? changeTree.allFilteredChanges
                 : changeTree.allChanges;
-            const it = allChangesSet.keys();
-            const isInvisible = this.invisible.has(changeTree);
 
-            for (const index of it) {
+            for (let i = 0, len = changeSet.operations.length; i < len; i++) {
+                const index = changeSet.operations[i];
+                if (index === undefined) { continue; } // skip "undefined" indexes
+
+                const op = changeTree.indexedOperations[index] ?? OPERATION.ADD;
+                const tagAtIndex = metadata?.[index].tag;
                 if (
-                    (isInvisible || metadata?.[metadata?.[index]].tag === tag) &&
-                    changeTree.getChange(index) !== OPERATION.DELETE
+                    (
+                        isInvisible || // if "invisible", include all
+                        tagAtIndex === undefined || // "all change" with no tag
+                        tagAtIndex === tag // tagged property
+                    ) &&
+                    op !== OPERATION.DELETE
                 ) {
-                    changes.set(index, OPERATION.ADD);
+                    changes[index] = op;
                 }
             }
         }
 
-        // TODO: avoid unnecessary iteration here
-        while (
-            changeTree.parent &&
-            (changeTree = changeTree.parent[$changes]) &&
-            (changeTree.isFiltered || changeTree.isPartiallyFiltered)
-        ) {
-            this.items.add(changeTree);
-        }
+        // Add children of this ChangeTree to this view
+        changeTree.forEachChild((change, index) => {
+            // Do not ADD children that don't have the same tag
+            if (
+                metadata &&
+                metadata[index].tag !== undefined &&
+                metadata[index].tag !== tag
+            ) {
+                return;
+            }
+            this.add(change.ref, tag, false);
+        });
 
         return this;
     }
 
-    protected addParent(changeTree: ChangeTree, tag: number) {
-        const parentRef = changeTree.parent;
-        if (!parentRef) { return; }
+    protected addParent(changeTree: ChangeTree, parentIndex: number, tag: number) {
+        // view must have all "changeTree" parent tree
+        this.items.add(changeTree);
 
-        const parentChangeTree = parentRef[$changes];
-        const parentIndex = changeTree.parentIndex;
+        // add parent's parent
+        const parentChangeTree: ChangeTree = changeTree.parent?.[$changes];
+        if (parentChangeTree && (parentChangeTree.filteredChanges !== undefined)) {
+            this.addParent(parentChangeTree, changeTree.parentIndex, tag);
+        }
 
-        if (!this.invisible.has(parentChangeTree)) {
-            // parent is already available, no need to add it!
+        // parent is already available, no need to add it!
+        if (!this.invisible.has(changeTree)) {
             return;
         }
 
-        this.addParent(parentChangeTree, tag);
-
         // add parent's tag properties
-        if (parentChangeTree.getChange(parentIndex) !== OPERATION.DELETE) {
+        if (changeTree.getChange(parentIndex) !== OPERATION.DELETE) {
 
-            let parentChanges = this.changes.get(parentChangeTree);
-            if (parentChanges === undefined) {
-                parentChanges = new Map<number, OPERATION>();
-                this.changes.set(parentChangeTree, parentChanges);
+            let changes = this.changes[changeTree.refId];
+            if (changes === undefined) {
+                changes = {};
+                this.changes[changeTree.refId] = changes;
             }
 
-            // 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>>();
+            }
 
-            if (!this.tags) { this.tags = new WeakMap<ChangeTree, Set<number>>(); }
             let tags: Set<number>;
-            if (!this.tags.has(parentChangeTree)) {
+            if (!this.tags.has(changeTree)) {
                 tags = new Set<number>();
-                this.tags.set(parentChangeTree, tags);
+                this.tags.set(changeTree, tags);
             } else {
-                tags = this.tags.get(parentChangeTree);
+                tags = this.tags.get(changeTree);
             }
             tags.add(tag);
 
-            parentChanges.set(parentIndex, OPERATION.ADD);
+            changes[parentIndex] = OPERATION.ADD;
         }
-
     }
 
     remove(obj: Ref, tag: number = DEFAULT_VIEW_TAG) {
@@ -179,10 +171,10 @@ export class StateView {
         const ref = changeTree.ref;
         const metadata: Metadata = ref.constructor[Symbol.metadata];
 
-        let changes = this.changes.get(changeTree);
+        let changes = this.changes[changeTree.refId];
         if (changes === undefined) {
-            changes = new Map<number, OPERATION>();
-            this.changes.set(changeTree, changes)
+            changes = {};
+            this.changes[changeTree.refId] = changes;
         }
 
         if (tag === DEFAULT_VIEW_TAG) {
@@ -190,25 +182,25 @@ export class StateView {
             const parent = changeTree.parent;
             if (!Metadata.isValidInstance(parent)) {
                 const parentChangeTree = parent[$changes];
-                let changes = this.changes.get(parentChangeTree);
+                let changes = this.changes[parentChangeTree.refId];
                 if (changes === undefined) {
-                    changes = new Map<number, OPERATION>();
-                    this.changes.set(parentChangeTree, changes)
+                    changes = {};
+                    this.changes[parentChangeTree.refId] = changes;
                 }
                 // DELETE / DELETE BY REF ID
-                changes.set(changeTree.parentIndex, OPERATION.DELETE);
+                changes[changeTree.parentIndex] = OPERATION.DELETE;
 
             } else {
                 // delete all "tagged" properties.
-                metadata[-2].forEach((index) =>
-                    changes.set(index, OPERATION.DELETE));
+                metadata[$viewFieldIndexes].forEach((index) =>
+                    changes[index] = OPERATION.DELETE);
             }
 
 
         } else {
             // delete only tagged properties
-            metadata[-3][tag].forEach((index) =>
-                changes.set(index, OPERATION.DELETE));
+            metadata[$fieldIndexesByViewTag][tag].forEach((index) =>
+                changes[index] = OPERATION.DELETE);
         }
 
         // remove tag

package/src/encoding/assert.ts

@@ -1,8 +1,9 @@
-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";
+import type { Schema } from "../Schema";
+import type { CollectionSchema } from "../types/custom/CollectionSchema";
+import type { MapSchema } from "../types/custom/MapSchema";
+import type { SetSchema } from "../types/custom/SetSchema";
+import type { ArraySchema } from "../types/custom/ArraySchema";
+import type { Ref } from "../encoder/ChangeTree";
 
 export class EncodeSchemaError extends Error {}
 
@@ -27,6 +28,10 @@ export function assertType(value: any, type: string, klass: Schema, field: strin
                 console.log(`trying to encode "NaN" in ${klass.constructor.name}#${field}`);
             }
             break;
+        case "bigint64":
+        case "biguint64":
+            typeofTarget = "bigint";
+            break;
         case "string":
             typeofTarget = "string";
             allowNull = true;
@@ -34,6 +39,10 @@ export function assertType(value: any, type: string, klass: Schema, field: strin
         case "boolean":
             // boolean is always encoded as true/false based on truthiness
             return;
+        default:
+            // skip assertion for custom types
+            // TODO: allow custom types to define their own assertions
+            return;
     }
 
     if (typeof (value) !== typeofTarget && (!allowNull || (allowNull && value !== null))) {
@@ -43,16 +52,16 @@ export function assertType(value: any, type: string, klass: Schema, field: strin
 }
 
 export function assertInstanceType(
-    value: Schema,
+    value: Ref,
     type: typeof Schema
         | typeof ArraySchema
         | typeof MapSchema
         | typeof CollectionSchema
         | typeof SetSchema,
-    klass: Schema,
+    instance: Ref,
     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}`);
+        throw new EncodeSchemaError(`a '${type.name}' was expected, but '${value && (value as any).constructor.name}' was provided in ${instance.constructor.name}#${field}`);
     }
 }

package/src/encoding/decode.ts

@@ -21,7 +21,6 @@
  * SOFTWARE
  */
 
-import { SWITCH_TO_STRUCTURE } from "./spec";
 import type { BufferLike } from "./encode";
 
 /**
@@ -31,7 +30,17 @@ import type { BufferLike } from "./encode";
 
 export interface Iterator { offset: number; }
 
-export function utf8Read(bytes: BufferLike, it: Iterator, length: number) {
+// force little endian to facilitate decoding on multiple implementations
+const _isLittleEndian = true;  // new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
+const _convoBuffer = new ArrayBuffer(8);
+
+const _int32 = new Int32Array(_convoBuffer);
+const _float32 = new Float32Array(_convoBuffer);
+const _float64 = new Float64Array(_convoBuffer);
+const _uint64 = new BigUint64Array(_convoBuffer);
+const _int64 = new BigInt64Array(_convoBuffer);
+
+function utf8Read(bytes: BufferLike, it: Iterator, length: number) {
   var string = '', chr = 0;
   for (var i = it.offset, end = it.offset + length; i < end; i++) {
     var byte = bytes[i];
@@ -76,72 +85,70 @@ export function utf8Read(bytes: BufferLike, it: Iterator, length: number) {
   return string;
 }
 
-export function int8 (bytes: BufferLike, it: Iterator) {
+function int8 (bytes: BufferLike, it: Iterator) {
     return uint8(bytes, it) << 24 >> 24;
 };
 
-export function uint8 (bytes: BufferLike, it: Iterator) {
+function uint8 (bytes: BufferLike, it: Iterator) {
     return bytes[it.offset++];
 };
 
-export function int16 (bytes: BufferLike, it: Iterator) {
+function int16 (bytes: BufferLike, it: Iterator) {
     return uint16(bytes, it) << 16 >> 16;
 };
 
-export function uint16 (bytes: BufferLike, it: Iterator) {
+function uint16 (bytes: BufferLike, it: Iterator) {
     return bytes[it.offset++] | bytes[it.offset++] << 8;
 };
 
-export function int32 (bytes: BufferLike, it: Iterator) {
+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: BufferLike, it: Iterator) {
+function uint32 (bytes: BufferLike, it: Iterator) {
     return int32(bytes, it) >>> 0;
 };
 
-export function float32(bytes: BufferLike, it: Iterator) {
-  return readFloat32(bytes, it);
-}
+function float32 (bytes: BufferLike, it: Iterator) {
+    _int32[0] = int32(bytes, it);
+    return _float32[0];
+};
 
-export function float64(bytes: BufferLike, it: Iterator) {
-  return readFloat64(bytes, it);
-}
+function float64 (bytes: BufferLike, it: Iterator) {
+    _int32[_isLittleEndian ? 0 : 1] = int32(bytes, it);
+    _int32[_isLittleEndian ? 1 : 0] = int32(bytes, it);
+    return _float64[0];
+};
 
-export function int64(bytes: BufferLike, it: Iterator) {
+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: BufferLike, it: Iterator) {
-  const low = uint32(bytes, it);
-  const high = uint32(bytes, it) * Math.pow(2, 32);
-  return high + low;
+function uint64(bytes: BufferLike, 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: BufferLike, it: Iterator) {
+function bigint64(bytes: BufferLike, it: Iterator) {
     _int32[0] = int32(bytes, it);
-    return _float32[0];
-};
+    _int32[1] = int32(bytes, it);
+    return _int64[0];
+}
 
-export function readFloat64 (bytes: BufferLike, it: Iterator) {
-    _int32[_isLittleEndian ? 0 : 1] = int32(bytes, it);
-    _int32[_isLittleEndian ? 1 : 0] = int32(bytes, it);
-    return _float64[0];
-};
+function biguint64(bytes: BufferLike, it: Iterator) {
+    _int32[0] = int32(bytes, it);
+    _int32[1] = int32(bytes, it);
+    return _uint64[0];
+}
 
-export function boolean (bytes: BufferLike, it: Iterator) {
+function boolean (bytes: BufferLike, it: Iterator) {
     return uint8(bytes, it) > 0;
 };
 
-export function string (bytes: BufferLike, it: Iterator) {
+function string (bytes: BufferLike, it: Iterator) {
   const prefix = bytes[it.offset++];
   let length: number;
 
@@ -162,21 +169,7 @@ export function string (bytes: BufferLike, it: Iterator) {
   return utf8Read(bytes, it, length);
 }
 
-export function stringCheck(bytes: BufferLike, 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: BufferLike, it: Iterator) {
+function number (bytes: BufferLike, it: Iterator) {
   const prefix = bytes[it.offset++];
 
   if (prefix < 0x80) {
@@ -185,11 +178,11 @@ export function number (bytes: BufferLike, it: Iterator) {
 
   } else if (prefix === 0xca) {
     // float 32
-    return readFloat32(bytes, it);
+    return float32(bytes, it);
 
   } else if (prefix === 0xcb) {
     // float 64
-    return readFloat64(bytes, it);
+    return float64(bytes, it);
 
   } else if (prefix === 0xcc) {
     // uint 8
@@ -229,49 +222,36 @@ export function number (bytes: BufferLike, it: Iterator) {
   }
 };
 
-export function numberCheck (bytes: BufferLike, it: Iterator) {
+export function stringCheck(bytes: BufferLike, 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)
+    // fixstr
+    (prefix < 0xc0 && prefix > 0xa0) ||
+    // str 8
+    prefix === 0xd9 ||
+    // str 16
+    prefix === 0xda ||
+    // str 32
+    prefix === 0xdb
   );
 }
 
-export function arrayCheck (bytes: BufferLike, 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: BufferLike, 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))
-  );
-}
+export const decode = {
+    utf8Read,
+    int8,
+    uint8,
+    int16,
+    uint16,
+    int32,
+    uint32,
+    float32,
+    float64,
+    int64,
+    uint64,
+    bigint64,
+    biguint64,
+    boolean,
+    string,
+    number,
+    stringCheck,
+};