@colyseus/schema 3.0.0-alpha.1 → 3.0.0-alpha.11

package/build/esm/index.mjs

@@ -164,7 +164,6 @@ class Root {
         // pending changes to be encoded
         this.changes = new Map();
         this.filteredChanges = new Map();
-        this.views = [];
     }
     getNextUniqueId() {
         return this.nextUniqueId++;
@@ -259,14 +258,12 @@ class ChangeTree {
         this.checkIsFiltered(parent, parentIndex);
         if (!this.isFiltered) {
             this.root.changes.set(this, this.changes);
+            this.root.allChanges.set(this, this.allChanges);
         }
         if (this.isFiltered || this.isPartiallyFiltered) {
             this.root.filteredChanges.set(this, this.filteredChanges);
             this.root.allFilteredChanges.set(this, this.filteredChanges);
         }
-        else {
-            this.root.allChanges.set(this, this.allChanges);
-        }
         this.ensureRefId();
         this.forEachChild((changeTree, atIndex) => {
             changeTree.setParent(this.ref, root, atIndex);
@@ -358,7 +355,6 @@ class ChangeTree {
     }
     _shiftAllChangeIndexes(shiftIndex, startIndex = 0, allChangeSet) {
         Array.from(allChangeSet.entries()).forEach(([index, op]) => {
-            // console.log('shiftAllChangeIndexes', index >= startIndex, { index, op, shiftIndex, startIndex })
             if (index >= startIndex) {
                 allChangeSet.delete(index);
                 allChangeSet.set(index + shiftIndex, op);
@@ -499,7 +495,7 @@ class ChangeTree {
     }
     checkIsFiltered(parent, parentIndex) {
         // Detect if current structure has "filters" declared
-        this.isPartiallyFiltered = this.ref['constructor']?.[Symbol.metadata]?.[-2];
+        this.isPartiallyFiltered = (this.ref['constructor']?.[Symbol.metadata]?.[-2] !== undefined);
         // TODO: support "partially filtered", where the instance is visible, but only a field is not.
         // Detect if parent has "filters" declared
         while (parent && !this.isFiltered) {
@@ -560,6 +556,29 @@ try {
     textEncoder = new TextEncoder();
 }
 catch (e) { }
+const hasBufferByteLength = (typeof Buffer !== 'undefined' && Buffer.byteLength);
+const utf8Length = (hasBufferByteLength)
+    ? Buffer.byteLength // node
+    : function (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;
+    };
 function utf8Write(view, str, it) {
     var c = 0;
     for (var i = 0, l = str.length; i < l; i++) {
@@ -654,8 +673,7 @@ function string$1(bytes, value, it) {
     if (!value) {
         value = "";
     }
-    // let length = utf8Length(value);
-    let length = Buffer.byteLength(value, "utf8");
+    let length = utf8Length(value, "utf8");
     let size = 0;
     // fixstr
     if (length < 0x20) {
@@ -766,6 +784,7 @@ function number$1(bytes, value, it) {
 
 var encode = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    utf8Length: utf8Length,
     utf8Write: utf8Write,
     int8: int8$1,
     uint8: uint8$1,
@@ -923,6 +942,18 @@ const encodeKeyValueOperation = function (encoder, bytes, changeTree, field, ope
     }
     const type = changeTree.getType(field);
     const value = changeTree.getValue(field);
+    // try { throw new Error(); } catch (e) {
+    //     // only print if not coming from Reflection.ts
+    //     if (!e.stack.includes("src/Reflection.ts")) {
+    //         console.log("encodeKeyValueOperation -> ", {
+    //             ref: changeTree.ref.constructor.name,
+    //             field,
+    //             operation: OPERATION[operation],
+    //             value: value?.toJSON(),
+    //             items: ref.toJSON(),
+    //         });
+    //     }
+    // }
     // TODO: inline this function call small performance gain
     encodeValue(encoder, bytes, ref, type, value, field, operation, it);
 };
@@ -989,9 +1020,9 @@ const encodeArray = function (encoder, bytes, changeTree, field, operation, it,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE
  */
-function utf8Read(bytes, offset, length) {
+function utf8Read(bytes, it, length) {
     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);
@@ -1026,6 +1057,7 @@ 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;
 }
 function int8(bytes, it) {
@@ -1093,9 +1125,7 @@ function string(bytes, it) {
     else if (prefix === 0xdb) {
         length = uint32(bytes, it);
     }
-    const value = utf8Read(bytes, it.offset, length);
-    it.offset += length;
-    return value;
+    return utf8Read(bytes, it, length);
 }
 function stringCheck(bytes, it) {
     const prefix = bytes[it.offset];
@@ -1199,6 +1229,7 @@ function switchStructureCheck(bytes, it) {
 
 var decode = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    utf8Read: utf8Read,
     int8: int8,
     uint8: uint8,
     int16: int16,
@@ -1222,7 +1253,7 @@ var decode = /*#__PURE__*/Object.freeze({
 
 const DEFINITION_MISMATCH = -1;
 function decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges) {
-    const $root = decoder.$root;
+    const $root = decoder.root;
     const previousValue = ref[$getByIndex](index);
     let value;
     if ((operation & OPERATION.DELETE) === OPERATION.DELETE) {
@@ -1422,7 +1453,7 @@ const decodeArray = function (decoder, bytes, it, ref, allChanges) {
     else if (operation === OPERATION.DELETE_BY_REFID) {
         // TODO: refactor here, try to follow same flow as below
         const refId = number(bytes, it);
-        const previousValue = decoder.$root.refs.get(refId);
+        const previousValue = decoder.root.refs.get(refId);
         const index = ref.findIndex((value) => value === previousValue);
         ref[$deleteByIndex](index);
         allChanges.push({
@@ -3358,13 +3389,13 @@ class Encoder {
         // });
     }
     setRoot(state) {
-        this.$root = new Root();
+        this.root = new Root();
         this.state = state;
-        state[$changes].setRoot(this.$root);
+        state[$changes].setRoot(this.root);
     }
-    encode(it = { offset: 0 }, view, bytes = this.sharedBuffer, changeTrees = this.$root.changes) {
+    encode(it = { offset: 0 }, view, buffer = this.sharedBuffer, changeTrees = this.root.changes) {
         const initialOffset = it.offset; // cache current offset in case we need to resize the buffer
-        const isEncodeAll = this.$root.allChanges === changeTrees;
+        const isEncodeAll = this.root.allChanges === changeTrees;
         const hasView = (view !== undefined);
         const rootChangeTree = this.state[$changes];
         const changeTreesIterator = changeTrees.entries();
@@ -3373,6 +3404,12 @@ class Encoder {
             const ctor = ref['constructor'];
             const encoder = ctor[$encoder];
             const filter = ctor[$filter];
+            // try { throw new Error(); } catch (e) {
+            //     // only print if not coming from Reflection.ts
+            //     if (!e.stack.includes("src/Reflection.ts")) {
+            //         console.log("ChangeTree:", { ref: ref.constructor.name, });
+            //     }
+            // }
             if (hasView) {
                 if (!view.items.has(changeTree)) {
                     view.invisible.add(changeTree);
@@ -3384,8 +3421,8 @@ class Encoder {
             }
             // skip root `refId` if it's the first change tree
             if (it.offset !== initialOffset || changeTree !== rootChangeTree) {
-                bytes[it.offset++] = SWITCH_TO_STRUCTURE & 255;
-                number$1(bytes, changeTree.refId, it);
+                buffer[it.offset++] = SWITCH_TO_STRUCTURE & 255;
+                number$1(buffer, changeTree.refId, it);
             }
             const changesIterator = changes.entries();
             for (const [fieldIndex, operation] of changesIterator) {
@@ -3402,22 +3439,31 @@ class Encoder {
                     // view?.invisible.add(changeTree);
                     continue;
                 }
-                // console.log("WILL ENCODE", {
-                //     ref: changeTree.ref.constructor.name,
-                //     fieldIndex,
-                //     operation: OPERATION[operation],
-                // });
-                encoder(this, bytes, changeTree, fieldIndex, operation, it, isEncodeAll, hasView);
+                // try { throw new Error(); } catch (e) {
+                //     // only print if not coming from Reflection.ts
+                //     if (!e.stack.includes("src/Reflection.ts")) {
+                //         // console.log("WILL ENCODE", {
+                //         //     ref: changeTree.ref.constructor.name,
+                //         //     fieldIndex,
+                //         //     operation: OPERATION[operation],
+                //         // });
+                //     }
+                // }
+                encoder(this, buffer, changeTree, fieldIndex, operation, it, isEncodeAll, hasView);
             }
         }
-        if (it.offset > bytes.byteLength) {
-            const newSize = getNextPowerOf2(this.sharedBuffer.byteLength * 2);
-            console.warn("@colyseus/schema encode buffer overflow. Current buffer size: " + bytes.byteLength + ", encoding offset: " + it.offset + ", new size: " + newSize);
+        if (it.offset > buffer.byteLength) {
+            const newSize = getNextPowerOf2(buffer.byteLength * 2);
+            console.warn("@colyseus/schema encode buffer overflow. Current buffer size: " + buffer.byteLength + ", encoding offset: " + it.offset + ", new size: " + newSize);
             //
             // resize buffer and re-encode (TODO: can we avoid re-encoding here?)
             //
-            this.sharedBuffer = Buffer.allocUnsafeSlow(newSize);
-            return this.encode({ offset: initialOffset }, view);
+            buffer = Buffer.allocUnsafeSlow(newSize);
+            // assign resized buffer to local sharedBuffer
+            if (buffer === this.sharedBuffer) {
+                this.sharedBuffer = buffer;
+            }
+            return this.encode({ offset: initialOffset }, view, buffer);
         }
         else {
             //
@@ -3429,42 +3475,41 @@ class Encoder {
                 //
                 this.onEndEncode(changeTrees);
             }
-            // return bytes;
-            return bytes.slice(0, it.offset);
+            return buffer.subarray(0, it.offset);
         }
     }
-    encodeAll(it = { offset: 0 }) {
-        // console.log(`encodeAll(), this.$root.allChanges (${this.$root.allChanges.size})`);
-        // Array.from(this.$root.allChanges.entries()).map((item) => {
-        //     console.log("->", item[0].refId, item[0].ref.toJSON());
+    encodeAll(it = { offset: 0 }, buffer = this.sharedBuffer) {
+        // console.log(`encodeAll(), this.root.allChanges (${this.root.allChanges.size})`);
+        // Array.from(this.root.allChanges.entries()).map((item) => {
+        //     console.log("->", { ref: item[0].ref.constructor.name, refId: item[0].refId, changes: item[1].size });
         // });
-        return this.encode(it, undefined, this.sharedBuffer, this.$root.allChanges);
+        return this.encode(it, undefined, buffer, this.root.allChanges);
     }
     encodeAllView(view, sharedOffset, it, bytes = this.sharedBuffer) {
         const viewOffset = it.offset;
-        // console.log(`encodeAllView(), this.$root.allFilteredChanges (${this.$root.allFilteredChanges.size})`);
+        // console.log(`encodeAllView(), this.root.allFilteredChanges (${this.root.allFilteredChanges.size})`);
         // this.debugAllFilteredChanges();
         // try to encode "filtered" changes
-        this.encode(it, view, bytes, this.$root.allFilteredChanges);
+        this.encode(it, view, bytes, this.root.allFilteredChanges);
         return Buffer.concat([
-            bytes.slice(0, sharedOffset),
-            bytes.slice(viewOffset, it.offset)
+            bytes.subarray(0, sharedOffset),
+            bytes.subarray(viewOffset, it.offset)
         ]);
     }
-    // debugAllFilteredChanges() {
-    //     Array.from(this.$root.allFilteredChanges.entries()).map((item) => {
-    //         console.log("->", { refId: item[0].refId }, item[0].ref.toJSON());
-    //         if (Array.isArray(item[0].ref.toJSON())) {
-    //             item[1].forEach((op, key) => {
-    //                 console.log("  ->", { key, op: OPERATION[op] });
-    //             })
-    //         }
-    //     });
-    // }
+    debugAllFilteredChanges() {
+        Array.from(this.root.allFilteredChanges.entries()).map((item) => {
+            console.log("->", { refId: item[0].refId, changes: item[1].size }, item[0].ref.toJSON());
+            if (Array.isArray(item[0].ref.toJSON())) {
+                item[1].forEach((op, key) => {
+                    console.log("  ->", { key, op: OPERATION[op] });
+                });
+            }
+        });
+    }
     encodeView(view, sharedOffset, it, bytes = this.sharedBuffer) {
         const viewOffset = it.offset;
         // try to encode "filtered" changes
-        this.encode(it, view, bytes, this.$root.filteredChanges);
+        this.encode(it, view, bytes, this.root.filteredChanges);
         // encode visibility changes (add/remove for this view)
         const viewChangesIterator = view.changes.entries();
         for (const [changeTree, changes] of viewChangesIterator) {
@@ -3492,11 +3537,11 @@ class Encoder {
         // clear "view" changes after encoding
         view.changes.clear();
         return Buffer.concat([
-            bytes.slice(0, sharedOffset),
-            bytes.slice(viewOffset, it.offset)
+            bytes.subarray(0, sharedOffset),
+            bytes.subarray(viewOffset, it.offset)
         ]);
     }
-    onEndEncode(changeTrees = this.$root.changes) {
+    onEndEncode(changeTrees = this.root.changes) {
         const changeTreesIterator = changeTrees.entries();
         for (const [changeTree, _] of changeTreesIterator) {
             changeTree.endEncode();
@@ -3504,14 +3549,14 @@ class Encoder {
     }
     discardChanges() {
         // discard shared changes
-        if (this.$root.changes.size > 0) {
-            this.onEndEncode(this.$root.changes);
-            this.$root.changes.clear();
+        if (this.root.changes.size > 0) {
+            this.onEndEncode(this.root.changes);
+            this.root.changes.clear();
         }
         // discard filtered changes
-        if (this.$root.filteredChanges.size > 0) {
-            this.onEndEncode(this.$root.filteredChanges);
-            this.$root.filteredChanges.clear();
+        if (this.root.filteredChanges.size > 0) {
+            this.onEndEncode(this.root.filteredChanges);
+            this.root.filteredChanges.clear();
         }
     }
     tryEncodeTypeId(bytes, baseType, targetType, it) {
@@ -3672,12 +3717,12 @@ class Decoder {
     }
     setRoot(root) {
         this.state = root;
-        this.$root = new ReferenceTracker();
-        this.$root.addRef(0, root);
+        this.root = new ReferenceTracker();
+        this.root.addRef(0, root);
     }
     decode(bytes, it = { offset: 0 }, ref = this.state) {
         const allChanges = [];
-        const $root = this.$root;
+        const $root = this.root;
         const totalBytes = bytes.byteLength;
         let decoder = ref['constructor'][$decoder];
         this.currentRefId = 0;
@@ -3758,7 +3803,7 @@ class Decoder {
                 previousValue: value
             });
             if (needRemoveRef) {
-                this.$root.removeRef(this.$root.refIds.get(value));
+                this.root.removeRef(this.root.refIds.get(value));
             }
         });
     }
@@ -3798,7 +3843,7 @@ class Reflection extends Schema {
         super(...arguments);
         this.types = new ArraySchema();
     }
-    static encode(instance, context) {
+    static encode(instance, context, it = { offset: 0 }) {
         if (!context) {
             context = new TypeContext(instance.constructor);
         }
@@ -3855,7 +3900,6 @@ class Reflection extends Schema {
             }
             buildType(type, klass[Symbol.metadata]);
         }
-        const it = { offset: 0 };
         const buf = encoder.encodeAll(it);
         return Buffer.from(buf, 0, it.offset);
     }