@colyseus/schema 3.0.0-alpha.30 → 3.0.0-alpha.32

package/src/Schema.ts

@@ -4,7 +4,7 @@ import { DEFAULT_VIEW_TAG, DefinitionType } from "./annotations";
 import { NonFunctionPropNames, ToJSON } from './types/HelperTypes';
 
 import { ChangeTree, Ref } from './encoder/ChangeTree';
-import { $changes, $decoder, $deleteByIndex, $encoder, $filter, $getByIndex, $track } from './types/symbols';
+import { $changes, $decoder, $deleteByIndex, $descriptors, $encoder, $filter, $getByIndex, $track } from './types/symbols';
 import { StateView } from './encoder/StateView';
 
 import { encodeSchemaOperation } from './encoder/EncodeOperation';
@@ -16,7 +16,6 @@ import { getIndent } from './utils';
  * Schema encoder / decoder
  */
 export abstract class Schema {
-
     static [$encoder] = encodeSchemaOperation;
     static [$decoder] = decodeSchemaOperation;
 
@@ -31,37 +30,7 @@ export abstract class Schema {
             writable: true
         });
 
-        const metadata = instance.constructor[Symbol.metadata];
-
-        // Define property descriptors
-        for (const field in metadata) {
-            if (metadata[field].descriptor) {
-                // for encoder
-                Object.defineProperty(instance, `_${field}`, {
-                    value: undefined,
-                    writable: true,
-                    enumerable: false,
-                    configurable: true,
-                });
-                Object.defineProperty(instance, field, metadata[field].descriptor);
-
-            } else {
-                // for decoder
-                Object.defineProperty(instance, field,  {
-                    value: undefined,
-                    writable: true,
-                    enumerable: true,
-                    configurable: true,
-                });
-            }
-
-            // Object.defineProperty(instance, field, {
-            //     ...instance.constructor[Symbol.metadata][field].descriptor
-            // });
-            // if (args[0]?.hasOwnProperty(field)) {
-            //     instance[field] = args[0][field];
-            // }
-        }
+        Object.defineProperties(instance, instance.constructor[Symbol.metadata]?.[$descriptors] || {});
     }
 
     static is(type: DefinitionType) {
@@ -88,7 +57,7 @@ export abstract class Schema {
      */
     static [$filter] (ref: Schema, index: number, view: StateView) {
         const metadata: Metadata = ref.constructor[Symbol.metadata];
-        const tag = metadata[metadata[index]].tag;
+        const tag = metadata[index]?.tag;
 
         if (view === undefined) {
             // shared pass/encode: encode if doesn't have a tag
@@ -111,13 +80,24 @@ export abstract class Schema {
 
     // allow inherited classes to have a constructor
     constructor(...args: any[]) {
-        Schema.initialize(this);
+        //
+        // inline
+        // Schema.initialize(this);
+        //
+
+        Object.defineProperty(this, $changes, {
+            value: new ChangeTree(this),
+            enumerable: false,
+            writable: true
+        });
+
+        Object.defineProperties(this, this.constructor[Symbol.metadata]?.[$descriptors] || {});
 
         //
         // Assign initial values
         //
         if (args[0]) {
-            this.assign(args[0]);
+            Object.assign(this, args[0]);
         }
     }
 
@@ -135,21 +115,25 @@ export abstract class Schema {
      * @param operation OPERATION to perform (detected automatically)
      */
     public setDirty<K extends NonFunctionPropNames<this>>(property: K | number, operation?: OPERATION) {
+        const metadata: Metadata = this.constructor[Symbol.metadata];
         this[$changes].change(
-            this.constructor[Symbol.metadata][property as string].index,
+            metadata[metadata[property as string]].index,
             operation
         );
     }
 
     clone (): this {
         const cloned = new ((this as any).constructor);
-        const metadata = this.constructor[Symbol.metadata];
+        const metadata: Metadata = this.constructor[Symbol.metadata];
 
         //
         // TODO: clone all properties, not only annotated ones
         //
         // for (const field in this) {
-        for (const field in metadata) {
+        for (const fieldIndex in metadata) {
+            // const field = metadata[metadata[fieldIndex]].name;
+            const field = metadata[fieldIndex as any as number].name;
+
             if (
                 typeof (this[field]) === "object" &&
                 typeof (this[field]?.clone) === "function"
@@ -162,15 +146,17 @@ export abstract class Schema {
                 cloned[field] = this[field];
             }
         }
+
         return cloned;
     }
 
     toJSON () {
-        const metadata = this.constructor[Symbol.metadata];
-
         const obj: unknown = {};
-        for (const fieldName in metadata) {
-            const field = metadata[fieldName];
+
+        const metadata = this.constructor[Symbol.metadata];
+        for (const index in metadata) {
+            const field = metadata[index];
+            const fieldName = field.name;
             if (!field.deprecated && this[fieldName] !== null && typeof (this[fieldName]) !== "undefined") {
                 obj[fieldName] = (typeof (this[fieldName]['toJSON']) === "function")
                     ? this[fieldName]['toJSON']()
@@ -185,11 +171,13 @@ export abstract class Schema {
     }
 
     protected [$getByIndex](index: number) {
-        return this[this.constructor[Symbol.metadata][index]];
+        const metadata: Metadata = this.constructor[Symbol.metadata];
+        return this[metadata[index].name];
     }
 
     protected [$deleteByIndex](index: number) {
-        this[this.constructor[Symbol.metadata][index]] = undefined;
+        const metadata: Metadata = this.constructor[Symbol.metadata];
+        this[metadata[index].name] = undefined;
     }
 
     static debugRefIds(instance: Ref, jsonContents: boolean = true, level: number = 0) {

package/src/annotations.ts

@@ -3,10 +3,12 @@ import { Schema } from './Schema';
 import { ArraySchema } from './types/custom/ArraySchema';
 import { MapSchema } from './types/custom/MapSchema';
 import { Metadata } from "./Metadata";
-import { $changes, $childType, $track } from "./types/symbols";
+import { $changes, $childType, $descriptors, $track } from "./types/symbols";
 import { TypeDefinition, getType } from "./types/registry";
 import { OPERATION } from "./encoding/spec";
 import { TypeContext } from "./types/TypeContext";
+import { assertInstanceType, assertType } from "./encoding/assert";
+import type { Ref } from "./encoder/ChangeTree";
 
 /**
  * Data types
@@ -227,18 +229,19 @@ export function view<T> (tag: number = DEFAULT_VIEW_TAG) {
 
         // TODO: use Metadata.initialize()
         const metadata: Metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
-
-        if (!metadata[fieldName]) {
-            //
-            // detect index for this field, considering inheritance
-            //
-            metadata[fieldName] = {
-                type: undefined,
-                index: (metadata[-1] // current structure already has fields defined
-                    ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
-                    ?? -1) + 1 // no fields defined
-            }
-        }
+        // const fieldIndex = metadata[fieldName];
+
+        // if (!metadata[fieldIndex]) {
+        //     //
+        //     // detect index for this field, considering inheritance
+        //     //
+        //     metadata[fieldIndex] = {
+        //         type: undefined,
+        //         index: (metadata[-1] // current structure already has fields defined
+        //             ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+        //             ?? -1) + 1 // no fields defined
+        //     }
+        // }
 
         Metadata.setTag(metadata, fieldName, tag);
     }
@@ -256,20 +259,20 @@ export function unreliable<T> (target: T, field: string) {
     // TODO: use Metadata.initialize()
     const metadata: Metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
 
-    if (!metadata[field]) {
-        //
-        // detect index for this field, considering inheritance
-        //
-        metadata[field] = {
-            type: undefined,
-            index: (metadata[-1] // current structure already has fields defined
-                ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
-                ?? -1) + 1 // no fields defined
-        }
-    }
+    // if (!metadata[field]) {
+    //     //
+    //     // detect index for this field, considering inheritance
+    //     //
+    //     metadata[field] = {
+    //         type: undefined,
+    //         index: (metadata[-1] // current structure already has fields defined
+    //             ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+    //             ?? -1) + 1 // no fields defined
+    //     }
+    // }
 
     // add owned flag to the field
-    metadata[field].unreliable = true;
+    metadata[metadata[field]].unreliable = true;
 }
 
 export function type (
@@ -290,17 +293,17 @@ export function type (
         const parentMetadata = parentClass && parentClass[Symbol.metadata];
         const metadata = Metadata.initialize(constructor, parentMetadata);
 
-        let fieldIndex: number;
+        let fieldIndex: number = metadata[field];
 
         /**
          * skip if descriptor already exists for this field (`@deprecated()`)
          */
-        if (metadata[field]) {
-            if (metadata[field].deprecated) {
+        if (metadata[fieldIndex]) {
+            if (metadata[fieldIndex].deprecated) {
                 // do not create accessors for deprecated properties.
                 return;
 
-            } else if (metadata[field].descriptor !== undefined) {
+            } else if (metadata[fieldIndex].type !== undefined) {
                 // trying to define same property multiple times across inheritance.
                 // https://github.com/colyseus/colyseus-unity3d/issues/131#issuecomment-814308572
                 try {
@@ -310,9 +313,6 @@ export function type (
                     const definitionAtLine = e.stack.split("\n")[4].trim();
                     throw new Error(`${e.message} ${definitionAtLine}`);
                 }
-
-            } else {
-                fieldIndex = metadata[field].index;
             }
 
         } else {
@@ -326,12 +326,18 @@ export function type (
         }
 
         if (options && options.manual) {
-            Metadata.addField(metadata, fieldIndex, field, type, {
-                // do not declare getter/setter descriptor
-                enumerable: true,
-                configurable: true,
-                writable: true,
-            });
+            Metadata.addField(
+                metadata,
+                fieldIndex,
+                field,
+                type,
+                {
+                    // do not declare getter/setter descriptor
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                }
+            );
 
         } else {
             const complexTypeKlass = (Array.isArray(type))
@@ -347,7 +353,7 @@ export function type (
                 fieldIndex,
                 field,
                 type,
-                getPropertyDescriptor(`_${field}`, fieldIndex, childType, complexTypeKlass, metadata, field)
+                getPropertyDescriptor(`_${field}`, fieldIndex, childType, complexTypeKlass)
             );
         }
     }
@@ -358,8 +364,6 @@ export function getPropertyDescriptor(
     fieldIndex: number,
     type: DefinitionType,
     complexTypeKlass: TypeDefinition,
-    metadata: Metadata,
-    field: string,
 ) {
     return {
         get: function () { return this[fieldCached]; },
@@ -385,30 +389,32 @@ export function getPropertyDescriptor(
                     }
 
                     value[$childType] = type;
+
+                } else if (typeof (type) !== "string") {
+                    assertInstanceType(value, type as typeof Schema, this, fieldCached.substring(1));
+
+                } else {
+                    assertType(value, type, this, fieldCached.substring(1));
                 }
 
+                const changeTree = this[$changes];
+
                 //
                 // Replacing existing "ref", remove it from root.
                 // TODO: if there are other references to this instance, we should not remove it from root.
                 //
                 if (previousValue !== undefined && previousValue[$changes]) {
-                    this[$changes].root?.remove(previousValue[$changes]);
+                    changeTree.root?.remove(previousValue[$changes]);
                 }
 
                 // flag the change for encoding.
-                this.constructor[$track](this[$changes], fieldIndex, OPERATION.ADD);
+                this.constructor[$track](changeTree, fieldIndex, OPERATION.ADD);
 
                 //
                 // call setParent() recursively for this and its child
                 // structures.
                 //
-                if (value[$changes]) {
-                    value[$changes].setParent(
-                        this,
-                        this[$changes].root,
-                        metadata[field].index,
-                    );
-                }
+                (value as Ref)[$changes]?.setParent(this, changeTree.root, fieldIndex);
 
             } else if (previousValue !== undefined) {
                 //
@@ -440,23 +446,25 @@ export function deprecated(throws: boolean = true): PropertyDecorator {
         const parentClass = Object.getPrototypeOf(constructor);
         const parentMetadata = parentClass[Symbol.metadata];
         const metadata: Metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
-
-        if (!metadata[field]) {
-            //
-            // detect index for this field, considering inheritance
-            //
-            metadata[field] = {
-                type: undefined,
-                index: (metadata[-1] // current structure already has fields defined
-                    ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
-                    ?? -1) + 1 // no fields defined
-            }
-        }
-
-        metadata[field].deprecated = true;
+        const fieldIndex = metadata[field];
+
+        // if (!metadata[field]) {
+        //     //
+        //     // detect index for this field, considering inheritance
+        //     //
+        //     metadata[field] = {
+        //         type: undefined,
+        //         index: (metadata[-1] // current structure already has fields defined
+        //             ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+        //             ?? -1) + 1 // no fields defined
+        //     }
+        // }
+
+        metadata[fieldIndex].deprecated = true;
 
         if (throws) {
-            metadata[field].descriptor = {
+            metadata[$descriptors] ??= {};
+            metadata[$descriptors][field] = {
                 get: function () { throw new Error(`${field} is deprecated.`); },
                 set: function (this: Schema, value: any) { /* throw new Error(`${field} is deprecated.`); */ },
                 enumerable: false,
@@ -465,8 +473,8 @@ export function deprecated(throws: boolean = true): PropertyDecorator {
         }
 
         // flag metadata[field] as non-enumerable
-        Object.defineProperty(metadata, field, {
-            value: metadata[field],
+        Object.defineProperty(metadata, fieldIndex, {
+            value: metadata[fieldIndex],
             enumerable: false,
             configurable: true
         });

package/src/bench_encode.ts

@@ -31,37 +31,40 @@ class State extends Schema {
 
 const state = new State();
 
-for (let i = 0; i < 50; i++) {
-    const player = new Player();
-    state.players.set(`p-${nanoid()}`, player);
-
-    player.position.x = (i + 1) * 100;
-    player.position.y = (i + 1) * 100;
-    for (let j = 0; j < 10; j++) {
-        const item = new Item();
-        item.price = (i + 1) * 50;
-        for (let k = 0; k < 5; k++) {
-            const attr = new Attribute();
-            attr.name = `Attribute ${k}`;
-            attr.value = k;
-            item.attributes.push(attr);
+Encoder.BUFFER_SIZE = 4096 * 4096;
+const encoder = new Encoder(state);
 
-        }
-        player.items.set(`item-${j}`, item);
-    }
-}
 
+let now = Date.now();
+
+// for (let i = 0; i < 10000; i++) {
+//     const player = new Player();
+//     state.players.set(`p-${nanoid()}`, player);
+//
+//     player.position.x = (i + 1) * 100;
+//     player.position.y = (i + 1) * 100;
+//     for (let j = 0; j < 10; j++) {
+//         const item = new Item();
+//         player.items.set(`item-${j}`, item);
+//         item.price = (i + 1) * 50;
+//         for (let k = 0; k < 5; k++) {
+//             const attr = new Attribute();
+//             attr.name = `Attribute ${k}`;
+//             attr.value = k;
+//             item.attributes.push(attr);
+//         }
+//     }
+// }
+// console.log("time to make changes:", Date.now() - now);
 
-Encoder.BUFFER_SIZE = 4096 * 4096;
-const encoder = new Encoder(state);
 
 // measure time to .encodeAll()
 
-let now = Date.now();
-for (let i = 0; i < 1000; i++) {
-    encoder.encodeAll();
-}
-console.log(Date.now() - now);
+now = Date.now();
+// for (let i = 0; i < 1000; i++) {
+//     encoder.encodeAll();
+// }
+// console.log(Date.now() - now);
 
 const allEncodes = Date.now();
 for (let i = 0; i < 100; i++) {
@@ -80,7 +83,6 @@ for (let i = 0; i < 100; i++) {
                 attr.name = `Attribute ${l}`;
                 attr.value = l;
                 item.attributes.push(attr);
-
             }
             player.items.set(`item-${k}`, item);
         }
@@ -94,4 +96,4 @@ for (let i = 0; i < 100; i++) {
 }
 console.log("time for all encodes:", Date.now() - allEncodes);
 
-console.log(Array.from(encoder.encodeAll()).length, "bytes");
+console.log(Array.from(encoder.encodeAll()).length, "bytes");

package/src/decoder/DecodeOperation.ts

@@ -105,7 +105,14 @@ export function decodeValue(
                 value = decoder.createInstanceOfType(childType);
             }
 
-            $root.addRef(refId, value, (value !== previousValue));
+            $root.addRef(
+                refId,
+                value,
+                (
+                    value !== previousValue || // increment ref count if value has changed
+                    (operation === OPERATION.DELETE_AND_ADD && value === previousValue) // increment ref count if the same instance is being added again
+                )
+            );
         }
 
 
@@ -174,7 +181,7 @@ export const decodeSchemaOperation: DecodeOperation = function (
     allChanges: DataChange[],
 ) {
     const first_byte = bytes[it.offset++];
-    const metadata: Metadata = ref['constructor'][Symbol.metadata];
+    const metadata: Metadata = ref.constructor[Symbol.metadata];
 
     // "compressed" index + operation
     const operation = (first_byte >> 6) << 6
@@ -192,14 +199,14 @@ export const decodeSchemaOperation: DecodeOperation = function (
         operation,
         ref,
         index,
-        metadata[field].type,
+        field.type,
         bytes,
         it,
         allChanges,
     );
 
     if (value !== null && value !== undefined) {
-        ref[field] = value;
+        ref[field.name] = value;
     }
 
     // add change
@@ -208,7 +215,7 @@ export const decodeSchemaOperation: DecodeOperation = function (
             ref,
             refId: decoder.currentRefId,
             op: operation,
-            field: field,
+            field: field.name,
             value,
             previousValue,
         });
@@ -308,8 +315,6 @@ export const decodeArray: DecodeOperation = function (
 ) {
     // "uncompressed" index + operation (array/map items)
     let operation = bytes[it.offset++];
-
-    let isSchemaChild: boolean;
     let index: number;
 
     if (operation === OPERATION.CLEAR) {
@@ -341,9 +346,6 @@ export const decodeArray: DecodeOperation = function (
         return;
 
     } else if (operation === OPERATION.ADD_BY_REFID) {
-        isSchemaChild = true;
-        // operation = OPERATION.ADD;
-
         const refId = decode.number(bytes, it);
         const itemByRefId = decoder.root.refs.get(refId);
 
@@ -353,7 +355,6 @@ export const decodeArray: DecodeOperation = function (
             : ref.length;
 
     } else {
-        isSchemaChild = false;
         index = decode.number(bytes, it);
     }
 

package/src/decoder/ReferenceTracker.ts

@@ -98,8 +98,9 @@ export class ReferenceTracker {
             // Ensure child schema instances have their references removed as well.
             //
             if (Metadata.isValidInstance(ref)) {
-                const metadata: Metadata = ref['constructor'][Symbol.metadata];
-                for (const field in metadata) {
+                const metadata: Metadata = ref.constructor[Symbol.metadata];
+                for (const index in metadata) {
+                    const field = metadata[index as any as number].name;
                     const childRefId = typeof(ref[field]) === "object" && this.refIds.get(ref[field]);
                     if (childRefId) {
                         this.removeRef(childRefId);

package/src/decoder/strategy/StateCallbacks.ts

@@ -264,7 +264,7 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
                 //
                 bindTo: function bindTo(targetObject: any, properties?: string[]) {
                     if (!properties) {
-                        properties = Object.keys(metadata);
+                        properties = Object.keys(metadata).map((index) => metadata[index as any as number].name);
                     }
                     return $root.addCallback(
                         $root.refIds.get(context.instance),
@@ -277,7 +277,8 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
                 }
             }, {
                 get(target, prop: string) {
-                    if (metadata[prop]) {
+                    const metadataField = metadata[metadata[prop]];
+                    if (metadataField) {
                         const instance = context.instance?.[prop];
                         const onInstanceAvailable: OnInstanceAvailableCallback = (
                             (callback: (ref: Ref, existing: boolean) => void) => {
@@ -297,7 +298,7 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
                                 }
                             }
                         );
-                        return getProxy(metadata[prop].type, {
+                        return getProxy(metadataField.type, {
                             // make sure refId is available, otherwise need to wait for the instance to be available.
                             instance: ($root.refIds.get(instance) && instance),
                             parentInstance: context.instance,