@colyseus/schema 1.1.0-alpha.1 → 2.0.2

package/build/umd/index.js

@@ -87,76 +87,6 @@
     //     CLEAR = 10,
     // }
 
-    //
-    // Root holds all schema references by unique id
-    //
-    var Root = /** @class */ (function () {
-        function Root() {
-            //
-            // Relation of refId => Schema structure
-            // For direct access of structures during decoding time.
-            //
-            this.refs = new Map();
-            this.refCounts = {};
-            this.deletedRefs = new Set();
-            this.nextUniqueId = 0;
-        }
-        Root.prototype.getNextUniqueId = function () {
-            return this.nextUniqueId++;
-        };
-        // for decoding
-        Root.prototype.addRef = function (refId, ref, incrementCount) {
-            if (incrementCount === void 0) { incrementCount = true; }
-            this.refs.set(refId, ref);
-            if (incrementCount) {
-                this.refCounts[refId] = (this.refCounts[refId] || 0) + 1;
-            }
-        };
-        // for decoding
-        Root.prototype.removeRef = function (refId) {
-            this.refCounts[refId] = this.refCounts[refId] - 1;
-            this.deletedRefs.add(refId);
-        };
-        Root.prototype.clearRefs = function () {
-            this.refs.clear();
-            this.deletedRefs.clear();
-            this.refCounts = {};
-        };
-        // for decoding
-        Root.prototype.garbageCollectDeletedRefs = function () {
-            var _this = this;
-            this.deletedRefs.forEach(function (refId) {
-                if (_this.refCounts[refId] <= 0) {
-                    var ref = _this.refs.get(refId);
-                    //
-                    // Ensure child schema instances have their references removed as well.
-                    //
-                    if (ref instanceof Schema) {
-                        for (var fieldName in ref['_definition'].schema) {
-                            if (typeof (ref['_definition'].schema[fieldName]) !== "string" &&
-                                ref[fieldName] &&
-                                ref[fieldName]['$changes']) {
-                                _this.removeRef(ref[fieldName]['$changes'].refId);
-                            }
-                        }
-                    }
-                    else {
-                        var definition = ref['$changes'].parent._definition;
-                        var type = definition.schema[definition.fieldsByIndex[ref['$changes'].parentIndex]];
-                        if (typeof (Object.values(type)[0]) === "function") {
-                            Array.from(ref.values())
-                                .forEach(function (child) { return _this.removeRef(child['$changes'].refId); });
-                        }
-                    }
-                    _this.refs.delete(refId);
-                    delete _this.refCounts[refId];
-                }
-            });
-            // clear deleted refs.
-            this.deletedRefs.clear();
-        };
-        return Root;
-    }());
     var ChangeTree = /** @class */ (function () {
         function ChangeTree(ref, parent, root) {
             this.changed = false;
@@ -360,13 +290,49 @@
         return ChangeTree;
     }());
 
-    //
-    // Notes:
-    // -----
-    //
-    // - The tsconfig.json of @colyseus/schema uses ES2018.
-    // - ES2019 introduces `flatMap` / `flat`, which is not currently relevant, and caused other issues.
-    //
+    function addCallback($callbacks, op, callback, existing) {
+        // initialize list of callbacks
+        if (!$callbacks[op]) {
+            $callbacks[op] = [];
+        }
+        $callbacks[op].push(callback);
+        //
+        // Trigger callback for existing elements
+        // - OPERATION.ADD
+        // - OPERATION.REPLACE
+        //
+        existing === null || existing === void 0 ? void 0 : existing.forEach(function (item, key) { return callback(item, key); });
+        return function () { return spliceOne($callbacks[op], $callbacks[op].indexOf(callback)); };
+    }
+    function removeChildRefs(changes) {
+        var _this = this;
+        var needRemoveRef = (typeof (this.$changes.getType()) !== "string");
+        this.$items.forEach(function (item, key) {
+            changes.push({
+                refId: _this.$changes.refId,
+                op: exports.OPERATION.DELETE,
+                field: key,
+                value: undefined,
+                previousValue: item
+            });
+            if (needRemoveRef) {
+                _this.$changes.root.removeRef(item['$changes'].refId);
+            }
+        });
+    }
+    function spliceOne(arr, index) {
+        // manually splice an array
+        if (index === -1 || index >= arr.length) {
+            return false;
+        }
+        var len = arr.length - 1;
+        for (var i = index; i < len; i++) {
+            arr[i] = arr[i + 1];
+        }
+        arr.length = len;
+        return true;
+    }
+
     var DEFAULT_SORT = function (a, b) {
         var A = a.toString();
         var B = b.toString();
@@ -437,8 +403,20 @@
             this.$refId = 0;
             this.push.apply(this, items);
         }
+        ArraySchema.prototype.onAdd = function (callback, triggerAll) {
+            if (triggerAll === void 0) { triggerAll = true; }
+            return addCallback((this.$callbacks || (this.$callbacks = [])), exports.OPERATION.ADD, callback, (triggerAll)
+                ? this.$items
+                : undefined);
+        };
+        ArraySchema.prototype.onRemove = function (callback) { return addCallback(this.$callbacks || (this.$callbacks = []), exports.OPERATION.DELETE, callback); };
+        ArraySchema.prototype.onChange = function (callback) { return addCallback(this.$callbacks || (this.$callbacks = []), exports.OPERATION.REPLACE, callback); };
         ArraySchema.is = function (type) {
-            return Array.isArray(type);
+            return (
+            // type format: ["string"]
+            Array.isArray(type) ||
+                // type format: { array: "string" }
+                (type['array'] !== undefined));
         };
         Object.defineProperty(ArraySchema.prototype, "length", {
             get: function () {
@@ -514,18 +492,19 @@
             this.$indexes.delete(index);
             return this.$items.delete(index);
         };
-        ArraySchema.prototype.clear = function (isDecoding) {
-            var _this = this;
+        ArraySchema.prototype.clear = function (changes) {
             // discard previous operations.
             this.$changes.discard(true, true);
             this.$changes.indexes = {};
             // clear previous indexes
             this.$indexes.clear();
-            // flag child items for garbage collection.
-            if (isDecoding && typeof (this.$changes.getType()) !== "string") {
-                this.$items.forEach(function (item) {
-                    _this.$changes.root.removeRef(item['$changes'].refId);
-                });
+            //
+            // When decoding:
+            // - enqueue items for DELETE callback.
+            // - flag child items for garbage collection.
+            //
+            if (changes) {
+                removeChildRefs.call(this, changes);
             }
             // clear items
             this.$items.clear();
@@ -876,9 +855,6 @@
             }
             return cloned;
         };
-        ArraySchema.prototype.triggerAll = function () {
-            Schema.prototype.triggerAll.apply(this);
-        };
         return ArraySchema;
     }());
 
@@ -932,6 +908,14 @@
                 }
             }
         }
+        MapSchema.prototype.onAdd = function (callback, triggerAll) {
+            if (triggerAll === void 0) { triggerAll = true; }
+            return addCallback((this.$callbacks || (this.$callbacks = [])), exports.OPERATION.ADD, callback, (triggerAll)
+                ? this.$items
+                : undefined);
+        };
+        MapSchema.prototype.onRemove = function (callback) { return addCallback(this.$callbacks || (this.$callbacks = []), exports.OPERATION.DELETE, callback); };
+        MapSchema.prototype.onChange = function (callback) { return addCallback(this.$callbacks || (this.$callbacks = []), exports.OPERATION.REPLACE, callback); };
         MapSchema.is = function (type) {
             return type['map'] !== undefined;
         };
@@ -943,6 +927,9 @@
             configurable: true
         });
         MapSchema.prototype.set = function (key, value) {
+            if (value === undefined || value === null) {
+                throw new Error("MapSchema#set('" + key + "', " + value + "): trying to set " + value + " value on '" + key + "'.");
+            }
             // get "index" for this value.
             var hasIndex = typeof (this.$changes.indexes[key]) !== "undefined";
             var index = (hasIndex)
@@ -986,18 +973,19 @@
             this.$changes.delete(key);
             return this.$items.delete(key);
         };
-        MapSchema.prototype.clear = function (isDecoding) {
-            var _this = this;
+        MapSchema.prototype.clear = function (changes) {
             // discard previous operations.
             this.$changes.discard(true, true);
             this.$changes.indexes = {};
             // clear previous indexes
             this.$indexes.clear();
-            // flag child items for garbage collection.
-            if (isDecoding && typeof (this.$changes.getType()) !== "string") {
-                this.$items.forEach(function (item) {
-                    _this.$changes.root.removeRef(item['$changes'].refId);
-                });
+            //
+            // When decoding:
+            // - enqueue items for DELETE callback.
+            // - flag child items for garbage collection.
+            //
+            if (changes) {
+                removeChildRefs.call(this, changes);
             }
             // clear items
             this.$items.clear();
@@ -1073,9 +1061,6 @@
             }
             return cloned;
         };
-        MapSchema.prototype.triggerAll = function () {
-            Schema.prototype.triggerAll.apply(this);
-        };
         return MapSchema;
     }());
 
@@ -1115,6 +1100,9 @@
                 ? { array: type[0] }
                 : type;
         };
+        SchemaDefinition.prototype.hasField = function (field) {
+            return this.indexes[field] !== undefined;
+        };
         SchemaDefinition.prototype.addFilter = function (field, cb) {
             if (!this.filters) {
                 this.filters = {};
@@ -1170,23 +1158,43 @@
             this.types[typeid] = schema;
             this.schemas.set(schema, typeid);
         };
-        Context.create = function (context) {
-            if (context === void 0) { context = new Context; }
+        Context.create = function (options) {
+            if (options === void 0) { options = {}; }
             return function (definition) {
-                return type(definition, context);
+                if (!options.context) {
+                    options.context = new Context();
+                }
+                return type(definition, options);
             };
         };
         return Context;
     }());
     var globalContext = new Context();
     /**
-     * `@type()` decorator for proxies
+     * [See documentation](https://docs.colyseus.io/state/schema/)
+     *
+     * Annotate a Schema property to be serializeable.
+     * \@type()'d fields are automatically flagged as "dirty" for the next patch.
+     *
+     * @example Standard usage, with automatic change tracking.
+     * ```
+     * \@type("string") propertyName: string;
+     * ```
+     *
+     * @example You can provide the "manual" option if you'd like to manually control your patches via .setDirty().
+     * ```
+     * \@type("string", { manual: true })
+     * ```
      */
-    function type(type, context) {
-        if (context === void 0) { context = globalContext; }
+    function type(type, options) {
+        if (options === void 0) { options = {}; }
         return function (target, field) {
+            var context = options.context || globalContext;
             var constructor = target.constructor;
             constructor._context = context;
+            if (!type) {
+                throw new Error(constructor.name + ": @type() reference provided for \"" + field + "\" is undefined. Make sure you don't have any circular dependencies.");
+            }
             /*
              * static schema
              */
@@ -1199,7 +1207,21 @@
              * skip if descriptor already exists for this field (`@deprecated()`)
              */
             if (definition.descriptors[field]) {
-                return;
+                if (definition.deprecated[field]) {
+                    // do not create accessors for deprecated properties.
+                    return;
+                }
+                else {
+                    // trying to define same property multiple times across inheritance.
+                    // https://github.com/colyseus/colyseus-unity3d/issues/131#issuecomment-814308572
+                    try {
+                        throw new Error("@colyseus/schema: Duplicate '" + field + "' definition on '" + constructor.name + "'.\nCheck @type() annotation");
+                    }
+                    catch (e) {
+                        var definitionAtLine = e.stack.split("\n")[4].trim();
+                        throw new Error(e.message + " " + definitionAtLine);
+                    }
+                }
             }
             var isArray = ArraySchema.is(type);
             var isMap = !isArray && MapSchema.is(type);
@@ -1212,6 +1234,15 @@
                     context.add(childType);
                 }
             }
+            if (options.manual) {
+                // do not declare getter/setter descriptor
+                definition.descriptors[field] = {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                };
+                return;
+            }
             var fieldCached = "_" + field;
             definition.descriptors[fieldCached] = {
                 enumerable: false,
@@ -1297,7 +1328,7 @@
      * `@deprecated()` flag a field as deprecated.
      * The previous `@type()` annotation should remain along with this one.
      */
-    function deprecated(throws, context) {
+    function deprecated(throws) {
         if (throws === void 0) { throws = true; }
         return function (target, field) {
             var constructor = target.constructor;
@@ -1313,10 +1344,13 @@
             }
         };
     }
-    function defineTypes(target, fields, context) {
-        if (context === void 0) { context = target._context || globalContext; }
+    function defineTypes(target, fields, options) {
+        if (options === void 0) { options = {}; }
+        if (!options.context) {
+            options.context = target._context || options.context || globalContext;
+        }
         for (var field in fields) {
-            type(fields[field], context)(target.prototype, field);
+            type(fields[field], options)(target.prototype, field);
         }
         return target;
     }
@@ -1854,6 +1888,14 @@
                 initialValues.forEach(function (v) { return _this.add(v); });
             }
         }
+        CollectionSchema.prototype.onAdd = function (callback, triggerAll) {
+            if (triggerAll === void 0) { triggerAll = true; }
+            return addCallback((this.$callbacks || (this.$callbacks = [])), exports.OPERATION.ADD, callback, (triggerAll)
+                ? this.$items
+                : undefined);
+        };
+        CollectionSchema.prototype.onRemove = function (callback) { return addCallback(this.$callbacks || (this.$callbacks = []), exports.OPERATION.DELETE, callback); };
+        CollectionSchema.prototype.onChange = function (callback) { return addCallback(this.$callbacks || (this.$callbacks = []), exports.OPERATION.REPLACE, callback); };
         CollectionSchema.is = function (type) {
             return type['collection'] !== undefined;
         };
@@ -1897,18 +1939,19 @@
             this.$indexes.delete(index);
             return this.$items.delete(index);
         };
-        CollectionSchema.prototype.clear = function (isDecoding) {
-            var _this = this;
+        CollectionSchema.prototype.clear = function (changes) {
             // discard previous operations.
             this.$changes.discard(true, true);
             this.$changes.indexes = {};
             // clear previous indexes
             this.$indexes.clear();
-            // flag child items for garbage collection.
-            if (isDecoding && typeof (this.$changes.getType()) !== "string") {
-                this.$items.forEach(function (item) {
-                    _this.$changes.root.removeRef(item['$changes'].refId);
-                });
+            //
+            // When decoding:
+            // - enqueue items for DELETE callback.
+            // - flag child items for garbage collection.
+            //
+            if (changes) {
+                removeChildRefs.call(this, changes);
             }
             // clear items
             this.$items.clear();
@@ -1982,9 +2025,6 @@
             }
             return cloned;
         };
-        CollectionSchema.prototype.triggerAll = function () {
-            Schema.prototype.triggerAll.apply(this);
-        };
         return CollectionSchema;
     }());
 
@@ -1999,23 +2039,33 @@
                 initialValues.forEach(function (v) { return _this.add(v); });
             }
         }
+        SetSchema.prototype.onAdd = function (callback, triggerAll) {
+            if (triggerAll === void 0) { triggerAll = true; }
+            return addCallback((this.$callbacks || (this.$callbacks = [])), exports.OPERATION.ADD, callback, (triggerAll)
+                ? this.$items
+                : undefined);
+        };
+        SetSchema.prototype.onRemove = function (callback) { return addCallback(this.$callbacks || (this.$callbacks = []), exports.OPERATION.DELETE, callback); };
+        SetSchema.prototype.onChange = function (callback) { return addCallback(this.$callbacks || (this.$callbacks = []), exports.OPERATION.REPLACE, callback); };
         SetSchema.is = function (type) {
             return type['set'] !== undefined;
         };
         SetSchema.prototype.add = function (value) {
+            var _a, _b;
+            // immediatelly return false if value already added.
             if (this.has(value)) {
                 return false;
             }
             // set "index" for reference.
             var index = this.$refId++;
-            var isRef = (value['$changes']) !== undefined;
-            if (isRef) {
+            if ((value['$changes']) !== undefined) {
                 value['$changes'].setParent(this, this.$changes.root, index);
             }
+            var operation = (_b = (_a = this.$changes.indexes[index]) === null || _a === void 0 ? void 0 : _a.op) !== null && _b !== void 0 ? _b : exports.OPERATION.ADD;
             this.$changes.indexes[index] = index;
             this.$indexes.set(index, index);
             this.$items.set(index, value);
-            this.$changes.change(index);
+            this.$changes.change(index, operation);
             return index;
         };
         SetSchema.prototype.entries = function () {
@@ -2041,18 +2091,19 @@
             this.$indexes.delete(index);
             return this.$items.delete(index);
         };
-        SetSchema.prototype.clear = function (isDecoding) {
-            var _this = this;
+        SetSchema.prototype.clear = function (changes) {
             // discard previous operations.
             this.$changes.discard(true, true);
             this.$changes.indexes = {};
             // clear previous indexes
             this.$indexes.clear();
-            // flag child items for garbage collection.
-            if (isDecoding && typeof (this.$changes.getType()) !== "string") {
-                this.$items.forEach(function (item) {
-                    _this.$changes.root.removeRef(item['$changes'].refId);
-                });
+            //
+            // When decoding:
+            // - enqueue items for DELETE callback.
+            // - flag child items for garbage collection.
+            //
+            if (changes) {
+                removeChildRefs.call(this, changes);
             }
             // clear items
             this.$items.clear();
@@ -2138,48 +2189,9 @@
             }
             return cloned;
         };
-        SetSchema.prototype.triggerAll = function () {
-            Schema.prototype.triggerAll.apply(this);
-        };
         return SetSchema;
     }());
 
-    /**
-     * Extracted from https://www.npmjs.com/package/strong-events
-     */
-    var EventEmitter = /** @class */ (function () {
-        function EventEmitter() {
-            this.handlers = [];
-        }
-        EventEmitter.prototype.register = function (cb, once) {
-            this.handlers.push(cb);
-            return this;
-        };
-        EventEmitter.prototype.invoke = function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            this.handlers.forEach(function (handler) { return handler.apply(void 0, args); });
-        };
-        EventEmitter.prototype.invokeAsync = function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            return Promise.all(this.handlers.map(function (handler) { return handler.apply(void 0, args); }));
-        };
-        EventEmitter.prototype.remove = function (cb) {
-            var index = this.handlers.indexOf(cb);
-            this.handlers[index] = this.handlers[this.handlers.length - 1];
-            this.handlers.pop();
-        };
-        EventEmitter.prototype.clear = function () {
-            this.handlers = [];
-        };
-        return EventEmitter;
-    }());
-
     var ClientState = /** @class */ (function () {
         function ClientState() {
             this.refIds = new WeakSet();
@@ -2201,6 +2213,78 @@
         return ClientState;
     }());
 
+    var ReferenceTracker = /** @class */ (function () {
+        function ReferenceTracker() {
+            //
+            // Relation of refId => Schema structure
+            // For direct access of structures during decoding time.
+            //
+            this.refs = new Map();
+            this.refCounts = {};
+            this.deletedRefs = new Set();
+            this.nextUniqueId = 0;
+        }
+        ReferenceTracker.prototype.getNextUniqueId = function () {
+            return this.nextUniqueId++;
+        };
+        // for decoding
+        ReferenceTracker.prototype.addRef = function (refId, ref, incrementCount) {
+            if (incrementCount === void 0) { incrementCount = true; }
+            this.refs.set(refId, ref);
+            if (incrementCount) {
+                this.refCounts[refId] = (this.refCounts[refId] || 0) + 1;
+            }
+        };
+        // for decoding
+        ReferenceTracker.prototype.removeRef = function (refId) {
+            this.refCounts[refId] = this.refCounts[refId] - 1;
+            this.deletedRefs.add(refId);
+        };
+        ReferenceTracker.prototype.clearRefs = function () {
+            this.refs.clear();
+            this.deletedRefs.clear();
+            this.refCounts = {};
+        };
+        // for decoding
+        ReferenceTracker.prototype.garbageCollectDeletedRefs = function () {
+            var _this = this;
+            this.deletedRefs.forEach(function (refId) {
+                //
+                // Skip active references.
+                //
+                if (_this.refCounts[refId] > 0) {
+                    return;
+                }
+                var ref = _this.refs.get(refId);
+                //
+                // Ensure child schema instances have their references removed as well.
+                //
+                if (ref instanceof Schema) {
+                    for (var fieldName in ref['_definition'].schema) {
+                        if (typeof (ref['_definition'].schema[fieldName]) !== "string" &&
+                            ref[fieldName] &&
+                            ref[fieldName]['$changes']) {
+                            _this.removeRef(ref[fieldName]['$changes'].refId);
+                        }
+                    }
+                }
+                else {
+                    var definition = ref['$changes'].parent._definition;
+                    var type = definition.schema[definition.fieldsByIndex[ref['$changes'].parentIndex]];
+                    if (typeof (Object.values(type)[0]) === "function") {
+                        Array.from(ref.values())
+                            .forEach(function (child) { return _this.removeRef(child['$changes'].refId); });
+                    }
+                }
+                _this.refs.delete(refId);
+                delete _this.refCounts[refId];
+            });
+            // clear deleted refs.
+            this.deletedRefs.clear();
+        };
+        return ReferenceTracker;
+    }());
+
     var EncodeSchemaError = /** @class */ (function (_super) {
         __extends(EncodeSchemaError, _super);
         function EncodeSchemaError() {
@@ -2272,12 +2356,17 @@
             // fix enumerability of fields for end-user
             Object.defineProperties(this, {
                 $changes: {
-                    value: new ChangeTree(this, undefined, new Root()),
+                    value: new ChangeTree(this, undefined, new ReferenceTracker()),
                     enumerable: false,
                     writable: true
                 },
-                $listeners: {
-                    value: {},
+                // $listeners: {
+                //     value: undefined,
+                //     enumerable: false,
+                //     writable: true
+                // },
+                $callbacks: {
+                    value: undefined,
                     enumerable: false,
                     writable: true
                 },
@@ -2300,6 +2389,12 @@
             return (type['_definition'] &&
                 type['_definition'].schema !== undefined);
         };
+        Schema.prototype.onChange = function (callback) {
+            return addCallback((this.$callbacks || (this.$callbacks = [])), exports.OPERATION.REPLACE, callback);
+        };
+        Schema.prototype.onRemove = function (callback) {
+            return addCallback((this.$callbacks || (this.$callbacks = [])), exports.OPERATION.DELETE, callback);
+        };
         Schema.prototype.assign = function (props) {
             Object.assign(this, props);
             return this;
@@ -2309,27 +2404,35 @@
             enumerable: false,
             configurable: true
         });
+        /**
+         * (Server-side): Flag a property to be encoded for the next patch.
+         * @param instance Schema instance
+         * @param property string representing the property name, or number representing the index of the property.
+         * @param operation OPERATION to perform (detected automatically)
+         */
+        Schema.prototype.setDirty = function (property, operation) {
+            this.$changes.change(property, operation);
+        };
         Schema.prototype.listen = function (attr, callback) {
             var _this = this;
-            if (!this.$listeners[attr]) {
-                this.$listeners[attr] = new EventEmitter();
+            if (!this.$callbacks) {
+                this.$callbacks = {};
+            }
+            if (!this.$callbacks[attr]) {
+                this.$callbacks[attr] = [];
             }
-            this.$listeners[attr].register(callback);
+            this.$callbacks[attr].push(callback);
             // return un-register callback.
-            return function () {
-                return _this.$listeners[attr].remove(callback);
-            };
+            return function () { return spliceOne(_this.$callbacks[attr], _this.$callbacks[attr].indexOf(callback)); };
         };
-        Schema.prototype.decode = function (bytes, it, ref, allChanges) {
+        Schema.prototype.decode = function (bytes, it, ref) {
             if (it === void 0) { it = { offset: 0 }; }
             if (ref === void 0) { ref = this; }
-            if (allChanges === void 0) { allChanges = new Map(); }
+            var allChanges = [];
             var $root = this.$changes.root;
             var totalBytes = bytes.length;
             var refId = 0;
-            var changes = [];
             $root.refs.set(refId, this);
-            allChanges.set(refId, changes);
             while (it.offset < totalBytes) {
                 var byte = bytes[it.offset++];
                 if (byte == SWITCH_TO_STRUCTURE) {
@@ -2342,9 +2445,6 @@
                         throw new Error("\"refId\" not found: " + refId);
                     }
                     ref = nextRef;
-                    // create empty list of changes for this refId.
-                    changes = [];
-                    allChanges.set(refId, changes);
                     continue;
                 }
                 var changeTree = ref['$changes'];
@@ -2358,7 +2458,7 @@
                     // The `.clear()` method is calling `$root.removeRef(refId)` for
                     // each item inside this collection
                     //
-                    ref.clear(true);
+                    ref.clear(allChanges);
                     continue;
                 }
                 var fieldIndex = (isSchema)
@@ -2428,9 +2528,8 @@
                             value = this.createTypeInstance(childType);
                             value.$changes.refId = refId_1;
                             if (previousValue) {
-                                value.onChange = previousValue.onChange;
-                                value.onRemove = previousValue.onRemove;
-                                value.$listeners = previousValue.$listeners;
+                                value.$callbacks = previousValue.$callbacks;
+                                // value.$listeners = previousValue.$listeners;
                                 if (previousValue['$changes'].refId &&
                                     refId_1 !== previousValue['$changes'].refId) {
                                     $root.removeRef(previousValue['$changes'].refId);
@@ -2456,40 +2555,29 @@
                     value.$changes.refId = refId_2;
                     // preserve schema callbacks
                     if (previousValue) {
-                        value.onAdd = previousValue.onAdd;
-                        value.onRemove = previousValue.onRemove;
-                        value.onChange = previousValue.onChange;
+                        value['$callbacks'] = previousValue['$callbacks'];
                         if (previousValue['$changes'].refId &&
                             refId_2 !== 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;
                             while ((iter = entries.next()) && !iter.done) {
                                 var _a = iter.value, key = _a[0], value_1 = _a[1];
-                                deletes.push({
+                                allChanges.push({
+                                    refId: refId_2,
                                     op: exports.OPERATION.DELETE,
                                     field: key,
                                     value: undefined,
                                     previousValue: value_1,
                                 });
                             }
-                            allChanges.set(previousValue['$changes'].refId, deletes);
                         }
                     }
                     $root.addRef(refId_2, value, (valueRef !== previousValue));
-                    //
-                    // TODO: deprecate proxies on next version.
-                    // get proxy to target value.
-                    //
-                    if (typeDef.getProxy) {
-                        value = typeDef.getProxy(value);
-                    }
                 }
-                var hasChange = (previousValue !== value);
                 if (value !== null &&
                     value !== undefined) {
                     if (value['$changes']) {
@@ -2497,14 +2585,7 @@
                     }
                     if (ref instanceof Schema) {
                         ref[fieldName] = value;
-                        //
-                        // FIXME: use `_field` instead of `field`.
-                        //
-                        // `field` is going to use the setter of the PropertyDescriptor
-                        // and create a proxy for array/map. This is only useful for
-                        // backwards-compatibility with @colyseus/schema@0.5.x
-                        //
-                        // // ref[_field] = value;
+                        // ref[`_${fieldName}`] = value;
                     }
                     else if (ref instanceof MapSchema) {
                         // const key = ref['$indexes'].get(field);
@@ -2518,19 +2599,20 @@
                         // ref[key] = value;
                         ref.setAt(fieldIndex, value);
                     }
-                    else if (ref instanceof CollectionSchema ||
-                        ref instanceof SetSchema) {
+                    else if (ref instanceof CollectionSchema) {
                         var index = ref.add(value);
                         ref['setIndex'](fieldIndex, index);
                     }
+                    else if (ref instanceof SetSchema) {
+                        var index = ref.add(value);
+                        if (index !== false) {
+                            ref['setIndex'](fieldIndex, index);
+                        }
+                    }
                 }
-                if (hasChange
-                // &&
-                // (
-                //     this.onChange || ref.$listeners[field]
-                // )
-                ) {
-                    changes.push({
+                if (previousValue !== value) {
+                    allChanges.push({
+                        refId: refId,
                         op: operation,
                         field: fieldName,
                         dynamicIndex: dynamicIndex,
@@ -2684,6 +2766,7 @@
             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();
@@ -2802,7 +2885,7 @@
                             //
                             // use cached bytes directly if is from Schema type.
                             //
-                            filteredBytes = filteredBytes.concat(changeTree.caches[fieldIndex]);
+                            filteredBytes.push.apply(filteredBytes, (_a = changeTree.caches[fieldIndex]) !== null && _a !== void 0 ? _a : []);
                             containerIndexes.add(fieldIndex);
                         }
                         else {
@@ -2810,7 +2893,7 @@
                                 //
                                 // use cached bytes if already has the field
                                 //
-                                filteredBytes = filteredBytes.concat(changeTree.caches[fieldIndex]);
+                                filteredBytes.push.apply(filteredBytes, (_b = changeTree.caches[fieldIndex]) !== null && _b !== void 0 ? _b : []);
                             }
                             else {
                                 //
@@ -2878,20 +2961,6 @@
             }
             return cloned;
         };
-        Schema.prototype.triggerAll = function () {
-            // skip if haven't received any remote refs yet.
-            if (this.$changes.root.refs.size === 0) {
-                return;
-            }
-            var allChanges = new Map();
-            Schema.prototype._triggerAllFillChanges.call(this, this, allChanges);
-            try {
-                Schema.prototype._triggerChanges.call(this, allChanges);
-            }
-            catch (e) {
-                Schema.onError(e);
-            }
-        };
         Schema.prototype.toJSON = function () {
             var schema = this._definition.schema;
             var deprecated = this._definition.deprecated;
@@ -2934,111 +3003,81 @@
             instance.$changes.root = this.$changes.root;
             return instance;
         };
-        Schema.prototype._triggerAllFillChanges = function (ref, allChanges) {
-            if (allChanges.has(ref['$changes'].refId)) {
-                return;
-            }
-            var changes = [];
-            allChanges.set(ref['$changes'].refId || 0, changes);
-            if (ref instanceof Schema) {
-                var schema = ref._definition.schema;
-                for (var fieldName in schema) {
-                    var _field = "_" + fieldName;
-                    var value = ref[_field];
-                    if (value !== undefined) {
-                        changes.push({
-                            op: exports.OPERATION.ADD,
-                            field: fieldName,
-                            value: value,
-                            previousValue: undefined
-                        });
-                        if (value['$changes'] !== undefined) {
-                            Schema.prototype._triggerAllFillChanges.call(this, value, allChanges);
+        Schema.prototype._triggerChanges = function (changes) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+            var uniqueRefIds = new Set();
+            var $refs = this.$changes.root.refs;
+            var _loop_2 = function (i) {
+                var change = changes[i];
+                var refId = change.refId;
+                var ref = $refs.get(refId);
+                var $callbacks = ref['$callbacks'];
+                //
+                // trigger onRemove on child structure.
+                //
+                if ((change.op & exports.OPERATION.DELETE) === exports.OPERATION.DELETE &&
+                    change.previousValue instanceof Schema) {
+                    (_b = (_a = change.previousValue['$callbacks']) === null || _a === void 0 ? void 0 : _a[exports.OPERATION.DELETE]) === null || _b === void 0 ? void 0 : _b.forEach(function (callback) { return callback(); });
+                }
+                // no callbacks defined, skip this structure!
+                if (!$callbacks) {
+                    return "continue";
+                }
+                if (ref instanceof Schema) {
+                    if (!uniqueRefIds.has(refId)) {
+                        try {
+                            // trigger onChange
+                            (_d = (_c = $callbacks) === null || _c === void 0 ? void 0 : _c[exports.OPERATION.REPLACE]) === null || _d === void 0 ? void 0 : _d.forEach(function (callback) {
+                                return callback(changes);
+                            });
+                        }
+                        catch (e) {
+                            Schema.onError(e);
                         }
                     }
-                }
-            }
-            else {
-                var entries = ref.entries();
-                var iter = void 0;
-                while ((iter = entries.next()) && !iter.done) {
-                    var _a = iter.value, key = _a[0], value = _a[1];
-                    changes.push({
-                        op: exports.OPERATION.ADD,
-                        field: key,
-                        dynamicIndex: key,
-                        value: value,
-                        previousValue: undefined,
-                    });
-                    if (value['$changes'] !== undefined) {
-                        Schema.prototype._triggerAllFillChanges.call(this, value, allChanges);
+                    try {
+                        (_e = $callbacks[change.op]) === null || _e === void 0 ? void 0 : _e.forEach(function (callback) {
+                            return callback(change.value, change.previousValue);
+                        });
+                    }
+                    catch (e) {
+                        Schema.onError(e);
                     }
                 }
-            }
-        };
-        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;
-                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];
-                        if (!isSchema) {
-                            if (change.op === exports.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);
-                            }
-                            else if (change.op === exports.OPERATION.DELETE) {
-                                //
-                                // FIXME: `previousValue` should always be avaiiable.
-                                // 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);
-                                }
-                            }
-                            else if (change.op === exports.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);
-                                }
-                                (_k = (_j = ref).onAdd) === null || _k === void 0 ? void 0 : _k.call(_j, change.value, change.dynamicIndex);
-                            }
-                            else if (change.op === exports.OPERATION.REPLACE ||
-                                change.value !== change.previousValue) {
-                                (_m = (_l = ref).onChange) === null || _m === void 0 ? void 0 : _m.call(_l, change.value, change.dynamicIndex);
-                            }
-                        }
+                else {
+                    // is a collection of items
+                    if (change.op === exports.OPERATION.ADD && change.previousValue === undefined) {
+                        // triger onAdd
+                        (_f = $callbacks[exports.OPERATION.ADD]) === null || _f === void 0 ? void 0 : _f.forEach(function (callback) { var _a; return callback(change.value, (_a = change.dynamicIndex) !== null && _a !== void 0 ? _a : change.field); });
+                    }
+                    else if (change.op === exports.OPERATION.DELETE) {
                         //
-                        // trigger onRemove on child structure.
+                        // FIXME: `previousValue` should always be available.
+                        // ADD + DELETE operations are still encoding DELETE operation.
                         //
-                        if ((change.op & exports.OPERATION.DELETE) === exports.OPERATION.DELETE &&
-                            change.previousValue instanceof Schema &&
-                            change.previousValue.onRemove) {
-                            change.previousValue.onRemove();
-                        }
-                        if (listener) {
-                            try {
-                                listener.invoke(change.value, change.previousValue);
-                            }
-                            catch (e) {
-                                Schema.onError(e);
-                            }
+                        if (change.previousValue !== undefined) {
+                            // triger onRemove
+                            (_g = $callbacks[exports.OPERATION.DELETE]) === null || _g === void 0 ? void 0 : _g.forEach(function (callback) { var _a; return callback(change.previousValue, (_a = change.dynamicIndex) !== null && _a !== void 0 ? _a : change.field); });
                         }
                     }
-                    if (isSchema) {
-                        if (ref.onChange) {
-                            try {
-                                ref.onChange(changes);
-                            }
-                            catch (e) {
-                                Schema.onError(e);
-                            }
+                    else if (change.op === exports.OPERATION.DELETE_AND_ADD) {
+                        // triger onRemove
+                        if (change.previousValue !== undefined) {
+                            (_h = $callbacks[exports.OPERATION.DELETE]) === null || _h === void 0 ? void 0 : _h.forEach(function (callback) { var _a; return callback(change.previousValue, (_a = change.dynamicIndex) !== null && _a !== void 0 ? _a : change.field); });
                         }
+                        // triger onAdd
+                        (_j = $callbacks[exports.OPERATION.ADD]) === null || _j === void 0 ? void 0 : _j.forEach(function (callback) { var _a; return callback(change.value, (_a = change.dynamicIndex) !== null && _a !== void 0 ? _a : change.field); });
+                    }
+                    // trigger onChange
+                    if (change.value !== change.previousValue) {
+                        (_k = $callbacks[exports.OPERATION.REPLACE]) === null || _k === void 0 ? void 0 : _k.forEach(function (callback) { var _a; return callback(change.value, (_a = change.dynamicIndex) !== null && _a !== void 0 ? _a : change.field); });
                     }
                 }
-            });
+                uniqueRefIds.add(refId);
+            };
+            for (var i = 0; i < changes.length; i++) {
+                _loop_2(i);
+            }
         };
         Schema._definition = SchemaDefinition.create();
         return Schema;
@@ -3066,7 +3105,7 @@
         return dump;
     }
 
-    var reflectionContext = new Context();
+    var reflectionContext = { context: new Context() };
     /**
      * Reflection
      */
@@ -3187,14 +3226,14 @@
                             refType = typeInfo[1];
                         }
                         if (fieldType === "ref") {
-                            type(refType, context)(schemaType.prototype, field.name);
+                            type(refType, { context: context })(schemaType.prototype, field.name);
                         }
                         else {
-                            type((_a = {}, _a[fieldType] = refType, _a), context)(schemaType.prototype, field.name);
+                            type((_a = {}, _a[fieldType] = refType, _a), { context: context })(schemaType.prototype, field.name);
                         }
                     }
                     else {
-                        type(field.type, context)(schemaType.prototype, field.name);
+                        type(field.type, { context: context })(schemaType.prototype, field.name);
                     }
                 });
             });
@@ -3223,8 +3262,8 @@
         return Reflection;
     }(Schema));
 
-    registerType("map", { constructor: MapSchema, getProxy: getMapProxy });
-    registerType("array", { constructor: ArraySchema, getProxy: getArrayProxy });
+    registerType("map", { constructor: MapSchema });
+    registerType("array", { constructor: ArraySchema });
     registerType("set", { constructor: SetSchema });
     registerType("collection", { constructor: CollectionSchema, });