@colyseus/schema 1.0.45 → 1.0.46

package/lib/Schema.js

@@ -1,59 +1,23 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = void 0;
-var spec_1 = require("./spec");
-var annotations_1 = require("./annotations");
-var encode = require("./encoding/encode");
-var decode = require("./encoding/decode");
-var ArraySchema_1 = require("./types/ArraySchema");
-var MapSchema_1 = require("./types/MapSchema");
-var CollectionSchema_1 = require("./types/CollectionSchema");
-var SetSchema_1 = require("./types/SetSchema");
-var ChangeTree_1 = require("./changes/ChangeTree");
-var EventEmitter_1 = require("./events/EventEmitter");
-var filters_1 = require("./filters");
-var types_1 = require("./types");
-var EncodeSchemaError = /** @class */ (function (_super) {
-    __extends(EncodeSchemaError, _super);
-    function EncodeSchemaError() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return EncodeSchemaError;
-}(Error));
+const spec_1 = require("./spec");
+const annotations_1 = require("./annotations");
+const encode = require("./encoding/encode");
+const decode = require("./encoding/decode");
+const ArraySchema_1 = require("./types/ArraySchema");
+const MapSchema_1 = require("./types/MapSchema");
+const CollectionSchema_1 = require("./types/CollectionSchema");
+const SetSchema_1 = require("./types/SetSchema");
+const ChangeTree_1 = require("./changes/ChangeTree");
+const EventEmitter_1 = require("./events/EventEmitter");
+const filters_1 = require("./filters");
+const types_1 = require("./types");
+class EncodeSchemaError extends Error {
+}
 function assertType(value, type, klass, field) {
-    var typeofTarget;
-    var allowNull = false;
+    let typeofTarget;
+    let allowNull = false;
     switch (type) {
         case "number":
         case "int8":
@@ -68,7 +32,7 @@ function assertType(value, type, klass, field) {
         case "float64":
             typeofTarget = "number";
             if (isNaN(value)) {
-                console.log("trying to encode \"NaN\" in ".concat(klass.constructor.name, "#").concat(field));
+                console.log(`trying to encode "NaN" in ${klass.constructor.name}#${field}`);
             }
             break;
         case "string":
@@ -80,23 +44,23 @@ function assertType(value, type, klass, field) {
             return;
     }
     if (typeof (value) !== typeofTarget && (!allowNull || (allowNull && value !== null))) {
-        var foundValue = "'".concat(JSON.stringify(value), "'").concat((value && value.constructor && " (".concat(value.constructor.name, ")")) || '');
-        throw new EncodeSchemaError("a '".concat(typeofTarget, "' was expected, but ").concat(foundValue, " was provided in ").concat(klass.constructor.name, "#").concat(field));
+        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}`);
     }
 }
 function assertInstanceType(value, type, klass, field) {
     if (!(value instanceof type)) {
-        throw new EncodeSchemaError("a '".concat(type.name, "' was expected, but '").concat(value.constructor.name, "' was provided in ").concat(klass.constructor.name, "#").concat(field));
+        throw new EncodeSchemaError(`a '${type.name}' was expected, but '${value.constructor.name}' was provided in ${klass.constructor.name}#${field}`);
     }
 }
 function encodePrimitiveType(type, bytes, value, klass, field) {
     assertType(value, type, klass, field);
-    var encodeFunc = encode[type];
+    const encodeFunc = encode[type];
     if (encodeFunc) {
         encodeFunc(bytes, value);
     }
     else {
-        throw new EncodeSchemaError("a '".concat(type, "' was expected, but ").concat(value, " was provided in ").concat(klass.constructor.name, "#").concat(field));
+        throw new EncodeSchemaError(`a '${type}' was expected, but ${value} was provided in ${klass.constructor.name}#${field}`);
     }
 }
 function decodePrimitiveType(type, bytes, it) {
@@ -105,13 +69,17 @@ function decodePrimitiveType(type, bytes, it) {
 /**
  * Schema encoder / decoder
  */
-var Schema = /** @class */ (function () {
+class Schema {
+    static { this._definition = annotations_1.SchemaDefinition.create(); }
+    static onError(e) {
+        console.error(e);
+    }
+    static is(type) {
+        return (type['_definition'] &&
+            type['_definition'].schema !== undefined);
+    }
     // allow inherited classes to have a constructor
-    function Schema() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
+    constructor(...args) {
         // fix enumerability of fields for end-user
         Object.defineProperties(this, {
             $changes: {
@@ -125,7 +93,7 @@ var Schema = /** @class */ (function () {
                 writable: true
             },
         });
-        var descriptors = this._definition.descriptors;
+        const descriptors = this._definition.descriptors;
         if (descriptors) {
             Object.defineProperties(this, descriptors);
         }
@@ -136,53 +104,36 @@ var Schema = /** @class */ (function () {
             this.assign(args[0]);
         }
     }
-    Schema.onError = function (e) {
-        console.error(e);
-    };
-    Schema.is = function (type) {
-        return (type['_definition'] &&
-            type['_definition'].schema !== undefined);
-    };
-    Schema.prototype.assign = function (props) {
+    assign(props) {
         Object.assign(this, props);
         return this;
-    };
-    Object.defineProperty(Schema.prototype, "_definition", {
-        get: function () { return this.constructor._definition; },
-        enumerable: false,
-        configurable: true
-    });
-    Schema.prototype.listen = function (attr, callback) {
-        var _this = this;
+    }
+    get _definition() { return this.constructor._definition; }
+    listen(attr, callback) {
         if (!this.$listeners[attr]) {
             this.$listeners[attr] = new EventEmitter_1.EventEmitter_();
         }
         this.$listeners[attr].register(callback);
         // return un-register callback.
-        return function () {
-            return _this.$listeners[attr].remove(callback);
-        };
-    };
-    Schema.prototype.decode = function (bytes, it, ref, allChanges) {
-        if (it === void 0) { it = { offset: 0 }; }
-        if (ref === void 0) { ref = this; }
-        if (allChanges === void 0) { allChanges = new Map(); }
-        var $root = this.$changes.root;
-        var totalBytes = bytes.length;
-        var refId = 0;
-        var changes = [];
+        return () => this.$listeners[attr].remove(callback);
+    }
+    decode(bytes, it = { offset: 0 }, ref = this, allChanges = new Map()) {
+        const $root = this.$changes.root;
+        const totalBytes = bytes.length;
+        let refId = 0;
+        let changes = [];
         $root.refs.set(refId, this);
         allChanges.set(refId, changes);
         while (it.offset < totalBytes) {
-            var byte = bytes[it.offset++];
+            let byte = bytes[it.offset++];
             if (byte == spec_1.SWITCH_TO_STRUCTURE) {
                 refId = decode.number(bytes, it);
-                var nextRef = $root.refs.get(refId);
+                const nextRef = $root.refs.get(refId);
                 //
                 // Trying to access a reference that haven't been decoded yet.
                 //
                 if (!nextRef) {
-                    throw new Error("\"refId\" not found: ".concat(refId));
+                    throw new Error(`"refId" not found: ${refId}`);
                 }
                 ref = nextRef;
                 // create empty list of changes for this refId.
@@ -190,9 +141,9 @@ var Schema = /** @class */ (function () {
                 allChanges.set(refId, changes);
                 continue;
             }
-            var changeTree = ref['$changes'];
-            var isSchema = (ref['_definition'] !== undefined);
-            var operation = (isSchema)
+            const changeTree = ref['$changes'];
+            const isSchema = (ref['_definition'] !== undefined);
+            const operation = (isSchema)
                 ? (byte >> 6) << 6 // "compressed" index + operation
                 : byte; // "uncompressed" index + operation (array/map items)
             if (operation === spec_1.OPERATION.CLEAR) {
@@ -204,16 +155,16 @@ var Schema = /** @class */ (function () {
                 ref.clear(true);
                 continue;
             }
-            var fieldIndex = (isSchema)
+            const fieldIndex = (isSchema)
                 ? byte % (operation || 255) // if "REPLACE" operation (0), use 255
                 : decode.number(bytes, it);
-            var fieldName = (isSchema)
+            const fieldName = (isSchema)
                 ? (ref['_definition'].fieldsByIndex[fieldIndex])
                 : "";
-            var type = changeTree.getType(fieldIndex);
-            var value = void 0;
-            var previousValue = void 0;
-            var dynamicIndex = void 0;
+            let type = changeTree.getType(fieldIndex);
+            let value;
+            let previousValue;
+            let dynamicIndex;
             if (!isSchema) {
                 previousValue = ref['getByIndex'](fieldIndex);
                 if ((operation & spec_1.OPERATION.ADD) === spec_1.OPERATION.ADD) { // ADD or DELETE_AND_ADD
@@ -228,7 +179,7 @@ var Schema = /** @class */ (function () {
                 }
             }
             else {
-                previousValue = ref["_".concat(fieldName)];
+                previousValue = ref[`_${fieldName}`];
             }
             //
             // Delete operations
@@ -249,7 +200,7 @@ var Schema = /** @class */ (function () {
                 // keep skipping next bytes until reaches a known structure
                 // by local decoder.
                 //
-                var nextIterator = { offset: it.offset };
+                const nextIterator = { offset: it.offset };
                 while (it.offset < totalBytes) {
                     if (decode.switchStructureCheck(bytes, it)) {
                         nextIterator.offset = it.offset + 1;
@@ -268,24 +219,24 @@ var Schema = /** @class */ (function () {
                 //
             }
             else if (Schema.is(type)) {
-                var refId_1 = decode.number(bytes, it);
-                value = $root.refs.get(refId_1);
+                const refId = decode.number(bytes, it);
+                value = $root.refs.get(refId);
                 if (operation !== spec_1.OPERATION.REPLACE) {
-                    var childType = this.getSchemaType(bytes, it, type);
+                    const childType = this.getSchemaType(bytes, it, type);
                     if (!value) {
                         value = this.createTypeInstance(childType);
-                        value.$changes.refId = refId_1;
+                        value.$changes.refId = refId;
                         if (previousValue) {
                             value.onChange = previousValue.onChange;
                             value.onRemove = previousValue.onRemove;
                             value.$listeners = previousValue.$listeners;
                             if (previousValue['$changes'].refId &&
-                                refId_1 !== previousValue['$changes'].refId) {
+                                refId !== previousValue['$changes'].refId) {
                                 $root.removeRef(previousValue['$changes'].refId);
                             }
                         }
                     }
-                    $root.addRef(refId_1, value, (value !== previousValue));
+                    $root.addRef(refId, value, (value !== previousValue));
                 }
             }
             else if (typeof (type) === "string") {
@@ -295,40 +246,40 @@ var Schema = /** @class */ (function () {
                 value = decodePrimitiveType(type, bytes, it);
             }
             else {
-                var typeDef = (0, types_1.getType)(Object.keys(type)[0]);
-                var refId_2 = decode.number(bytes, it);
-                var valueRef = ($root.refs.has(refId_2))
-                    ? previousValue || $root.refs.get(refId_2)
+                const typeDef = (0, types_1.getType)(Object.keys(type)[0]);
+                const refId = decode.number(bytes, it);
+                const valueRef = ($root.refs.has(refId))
+                    ? previousValue || $root.refs.get(refId)
                     : new typeDef.constructor();
                 value = valueRef.clone(true);
-                value.$changes.refId = refId_2;
+                value.$changes.refId = refId;
                 // preserve schema callbacks
                 if (previousValue) {
                     value.onAdd = previousValue.onAdd;
                     value.onRemove = previousValue.onRemove;
                     value.onChange = previousValue.onChange;
                     if (previousValue['$changes'].refId &&
-                        refId_2 !== previousValue['$changes'].refId) {
+                        refId !== previousValue['$changes'].refId) {
                         $root.removeRef(previousValue['$changes'].refId);
                         //
                         // Trigger onRemove if structure has been replaced.
                         //
-                        var deletes = [];
-                        var entries = previousValue.entries();
-                        var iter = void 0;
+                        const deletes = [];
+                        const entries = previousValue.entries();
+                        let iter;
                         while ((iter = entries.next()) && !iter.done) {
-                            var _a = __read(iter.value, 2), key = _a[0], value_1 = _a[1];
+                            const [key, value] = iter.value;
                             deletes.push({
                                 op: spec_1.OPERATION.DELETE,
                                 field: key,
                                 value: undefined,
-                                previousValue: value_1,
+                                previousValue: value,
                             });
                         }
                         allChanges.set(previousValue['$changes'].refId, deletes);
                     }
                 }
-                $root.addRef(refId_2, value, (valueRef !== previousValue));
+                $root.addRef(refId, value, (valueRef !== previousValue));
                 //
                 // TODO: deprecate proxies on next version.
                 // get proxy to target value.
@@ -337,7 +288,7 @@ var Schema = /** @class */ (function () {
                     value = typeDef.getProxy(value);
                 }
             }
-            var hasChange = (previousValue !== value);
+            let hasChange = (previousValue !== value);
             if (value !== null &&
                 value !== undefined) {
                 if (value['$changes']) {
@@ -356,7 +307,7 @@ var Schema = /** @class */ (function () {
                 }
                 else if (ref instanceof MapSchema_1.MapSchema) {
                     // const key = ref['$indexes'].get(field);
-                    var key = dynamicIndex;
+                    const key = dynamicIndex;
                     // ref.set(key, value);
                     ref['$items'].set(key, value);
                     ref['$changes'].allChanges.add(fieldIndex);
@@ -368,11 +319,11 @@ var Schema = /** @class */ (function () {
                     ref.setAt(fieldIndex, value);
                 }
                 else if (ref instanceof CollectionSchema_1.CollectionSchema) {
-                    var index = ref.add(value);
+                    const index = ref.add(value);
                     ref['setIndex'](fieldIndex, index);
                 }
                 else if (ref instanceof SetSchema_1.SetSchema) {
-                    var index = ref.add(value);
+                    const index = ref.add(value);
                     if (index !== false) {
                         ref['setIndex'](fieldIndex, index);
                     }
@@ -387,9 +338,9 @@ var Schema = /** @class */ (function () {
                 changes.push({
                     op: operation,
                     field: fieldName,
-                    dynamicIndex: dynamicIndex,
-                    value: value,
-                    previousValue: previousValue,
+                    dynamicIndex,
+                    value,
+                    previousValue,
                 });
             }
         }
@@ -397,19 +348,16 @@ var Schema = /** @class */ (function () {
         // drop references of unused schemas
         $root.garbageCollectDeletedRefs();
         return allChanges;
-    };
-    Schema.prototype.encode = function (encodeAll, bytes, useFilters) {
-        if (encodeAll === void 0) { encodeAll = false; }
-        if (bytes === void 0) { bytes = []; }
-        if (useFilters === void 0) { useFilters = false; }
-        var rootChangeTree = this.$changes;
-        var refIdsVisited = new WeakSet();
-        var changeTrees = [rootChangeTree];
-        var numChangeTrees = 1;
-        for (var i = 0; i < numChangeTrees; i++) {
-            var changeTree = changeTrees[i];
-            var ref = changeTree.ref;
-            var isSchema = (ref instanceof Schema);
+    }
+    encode(encodeAll = false, bytes = [], useFilters = false) {
+        const rootChangeTree = this.$changes;
+        const refIdsVisited = new WeakSet();
+        const changeTrees = [rootChangeTree];
+        let numChangeTrees = 1;
+        for (let i = 0; i < numChangeTrees; i++) {
+            const changeTree = changeTrees[i];
+            const ref = changeTree.ref;
+            const isSchema = (ref instanceof Schema);
             // Generate unique refId for the ChangeTree.
             changeTree.ensureRefId();
             // mark this ChangeTree as visited.
@@ -420,19 +368,19 @@ var Schema = /** @class */ (function () {
                 encode.uint8(bytes, spec_1.SWITCH_TO_STRUCTURE);
                 encode.number(bytes, changeTree.refId);
             }
-            var changes = (encodeAll)
+            const changes = (encodeAll)
                 ? Array.from(changeTree.allChanges)
                 : Array.from(changeTree.changes.values());
-            for (var j = 0, cl = changes.length; j < cl; j++) {
-                var operation = (encodeAll)
+            for (let j = 0, cl = changes.length; j < cl; j++) {
+                const operation = (encodeAll)
                     ? { op: spec_1.OPERATION.ADD, index: changes[j] }
                     : changes[j];
-                var fieldIndex = operation.index;
-                var field = (isSchema)
+                const fieldIndex = operation.index;
+                const field = (isSchema)
                     ? ref['_definition'].fieldsByIndex && ref['_definition'].fieldsByIndex[fieldIndex]
                     : fieldIndex;
                 // cache begin index if `useFilters`
-                var beginIndex = bytes.length;
+                const beginIndex = bytes.length;
                 // encode field index + operation
                 if (operation.op !== spec_1.OPERATION.TOUCH) {
                     if (isSchema) {
@@ -462,7 +410,7 @@ var Schema = /** @class */ (function () {
                         //
                         // MapSchema dynamic key
                         //
-                        var dynamicIndex = changeTree.ref['$indexes'].get(fieldIndex);
+                        const dynamicIndex = changeTree.ref['$indexes'].get(fieldIndex);
                         encode.string(bytes, dynamicIndex);
                     }
                 }
@@ -476,9 +424,9 @@ var Schema = /** @class */ (function () {
                     continue;
                 }
                 // const type = changeTree.childType || ref._schema[field];
-                var type = changeTree.getType(fieldIndex);
+                const type = changeTree.getType(fieldIndex);
                 // const type = changeTree.getType(fieldIndex);
-                var value = changeTree.getValue(fieldIndex);
+                const value = changeTree.getValue(fieldIndex);
                 // Enqueue ChangeTree to be visited
                 if (value &&
                     value['$changes'] &&
@@ -512,11 +460,11 @@ var Schema = /** @class */ (function () {
                     //
                     // Custom type (MapSchema, ArraySchema, etc)
                     //
-                    var definition = (0, types_1.getType)(Object.keys(type)[0]);
+                    const definition = (0, types_1.getType)(Object.keys(type)[0]);
                     //
                     // ensure a ArraySchema has been provided
                     //
-                    assertInstanceType(ref["_".concat(field)], definition.constructor, ref, field);
+                    assertInstanceType(ref[`_${field}`], definition.constructor, ref, field);
                     //
                     // Encode refId for this instance.
                     // The actual instance is going to be encoded on next `changeTree` iteration.
@@ -533,38 +481,37 @@ var Schema = /** @class */ (function () {
             }
         }
         return bytes;
-    };
-    Schema.prototype.encodeAll = function (useFilters) {
+    }
+    encodeAll(useFilters) {
         return this.encode(true, [], useFilters);
-    };
-    Schema.prototype.applyFilters = function (client, encodeAll) {
-        var _a, _b;
-        if (encodeAll === void 0) { encodeAll = false; }
-        var root = this;
-        var refIdsDissallowed = new Set();
-        var $filterState = filters_1.ClientState.get(client);
-        var changeTrees = [this.$changes];
-        var numChangeTrees = 1;
-        var filteredBytes = [];
-        var _loop_1 = function (i) {
-            var changeTree = changeTrees[i];
+    }
+    applyFilters(client, encodeAll = false) {
+        const root = this;
+        const refIdsDissallowed = new Set();
+        const $filterState = filters_1.ClientState.get(client);
+        const changeTrees = [this.$changes];
+        let numChangeTrees = 1;
+        let filteredBytes = [];
+        for (let i = 0; i < numChangeTrees; i++) {
+            const changeTree = changeTrees[i];
             if (refIdsDissallowed.has(changeTree.refId)) {
-                return "continue";
+                // console.log("REFID IS NOT ALLOWED. SKIP.", { refId: changeTree.refId })
+                continue;
             }
-            var ref = changeTree.ref;
-            var isSchema = ref instanceof Schema;
+            const ref = changeTree.ref;
+            const isSchema = ref instanceof Schema;
             encode.uint8(filteredBytes, spec_1.SWITCH_TO_STRUCTURE);
             encode.number(filteredBytes, changeTree.refId);
-            var clientHasRefId = $filterState.refIds.has(changeTree);
-            var isEncodeAll = (encodeAll || !clientHasRefId);
+            const clientHasRefId = $filterState.refIds.has(changeTree);
+            const isEncodeAll = (encodeAll || !clientHasRefId);
             // console.log("REF:", ref.constructor.name);
             // console.log("Encode all?", isEncodeAll);
             //
             // include `changeTree` on list of known refIds by this client.
             //
             $filterState.addRefId(changeTree);
-            var containerIndexes = $filterState.containerIndexes.get(changeTree);
-            var changes = (isEncodeAll)
+            const containerIndexes = $filterState.containerIndexes.get(changeTree);
+            const changes = (isEncodeAll)
                 ? Array.from(changeTree.allChanges)
                 : Array.from(changeTree.changes.values());
             //
@@ -574,8 +521,8 @@ var Schema = /** @class */ (function () {
             if (!encodeAll &&
                 isSchema &&
                 ref._definition.indexesWithFilters) {
-                var indexesWithFilters = ref._definition.indexesWithFilters;
-                indexesWithFilters.forEach(function (indexWithFilter) {
+                const indexesWithFilters = ref._definition.indexesWithFilters;
+                indexesWithFilters.forEach(indexWithFilter => {
                     if (!containerIndexes.has(indexWithFilter) &&
                         changeTree.allChanges.has(indexWithFilter)) {
                         if (isEncodeAll) {
@@ -587,8 +534,8 @@ var Schema = /** @class */ (function () {
                     }
                 });
             }
-            for (var j = 0, cl = changes.length; j < cl; j++) {
-                var change = (isEncodeAll)
+            for (let j = 0, cl = changes.length; j < cl; j++) {
+                const change = (isEncodeAll)
                     ? { op: spec_1.OPERATION.ADD, index: changes[j] }
                     : changes[j];
                 // custom operations
@@ -596,7 +543,7 @@ var Schema = /** @class */ (function () {
                     encode.uint8(filteredBytes, change.op);
                     continue;
                 }
-                var fieldIndex = change.index;
+                const fieldIndex = change.index;
                 //
                 // Deleting fields: encode the operation + field index
                 //
@@ -617,11 +564,11 @@ var Schema = /** @class */ (function () {
                     continue;
                 }
                 // indexed operation
-                var value = changeTree.getValue(fieldIndex);
-                var type = changeTree.getType(fieldIndex);
+                const value = changeTree.getValue(fieldIndex);
+                const type = changeTree.getType(fieldIndex);
                 if (isSchema) {
                     // Is a Schema!
-                    var filter = (ref._definition.filters &&
+                    const filter = (ref._definition.filters &&
                         ref._definition.filters[fieldIndex]);
                     if (filter && !filter.call(ref, client, value, root)) {
                         if (value && value['$changes']) {
@@ -633,8 +580,8 @@ var Schema = /** @class */ (function () {
                 }
                 else {
                     // Is a collection! (map, array, etc.)
-                    var parent = changeTree.parent;
-                    var filter = changeTree.getChildrenFilter();
+                    const parent = changeTree.parent;
+                    const filter = changeTree.getChildrenFilter();
                     if (filter && !filter.call(parent, client, ref['$indexes'].get(fieldIndex), value, root)) {
                         if (value && value['$changes']) {
                             refIdsDissallowed.add(value['$changes'].refId);
@@ -658,7 +605,7 @@ var Schema = /** @class */ (function () {
                         //
                         // use cached bytes directly if is from Schema type.
                         //
-                        filteredBytes.push.apply(filteredBytes, (_a = changeTree.caches[fieldIndex]) !== null && _a !== void 0 ? _a : []);
+                        filteredBytes.push.apply(filteredBytes, changeTree.caches[fieldIndex] ?? []);
                         containerIndexes.add(fieldIndex);
                     }
                     else {
@@ -666,7 +613,7 @@ var Schema = /** @class */ (function () {
                             //
                             // use cached bytes if already has the field
                             //
-                            filteredBytes.push.apply(filteredBytes, (_b = changeTree.caches[fieldIndex]) !== null && _b !== void 0 ? _b : []);
+                            filteredBytes.push.apply(filteredBytes, changeTree.caches[fieldIndex] ?? []);
                         }
                         else {
                             //
@@ -679,7 +626,7 @@ var Schema = /** @class */ (function () {
                                 //
                                 // MapSchema dynamic key
                                 //
-                                var dynamicIndex = changeTree.ref['$indexes'].get(fieldIndex);
+                                const dynamicIndex = changeTree.ref['$indexes'].get(fieldIndex);
                                 encode.string(filteredBytes, dynamicIndex);
                             }
                             if (value['$changes']) {
@@ -706,26 +653,22 @@ var Schema = /** @class */ (function () {
                         //
                         // MapSchema dynamic key
                         //
-                        var dynamicIndex = changeTree.ref['$indexes'].get(fieldIndex);
+                        const dynamicIndex = changeTree.ref['$indexes'].get(fieldIndex);
                         encode.string(filteredBytes, dynamicIndex);
                     }
                     encode.number(filteredBytes, value['$changes'].refId);
                 }
             }
             ;
-        };
-        for (var i = 0; i < numChangeTrees; i++) {
-            _loop_1(i);
         }
         return filteredBytes;
-    };
-    Schema.prototype.clone = function () {
-        var _a;
-        var cloned = new (this.constructor);
-        var schema = this._definition.schema;
-        for (var field in schema) {
+    }
+    clone() {
+        const cloned = new (this.constructor);
+        const schema = this._definition.schema;
+        for (let field in schema) {
             if (typeof (this[field]) === "object" &&
-                typeof ((_a = this[field]) === null || _a === void 0 ? void 0 : _a.clone) === "function") {
+                typeof (this[field]?.clone) === "function") {
                 // deep clone
                 cloned[field] = this[field].clone();
             }
@@ -735,13 +678,13 @@ var Schema = /** @class */ (function () {
             }
         }
         return cloned;
-    };
-    Schema.prototype.triggerAll = function () {
+    }
+    triggerAll() {
         // skip if haven't received any remote refs yet.
         if (this.$changes.root.refs.size === 0) {
             return;
         }
-        var allChanges = new Map();
+        const allChanges = new Map();
         Schema.prototype._triggerAllFillChanges.call(this, this, allChanges);
         try {
             Schema.prototype._triggerChanges.call(this, allChanges);
@@ -749,65 +692,65 @@ var Schema = /** @class */ (function () {
         catch (e) {
             Schema.onError(e);
         }
-    };
-    Schema.prototype.toJSON = function () {
-        var schema = this._definition.schema;
-        var deprecated = this._definition.deprecated;
-        var obj = {};
-        for (var field in schema) {
+    }
+    toJSON() {
+        const schema = this._definition.schema;
+        const deprecated = this._definition.deprecated;
+        const obj = {};
+        for (let field in schema) {
             if (!deprecated[field] && this[field] !== null && typeof (this[field]) !== "undefined") {
                 obj[field] = (typeof (this[field]['toJSON']) === "function")
                     ? this[field]['toJSON']()
-                    : this["_".concat(field)];
+                    : this[`_${field}`];
             }
         }
         return obj;
-    };
-    Schema.prototype.discardAllChanges = function () {
+    }
+    discardAllChanges() {
         this.$changes.discardAll();
-    };
-    Schema.prototype.getByIndex = function (index) {
+    }
+    getByIndex(index) {
         return this[this._definition.fieldsByIndex[index]];
-    };
-    Schema.prototype.deleteByIndex = function (index) {
+    }
+    deleteByIndex(index) {
         this[this._definition.fieldsByIndex[index]] = undefined;
-    };
-    Schema.prototype.tryEncodeTypeId = function (bytes, type, targetType) {
+    }
+    tryEncodeTypeId(bytes, type, targetType) {
         if (type._typeid !== targetType._typeid) {
             encode.uint8(bytes, spec_1.TYPE_ID);
             encode.number(bytes, targetType._typeid);
         }
-    };
-    Schema.prototype.getSchemaType = function (bytes, it, defaultType) {
-        var type;
+    }
+    getSchemaType(bytes, it, defaultType) {
+        let type;
         if (bytes[it.offset] === spec_1.TYPE_ID) {
             it.offset++;
             type = this.constructor._context.get(decode.number(bytes, it));
         }
         return type || defaultType;
-    };
-    Schema.prototype.createTypeInstance = function (type) {
-        var instance = new type();
+    }
+    createTypeInstance(type) {
+        let instance = new type();
         // assign root on $changes
         instance.$changes.root = this.$changes.root;
         return instance;
-    };
-    Schema.prototype._triggerAllFillChanges = function (ref, allChanges) {
+    }
+    _triggerAllFillChanges(ref, allChanges) {
         if (allChanges.has(ref['$changes'].refId)) {
             return;
         }
-        var changes = [];
+        const changes = [];
         allChanges.set(ref['$changes'].refId || 0, changes);
         if (ref instanceof Schema) {
-            var schema = ref._definition.schema;
-            for (var fieldName in schema) {
-                var _field = "_".concat(fieldName);
-                var value = ref[_field];
+            const schema = ref._definition.schema;
+            for (let fieldName in schema) {
+                const _field = `_${fieldName}`;
+                const value = ref[_field];
                 if (value !== undefined) {
                     changes.push({
                         op: spec_1.OPERATION.ADD,
                         field: fieldName,
-                        value: value,
+                        value,
                         previousValue: undefined
                     });
                     if (value['$changes'] !== undefined) {
@@ -817,10 +760,10 @@ var Schema = /** @class */ (function () {
             }
         }
         else {
-            var entries = ref.entries();
-            var iter = void 0;
+            const entries = ref.entries();
+            let iter;
             while ((iter = entries.next()) && !iter.done) {
-                var _a = __read(iter.value, 2), key = _a[0], value = _a[1];
+                const [key, value] = iter.value;
                 changes.push({
                     op: spec_1.OPERATION.ADD,
                     field: key,
@@ -833,20 +776,18 @@ var Schema = /** @class */ (function () {
                 }
             }
         }
-    };
-    Schema.prototype._triggerChanges = function (allChanges) {
-        var _this = this;
-        allChanges.forEach(function (changes, refId) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    }
+    _triggerChanges(allChanges) {
+        allChanges.forEach((changes, refId) => {
             if (changes.length > 0) {
-                var ref = _this.$changes.root.refs.get(refId);
-                var isSchema = ref instanceof Schema;
-                for (var i = 0; i < changes.length; i++) {
-                    var change = changes[i];
-                    var listener = ref['$listeners'] && ref['$listeners'][change.field];
+                const ref = this.$changes.root.refs.get(refId);
+                const isSchema = ref instanceof Schema;
+                for (let i = 0; i < changes.length; i++) {
+                    const change = changes[i];
+                    const listener = ref['$listeners'] && ref['$listeners'][change.field];
                     if (!isSchema) {
                         if (change.op === spec_1.OPERATION.ADD && change.previousValue === undefined) {
-                            (_b = (_a = ref).onAdd) === null || _b === void 0 ? void 0 : _b.call(_a, change.value, (_c = change.dynamicIndex) !== null && _c !== void 0 ? _c : change.field);
+                            ref.onAdd?.(change.value, change.dynamicIndex ?? change.field);
                         }
                         else if (change.op === spec_1.OPERATION.DELETE) {
                             //
@@ -854,18 +795,18 @@ var Schema = /** @class */ (function () {
                             // ADD + DELETE operations are still encoding DELETE operation.
                             //
                             if (change.previousValue !== undefined) {
-                                (_e = (_d = ref).onRemove) === null || _e === void 0 ? void 0 : _e.call(_d, change.previousValue, (_f = change.dynamicIndex) !== null && _f !== void 0 ? _f : change.field);
+                                ref.onRemove?.(change.previousValue, change.dynamicIndex ?? change.field);
                             }
                         }
                         else if (change.op === spec_1.OPERATION.DELETE_AND_ADD) {
                             if (change.previousValue !== undefined) {
-                                (_h = (_g = ref).onRemove) === null || _h === void 0 ? void 0 : _h.call(_g, change.previousValue, change.dynamicIndex);
+                                ref.onRemove?.(change.previousValue, change.dynamicIndex);
                             }
-                            (_k = (_j = ref).onAdd) === null || _k === void 0 ? void 0 : _k.call(_j, change.value, change.dynamicIndex);
+                            ref.onAdd?.(change.value, change.dynamicIndex);
                         }
                         else if (change.op === spec_1.OPERATION.REPLACE ||
                             change.value !== change.previousValue) {
-                            (_m = (_l = ref).onChange) === null || _m === void 0 ? void 0 : _m.call(_l, change.value, change.dynamicIndex);
+                            ref.onChange?.(change.value, change.dynamicIndex);
                         }
                     }
                     //
@@ -897,9 +838,7 @@ var Schema = /** @class */ (function () {
                 }
             }
         });
-    };
-    Schema._definition = annotations_1.SchemaDefinition.create();
-    return Schema;
-}());
+    }
+}
 exports.Schema = Schema;
 //# sourceMappingURL=Schema.js.map