@colyseus/schema 1.1.0-alpha.2 → 2.0.3

package/build/esm/index.mjs

@@ -37,73 +37,6 @@ var OPERATION;
 //     CLEAR = 10,
 // }
 
-//
-// Root holds all schema references by unique id
-//
-class Root {
-    constructor() {
-        //
-        // 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;
-    }
-    getNextUniqueId() {
-        return this.nextUniqueId++;
-    }
-    // for decoding
-    addRef(refId, ref, incrementCount = true) {
-        this.refs.set(refId, ref);
-        if (incrementCount) {
-            this.refCounts[refId] = (this.refCounts[refId] || 0) + 1;
-        }
-    }
-    // for decoding
-    removeRef(refId) {
-        this.refCounts[refId] = this.refCounts[refId] - 1;
-        this.deletedRefs.add(refId);
-    }
-    clearRefs() {
-        this.refs.clear();
-        this.deletedRefs.clear();
-        this.refCounts = {};
-    }
-    // for decoding
-    garbageCollectDeletedRefs() {
-        this.deletedRefs.forEach((refId) => {
-            if (this.refCounts[refId] <= 0) {
-                const ref = this.refs.get(refId);
-                //
-                // Ensure child schema instances have their references removed as well.
-                //
-                if (ref instanceof Schema) {
-                    for (const fieldName in ref['_definition'].schema) {
-                        if (typeof (ref['_definition'].schema[fieldName]) !== "string" &&
-                            ref[fieldName] &&
-                            ref[fieldName]['$changes']) {
-                            this.removeRef(ref[fieldName]['$changes'].refId);
-                        }
-                    }
-                }
-                else {
-                    const definition = ref['$changes'].parent._definition;
-                    const type = definition.schema[definition.fieldsByIndex[ref['$changes'].parentIndex]];
-                    if (typeof (Object.values(type)[0]) === "function") {
-                        Array.from(ref.values())
-                            .forEach((child) => this.removeRef(child['$changes'].refId));
-                    }
-                }
-                this.refs.delete(refId);
-                delete this.refCounts[refId];
-            }
-        });
-        // clear deleted refs.
-        this.deletedRefs.clear();
-    }
-}
 class ChangeTree {
     constructor(ref, parent, root) {
         this.changed = false;
@@ -300,13 +233,48 @@ class 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?.forEach((item, key) => callback(item, key));
+    return () => spliceOne($callbacks[op], $callbacks[op].indexOf(callback));
+}
+function removeChildRefs(changes) {
+    const needRemoveRef = (typeof (this.$changes.getType()) !== "string");
+    this.$items.forEach((item, key) => {
+        changes.push({
+            refId: this.$changes.refId,
+            op: 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;
+    }
+    const len = arr.length - 1;
+    for (let i = index; i < len; i++) {
+        arr[i] = arr[i + 1];
+    }
+    arr.length = len;
+    return true;
+}
+
 const DEFAULT_SORT = (a, b) => {
     const A = a.toString();
     const B = b.toString();
@@ -373,8 +341,19 @@ class ArraySchema {
         this.$refId = 0;
         this.push.apply(this, items);
     }
+    onAdd(callback, triggerAll = true) {
+        return addCallback((this.$callbacks || (this.$callbacks = [])), OPERATION.ADD, callback, (triggerAll)
+            ? this.$items
+            : undefined);
+    }
+    onRemove(callback) { return addCallback(this.$callbacks || (this.$callbacks = []), OPERATION.DELETE, callback); }
+    onChange(callback) { return addCallback(this.$callbacks || (this.$callbacks = []), OPERATION.REPLACE, callback); }
     static is(type) {
-        return Array.isArray(type);
+        return (
+        // type format: ["string"]
+        Array.isArray(type) ||
+            // type format: { array: "string" }
+            (type['array'] !== undefined));
     }
     set length(value) {
         if (value === 0) {
@@ -440,17 +419,19 @@ class ArraySchema {
         this.$indexes.delete(index);
         return this.$items.delete(index);
     }
-    clear(isDecoding) {
+    clear(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((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();
@@ -784,9 +765,6 @@ class ArraySchema {
         return cloned;
     }
     ;
-    triggerAll() {
-        Schema.prototype.triggerAll.apply(this);
-    }
 }
 
 function getMapProxy(value) {
@@ -838,6 +816,13 @@ class MapSchema {
             }
         }
     }
+    onAdd(callback, triggerAll = true) {
+        return addCallback((this.$callbacks || (this.$callbacks = [])), OPERATION.ADD, callback, (triggerAll)
+            ? this.$items
+            : undefined);
+    }
+    onRemove(callback) { return addCallback(this.$callbacks || (this.$callbacks = []), OPERATION.DELETE, callback); }
+    onChange(callback) { return addCallback(this.$callbacks || (this.$callbacks = []), OPERATION.REPLACE, callback); }
     static is(type) {
         return type['map'] !== undefined;
     }
@@ -845,6 +830,9 @@ class MapSchema {
     [Symbol.iterator]() { return this.$items[Symbol.iterator](); }
     get [Symbol.toStringTag]() { return this.$items[Symbol.toStringTag]; }
     set(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.
         const hasIndex = typeof (this.$changes.indexes[key]) !== "undefined";
         const index = (hasIndex)
@@ -888,17 +876,19 @@ class MapSchema {
         this.$changes.delete(key);
         return this.$items.delete(key);
     }
-    clear(isDecoding) {
+    clear(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((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();
@@ -970,9 +960,6 @@ class MapSchema {
         }
         return cloned;
     }
-    triggerAll() {
-        Schema.prototype.triggerAll.apply(this);
-    }
 }
 
 const registeredTypes = {};
@@ -1011,6 +998,9 @@ class SchemaDefinition {
             ? { array: type[0] }
             : type;
     }
+    hasField(field) {
+        return this.indexes[field] !== undefined;
+    }
     addFilter(field, cb) {
         if (!this.filters) {
             this.filters = {};
@@ -1064,20 +1054,40 @@ class Context {
         this.types[typeid] = schema;
         this.schemas.set(schema, typeid);
     }
-    static create(context = new Context) {
+    static create(options = {}) {
         return function (definition) {
-            return type(definition, context);
+            if (!options.context) {
+                options.context = new Context();
+            }
+            return type(definition, options);
         };
     }
 }
 const 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 = globalContext) {
+function type(type, options = {}) {
     return function (target, field) {
+        const context = options.context || globalContext;
         const 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
          */
@@ -1090,7 +1100,21 @@ function type(type, context = globalContext) {
          * 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) {
+                    const definitionAtLine = e.stack.split("\n")[4].trim();
+                    throw new Error(`${e.message} ${definitionAtLine}`);
+                }
+            }
         }
         const isArray = ArraySchema.is(type);
         const isMap = !isArray && MapSchema.is(type);
@@ -1103,6 +1127,15 @@ function type(type, context = globalContext) {
                 context.add(childType);
             }
         }
+        if (options.manual) {
+            // do not declare getter/setter descriptor
+            definition.descriptors[field] = {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+            };
+            return;
+        }
         const fieldCached = `_${field}`;
         definition.descriptors[fieldCached] = {
             enumerable: false,
@@ -1188,7 +1221,7 @@ function filterChildren(cb) {
  * `@deprecated()` flag a field as deprecated.
  * The previous `@type()` annotation should remain along with this one.
  */
-function deprecated(throws = true, context = globalContext) {
+function deprecated(throws = true) {
     return function (target, field) {
         const constructor = target.constructor;
         const definition = constructor._definition;
@@ -1203,9 +1236,12 @@ function deprecated(throws = true, context = globalContext) {
         }
     };
 }
-function defineTypes(target, fields, context = target._context || globalContext) {
+function defineTypes(target, fields, options = {}) {
+    if (!options.context) {
+        options.context = target._context || options.context || globalContext;
+    }
     for (let field in fields) {
-        type(fields[field], context)(target.prototype, field);
+        type(fields[field], options)(target.prototype, field);
     }
     return target;
 }
@@ -1742,6 +1778,13 @@ class CollectionSchema {
             initialValues.forEach((v) => this.add(v));
         }
     }
+    onAdd(callback, triggerAll = true) {
+        return addCallback((this.$callbacks || (this.$callbacks = [])), OPERATION.ADD, callback, (triggerAll)
+            ? this.$items
+            : undefined);
+    }
+    onRemove(callback) { return addCallback(this.$callbacks || (this.$callbacks = []), OPERATION.DELETE, callback); }
+    onChange(callback) { return addCallback(this.$callbacks || (this.$callbacks = []), OPERATION.REPLACE, callback); }
     static is(type) {
         return type['collection'] !== undefined;
     }
@@ -1785,17 +1828,19 @@ class CollectionSchema {
         this.$indexes.delete(index);
         return this.$items.delete(index);
     }
-    clear(isDecoding) {
+    clear(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((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();
@@ -1864,9 +1909,6 @@ class CollectionSchema {
         }
         return cloned;
     }
-    triggerAll() {
-        Schema.prototype.triggerAll.apply(this);
-    }
 }
 
 class SetSchema {
@@ -1879,23 +1921,31 @@ class SetSchema {
             initialValues.forEach((v) => this.add(v));
         }
     }
+    onAdd(callback, triggerAll = true) {
+        return addCallback((this.$callbacks || (this.$callbacks = [])), OPERATION.ADD, callback, (triggerAll)
+            ? this.$items
+            : undefined);
+    }
+    onRemove(callback) { return addCallback(this.$callbacks || (this.$callbacks = []), OPERATION.DELETE, callback); }
+    onChange(callback) { return addCallback(this.$callbacks || (this.$callbacks = []), OPERATION.REPLACE, callback); }
     static is(type) {
         return type['set'] !== undefined;
     }
     add(value) {
+        // immediatelly return false if value already added.
         if (this.has(value)) {
             return false;
         }
         // set "index" for reference.
         const index = this.$refId++;
-        const isRef = (value['$changes']) !== undefined;
-        if (isRef) {
+        if ((value['$changes']) !== undefined) {
             value['$changes'].setParent(this, this.$changes.root, index);
         }
+        const operation = this.$changes.indexes[index]?.op ?? 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;
     }
     entries() {
@@ -1921,17 +1971,19 @@ class SetSchema {
         this.$indexes.delete(index);
         return this.$items.delete(index);
     }
-    clear(isDecoding) {
+    clear(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((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();
@@ -2012,36 +2064,6 @@ class SetSchema {
         }
         return cloned;
     }
-    triggerAll() {
-        Schema.prototype.triggerAll.apply(this);
-    }
-}
-
-/**
- * Extracted from https://www.npmjs.com/package/strong-events
- */
-class EventEmitter {
-    constructor() {
-        this.handlers = [];
-    }
-    register(cb, once = false) {
-        this.handlers.push(cb);
-        return this;
-    }
-    invoke(...args) {
-        this.handlers.forEach((handler) => handler(...args));
-    }
-    invokeAsync(...args) {
-        return Promise.all(this.handlers.map((handler) => handler(...args)));
-    }
-    remove(cb) {
-        const index = this.handlers.indexOf(cb);
-        this.handlers[index] = this.handlers[this.handlers.length - 1];
-        this.handlers.pop();
-    }
-    clear() {
-        this.handlers = [];
-    }
 }
 
 class ClientState {
@@ -2064,6 +2086,75 @@ class ClientState {
     }
 }
 
+class ReferenceTracker {
+    constructor() {
+        //
+        // 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;
+    }
+    getNextUniqueId() {
+        return this.nextUniqueId++;
+    }
+    // for decoding
+    addRef(refId, ref, incrementCount = true) {
+        this.refs.set(refId, ref);
+        if (incrementCount) {
+            this.refCounts[refId] = (this.refCounts[refId] || 0) + 1;
+        }
+    }
+    // for decoding
+    removeRef(refId) {
+        this.refCounts[refId] = this.refCounts[refId] - 1;
+        this.deletedRefs.add(refId);
+    }
+    clearRefs() {
+        this.refs.clear();
+        this.deletedRefs.clear();
+        this.refCounts = {};
+    }
+    // for decoding
+    garbageCollectDeletedRefs() {
+        this.deletedRefs.forEach((refId) => {
+            //
+            // Skip active references.
+            //
+            if (this.refCounts[refId] > 0) {
+                return;
+            }
+            const ref = this.refs.get(refId);
+            //
+            // Ensure child schema instances have their references removed as well.
+            //
+            if (ref instanceof Schema) {
+                for (const fieldName in ref['_definition'].schema) {
+                    if (typeof (ref['_definition'].schema[fieldName]) !== "string" &&
+                        ref[fieldName] &&
+                        ref[fieldName]['$changes']) {
+                        this.removeRef(ref[fieldName]['$changes'].refId);
+                    }
+                }
+            }
+            else {
+                const definition = ref['$changes'].parent._definition;
+                const type = definition.schema[definition.fieldsByIndex[ref['$changes'].parentIndex]];
+                if (typeof (Object.values(type)[0]) === "function") {
+                    Array.from(ref.values())
+                        .forEach((child) => this.removeRef(child['$changes'].refId));
+                }
+            }
+            this.refs.delete(refId);
+            delete this.refCounts[refId];
+        });
+        // clear deleted refs.
+        this.deletedRefs.clear();
+    }
+}
+
 class EncodeSchemaError extends Error {
 }
 function assertType(value, type, klass, field) {
@@ -2126,12 +2217,17 @@ class Schema {
         // 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
             },
@@ -2154,26 +2250,43 @@ class Schema {
         return (type['_definition'] &&
             type['_definition'].schema !== undefined);
     }
+    onChange(callback) {
+        return addCallback((this.$callbacks || (this.$callbacks = [])), OPERATION.REPLACE, callback);
+    }
+    onRemove(callback) {
+        return addCallback((this.$callbacks || (this.$callbacks = [])), OPERATION.DELETE, callback);
+    }
     assign(props) {
         Object.assign(this, props);
         return this;
     }
     get _definition() { return this.constructor._definition; }
+    /**
+     * (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)
+     */
+    setDirty(property, operation) {
+        this.$changes.change(property, operation);
+    }
     listen(attr, callback) {
-        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 () => this.$listeners[attr].remove(callback);
+        return () => spliceOne(this.$callbacks[attr], this.$callbacks[attr].indexOf(callback));
     }
-    decode(bytes, it = { offset: 0 }, ref = this, allChanges = new Map()) {
+    decode(bytes, it = { offset: 0 }, ref = this) {
+        const allChanges = [];
         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) {
             let byte = bytes[it.offset++];
             if (byte == SWITCH_TO_STRUCTURE) {
@@ -2186,9 +2299,6 @@ class Schema {
                     throw new Error(`"refId" not found: ${refId}`);
                 }
                 ref = nextRef;
-                // create empty list of changes for this refId.
-                changes = [];
-                allChanges.set(refId, changes);
                 continue;
             }
             const changeTree = ref['$changes'];
@@ -2202,7 +2312,7 @@ class Schema {
                 // The `.clear()` method is calling `$root.removeRef(refId)` for
                 // each item inside this collection
                 //
-                ref.clear(true);
+                ref.clear(allChanges);
                 continue;
             }
             const fieldIndex = (isSchema)
@@ -2272,9 +2382,8 @@ class Schema {
                         value = this.createTypeInstance(childType);
                         value.$changes.refId = refId;
                         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 !== previousValue['$changes'].refId) {
                                 $root.removeRef(previousValue['$changes'].refId);
@@ -2300,40 +2409,29 @@ class Schema {
                 value.$changes.refId = refId;
                 // 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 !== previousValue['$changes'].refId) {
                         $root.removeRef(previousValue['$changes'].refId);
                         //
                         // Trigger onRemove if structure has been replaced.
                         //
-                        const deletes = [];
                         const entries = previousValue.entries();
                         let iter;
                         while ((iter = entries.next()) && !iter.done) {
                             const [key, value] = iter.value;
-                            deletes.push({
+                            allChanges.push({
+                                refId,
                                 op: OPERATION.DELETE,
                                 field: key,
                                 value: undefined,
                                 previousValue: value,
                             });
                         }
-                        allChanges.set(previousValue['$changes'].refId, deletes);
                     }
                 }
                 $root.addRef(refId, value, (valueRef !== previousValue));
-                //
-                // TODO: deprecate proxies on next version.
-                // get proxy to target value.
-                //
-                if (typeDef.getProxy) {
-                    value = typeDef.getProxy(value);
-                }
             }
-            let hasChange = (previousValue !== value);
             if (value !== null &&
                 value !== undefined) {
                 if (value['$changes']) {
@@ -2341,14 +2439,7 @@ class Schema {
                 }
                 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);
@@ -2362,19 +2453,20 @@ class Schema {
                     // ref[key] = value;
                     ref.setAt(fieldIndex, value);
                 }
-                else if (ref instanceof CollectionSchema ||
-                    ref instanceof SetSchema) {
+                else if (ref instanceof CollectionSchema) {
                     const index = ref.add(value);
                     ref['setIndex'](fieldIndex, index);
                 }
+                else if (ref instanceof SetSchema) {
+                    const 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,
                     op: operation,
                     field: fieldName,
                     dynamicIndex,
@@ -2643,7 +2735,7 @@ class Schema {
                         //
                         // use cached bytes directly if is from Schema type.
                         //
-                        filteredBytes = filteredBytes.concat(changeTree.caches[fieldIndex]);
+                        filteredBytes.push.apply(filteredBytes, changeTree.caches[fieldIndex] ?? []);
                         containerIndexes.add(fieldIndex);
                     }
                     else {
@@ -2651,7 +2743,7 @@ class Schema {
                             //
                             // use cached bytes if already has the field
                             //
-                            filteredBytes = filteredBytes.concat(changeTree.caches[fieldIndex]);
+                            filteredBytes.push.apply(filteredBytes, changeTree.caches[fieldIndex] ?? []);
                         }
                         else {
                             //
@@ -2716,20 +2808,6 @@ class Schema {
         }
         return cloned;
     }
-    triggerAll() {
-        // skip if haven't received any remote refs yet.
-        if (this.$changes.root.refs.size === 0) {
-            return;
-        }
-        const allChanges = new Map();
-        Schema.prototype._triggerAllFillChanges.call(this, this, allChanges);
-        try {
-            Schema.prototype._triggerChanges.call(this, allChanges);
-        }
-        catch (e) {
-            Schema.onError(e);
-        }
-    }
     toJSON() {
         const schema = this._definition.schema;
         const deprecated = this._definition.deprecated;
@@ -2772,109 +2850,73 @@ class Schema {
         instance.$changes.root = this.$changes.root;
         return instance;
     }
-    _triggerAllFillChanges(ref, allChanges) {
-        if (allChanges.has(ref['$changes'].refId)) {
-            return;
-        }
-        const changes = [];
-        allChanges.set(ref['$changes'].refId || 0, changes);
-        if (ref instanceof Schema) {
-            const schema = ref._definition.schema;
-            for (let fieldName in schema) {
-                const _field = `_${fieldName}`;
-                const value = ref[_field];
-                if (value !== undefined) {
-                    changes.push({
-                        op: OPERATION.ADD,
-                        field: fieldName,
-                        value,
-                        previousValue: undefined
-                    });
-                    if (value['$changes'] !== undefined) {
-                        Schema.prototype._triggerAllFillChanges.call(this, value, allChanges);
+    _triggerChanges(changes) {
+        const uniqueRefIds = new Set();
+        const $refs = this.$changes.root.refs;
+        for (let i = 0; i < changes.length; i++) {
+            const change = changes[i];
+            const refId = change.refId;
+            const ref = $refs.get(refId);
+            const $callbacks = ref['$callbacks'];
+            //
+            // trigger onRemove on child structure.
+            //
+            if ((change.op & OPERATION.DELETE) === OPERATION.DELETE &&
+                change.previousValue instanceof Schema) {
+                change.previousValue['$callbacks']?.[OPERATION.DELETE]?.forEach(callback => callback());
+            }
+            // no callbacks defined, skip this structure!
+            if (!$callbacks) {
+                continue;
+            }
+            if (ref instanceof Schema) {
+                if (!uniqueRefIds.has(refId)) {
+                    try {
+                        // trigger onChange
+                        $callbacks?.[OPERATION.REPLACE]?.forEach(callback => callback(changes));
+                    }
+                    catch (e) {
+                        Schema.onError(e);
                     }
                 }
-            }
-        }
-        else {
-            const entries = ref.entries();
-            let iter;
-            while ((iter = entries.next()) && !iter.done) {
-                const [key, value] = iter.value;
-                changes.push({
-                    op: OPERATION.ADD,
-                    field: key,
-                    dynamicIndex: key,
-                    value: value,
-                    previousValue: undefined,
-                });
-                if (value['$changes'] !== undefined) {
-                    Schema.prototype._triggerAllFillChanges.call(this, value, allChanges);
+                try {
+                    $callbacks[change.op]?.forEach(callback => callback(change.value, change.previousValue));
+                }
+                catch (e) {
+                    Schema.onError(e);
                 }
             }
-        }
-    }
-    _triggerChanges(allChanges) {
-        allChanges.forEach((changes, refId) => {
-            if (changes.length > 0) {
-                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 === OPERATION.ADD && change.previousValue === undefined) {
-                            ref.onAdd?.(change.value, change.dynamicIndex ?? change.field);
-                        }
-                        else if (change.op === OPERATION.DELETE) {
-                            //
-                            // FIXME: `previousValue` should always be avaiiable.
-                            // ADD + DELETE operations are still encoding DELETE operation.
-                            //
-                            if (change.previousValue !== undefined) {
-                                ref.onRemove?.(change.previousValue, change.dynamicIndex ?? change.field);
-                            }
-                        }
-                        else if (change.op === OPERATION.DELETE_AND_ADD) {
-                            if (change.previousValue !== undefined) {
-                                ref.onRemove?.(change.previousValue, change.dynamicIndex);
-                            }
-                            ref.onAdd?.(change.value, change.dynamicIndex);
-                        }
-                        else if (change.op === OPERATION.REPLACE ||
-                            change.value !== change.previousValue) {
-                            ref.onChange?.(change.value, change.dynamicIndex);
-                        }
-                    }
+            else {
+                // is a collection of items
+                if (change.op === OPERATION.ADD && change.previousValue === undefined) {
+                    // triger onAdd
+                    $callbacks[OPERATION.ADD]?.forEach(callback => callback(change.value, change.dynamicIndex ?? change.field));
+                }
+                else if (change.op === OPERATION.DELETE) {
                     //
-                    // trigger onRemove on child structure.
+                    // FIXME: `previousValue` should always be available.
+                    // ADD + DELETE operations are still encoding DELETE operation.
                     //
-                    if ((change.op & OPERATION.DELETE) === 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
+                        $callbacks[OPERATION.DELETE]?.forEach(callback => callback(change.previousValue, change.dynamicIndex ?? change.field));
                     }
                 }
-                if (isSchema) {
-                    if (ref.onChange) {
-                        try {
-                            ref.onChange(changes);
-                        }
-                        catch (e) {
-                            Schema.onError(e);
-                        }
+                else if (change.op === OPERATION.DELETE_AND_ADD) {
+                    // triger onRemove
+                    if (change.previousValue !== undefined) {
+                        $callbacks[OPERATION.DELETE]?.forEach(callback => callback(change.previousValue, change.dynamicIndex ?? change.field));
                     }
+                    // triger onAdd
+                    $callbacks[OPERATION.ADD]?.forEach(callback => callback(change.value, change.dynamicIndex ?? change.field));
+                }
+                // trigger onChange
+                if (change.value !== change.previousValue) {
+                    $callbacks[OPERATION.REPLACE]?.forEach(callback => callback(change.value, change.dynamicIndex ?? change.field));
                 }
             }
-        });
+            uniqueRefIds.add(refId);
+        }
     }
 }
 Schema._definition = SchemaDefinition.create();
@@ -2920,7 +2962,7 @@ function __decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 
-const reflectionContext = new Context();
+const reflectionContext = { context: new Context() };
 /**
  * Reflection
  */
@@ -3025,14 +3067,14 @@ class Reflection extends Schema {
                         refType = typeInfo[1];
                     }
                     if (fieldType === "ref") {
-                        type(refType, context)(schemaType.prototype, field.name);
+                        type(refType, { context })(schemaType.prototype, field.name);
                     }
                     else {
-                        type({ [fieldType]: refType }, context)(schemaType.prototype, field.name);
+                        type({ [fieldType]: refType }, { context })(schemaType.prototype, field.name);
                     }
                 }
                 else {
-                    type(field.type, context)(schemaType.prototype, field.name);
+                    type(field.type, { context })(schemaType.prototype, field.name);
                 }
             });
         });
@@ -3060,8 +3102,8 @@ __decorate([
     type("number", reflectionContext)
 ], Reflection.prototype, "rootType", void 0);
 
-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, });