@colyseus/schema 3.0.0-alpha.34 → 3.0.0-alpha.36

package/src/Metadata.ts

@@ -1,6 +1,8 @@
 import { getPropertyDescriptor, type DefinitionType } from "./annotations";
+import { Schema } from "./Schema";
 import { getType } from "./types/registry";
-import { $descriptors } from "./types/symbols";
+import { $decoder, $descriptors, $encoder, $fieldIndexesByViewTag, $numFields, $refTypeFieldIndexes, $track, $viewFieldIndexes } from "./types/symbols";
+import { TypeContext } from "./types/TypeContext";
 
 export type MetadataField = {
     type: DefinitionType,
@@ -12,10 +14,10 @@ export type MetadataField = {
 };
 
 export type Metadata =
-    { [-1]: number; } & // number of fields
-    { [-2]: number[]; } & // all field indexes with "view" tag
-    { [-3]: {[tag: number]: number[]}; } & // field indexes by "view" tag
-    { [-4]: number[]; } & // all field indexes containing Ref types (Schema, ArraySchema, MapSchema, etc)
+    { [$numFields]: number; } & // number of fields
+    { [$viewFieldIndexes]: number[]; } & // all field indexes with "view" tag
+    { [$fieldIndexesByViewTag]: {[tag: number]: number[]}; } & // field indexes by "view" tag
+    { [$refTypeFieldIndexes]: number[]; } & // all field indexes containing Ref types (Schema, ArraySchema, MapSchema, etc)
     { [field: number]: MetadataField; } & // index => field name
     { [field: string]: number; } & // field name => field metadata
     { [$descriptors]: { [field: string]: PropertyDescriptor } }  // property descriptors
@@ -61,7 +63,7 @@ export const Metadata = {
         }
 
         // map -1 as last field index
-        Object.defineProperty(metadata, -1, {
+        Object.defineProperty(metadata, $numFields, {
             value: index,
             enumerable: false,
             configurable: true
@@ -76,14 +78,14 @@ export const Metadata = {
 
         // if child Ref/complex type, add to -4
         if (typeof (metadata[index].type) !== "string") {
-            if (metadata[-4] === undefined) {
-                Object.defineProperty(metadata, -4, {
+            if (metadata[$refTypeFieldIndexes] === undefined) {
+                Object.defineProperty(metadata, $refTypeFieldIndexes, {
                     value: [],
                     enumerable: false,
                     configurable: true,
                 });
             }
-            metadata[-4].push(index);
+            metadata[$refTypeFieldIndexes].push(index);
         }
     },
 
@@ -94,35 +96,55 @@ export const Metadata = {
         // add 'tag' to the field
         field.tag = tag;
 
-        if (!metadata[-2]) {
+        if (!metadata[$viewFieldIndexes]) {
             // -2: all field indexes with "view" tag
-            Object.defineProperty(metadata, -2, {
+            Object.defineProperty(metadata, $viewFieldIndexes, {
                 value: [],
                 enumerable: false,
                 configurable: true
             });
 
             // -3: field indexes by "view" tag
-            Object.defineProperty(metadata, -3, {
+            Object.defineProperty(metadata, $fieldIndexesByViewTag, {
                 value: {},
                 enumerable: false,
                 configurable: true
             });
         }
 
-        metadata[-2].push(index);
+        metadata[$viewFieldIndexes].push(index);
 
-        if (!metadata[-3][tag]) {
-            metadata[-3][tag] = [];
+        if (!metadata[$fieldIndexesByViewTag][tag]) {
+            metadata[$fieldIndexesByViewTag][tag] = [];
         }
 
-        metadata[-3][tag].push(index);
+        metadata[$fieldIndexesByViewTag][tag].push(index);
     },
 
     setFields(target: any, fields: { [field: string]: DefinitionType }) {
-        const metadata = (target.prototype.constructor[Symbol.metadata] ??= {});
+        // for inheritance support
+        const constructor = target.prototype.constructor;
+        TypeContext.register(constructor);
+
+        const parentClass = Object.getPrototypeOf(constructor);
+        const parentMetadata = parentClass && parentClass[Symbol.metadata];
+        const metadata = Metadata.initialize(constructor, parentMetadata);
+
+        // Use Schema's methods if not defined in the class
+        if (!constructor[$track]) { constructor[$track] = Schema[$track]; }
+        if (!constructor[$encoder]) { constructor[$encoder] = Schema[$encoder]; }
+        if (!constructor[$decoder]) { constructor[$decoder] = Schema[$decoder]; }
+        if (!constructor.prototype.toJSON) { constructor.prototype.toJSON = Schema.prototype.toJSON; }
+
+        //
+        // detect index for this field, considering inheritance
+        //
+        let fieldIndex = metadata[$numFields] // current structure already has fields defined
+            ?? (parentMetadata && parentMetadata[$numFields]) // parent structure has fields defined
+            ?? -1; // no fields defined
+
+        fieldIndex++;
 
-        let index = 0;
         for (const field in fields) {
             const type = fields[field];
 
@@ -133,14 +155,16 @@ export const Metadata = {
 
             Metadata.addField(
                 metadata,
-                index,
+                fieldIndex,
                 field,
                 type,
-                getPropertyDescriptor(`_${field}`, index, type, complexTypeKlass)
+                getPropertyDescriptor(`_${field}`, fieldIndex, type, complexTypeKlass)
             );
 
-            index++;
+            fieldIndex++;
         }
+
+        return target;
     },
 
     isDeprecated(metadata: any, field: string) {
@@ -154,7 +178,7 @@ export const Metadata = {
         //
         const metadata = {};
         klass[Symbol.metadata] = metadata;
-        Object.defineProperty(metadata, -1, {
+        Object.defineProperty(metadata, $numFields, {
             value: 0,
             enumerable: false,
             configurable: true,
@@ -172,7 +196,7 @@ export const Metadata = {
                 // assign parent metadata to current
                 Object.assign(metadata, parentMetadata);
 
-                for (let i = 0; i <= parentMetadata[-1]; i++) {
+                for (let i = 0; i <= parentMetadata[$numFields]; i++) {
                     const fieldName = parentMetadata[i].name;
                     Object.defineProperty(metadata, fieldName, {
                         value: parentMetadata[fieldName],
@@ -181,8 +205,8 @@ export const Metadata = {
                     });
                 }
 
-                Object.defineProperty(metadata, -1, {
-                    value: parentMetadata[-1],
+                Object.defineProperty(metadata, $numFields, {
+                    value: parentMetadata[$numFields],
                     enumerable: false,
                     configurable: true,
                     writable: true,
@@ -198,14 +222,14 @@ export const Metadata = {
     isValidInstance(klass: any) {
         return (
             klass.constructor[Symbol.metadata] &&
-            Object.prototype.hasOwnProperty.call(klass.constructor[Symbol.metadata], -1) as boolean
+            Object.prototype.hasOwnProperty.call(klass.constructor[Symbol.metadata], $numFields) as boolean
         );
     },
 
     getFields(klass: any) {
         const metadata: Metadata = klass[Symbol.metadata];
         const fields = {};
-        for (let i = 0; i <= metadata[-1]; i++) {
+        for (let i = 0; i <= metadata[$numFields]; i++) {
             fields[metadata[i].name] = metadata[i].type;
         }
         return fields;

package/src/Reflection.ts

@@ -25,11 +25,16 @@ export class ReflectionType extends Schema {
 export class Reflection extends Schema {
     @type([ ReflectionType ]) types: ArraySchema<ReflectionType> = new ArraySchema<ReflectionType>();
 
-    static encode(instance: Schema, context?: TypeContext, it: Iterator = { offset: 0 }) {
-        context ??= new TypeContext(instance.constructor as typeof Schema);
-
+    /**
+     * Encodes the TypeContext of an Encoder into a buffer.
+     *
+     * @param context TypeContext instance
+     * @param it
+     * @returns
+     */
+    static encode(context: TypeContext, it: Iterator = { offset: 0 }) {
         const reflection = new Reflection();
-        const encoder = new Encoder(reflection);
+        const reflectionEncoder = new Encoder(reflection);
 
         const buildType = (currentType: ReflectionType, metadata: Metadata) => {
             for (const fieldIndex in metadata) {
@@ -98,11 +103,18 @@ export class Reflection extends Schema {
             buildType(type, klass[Symbol.metadata]);
         }
 
-        const buf = encoder.encodeAll(it);
+        const buf = reflectionEncoder.encodeAll(it);
         return Buffer.from(buf, 0, it.offset);
     }
 
-    static decode<T extends Schema = Schema>(bytes: Buffer, it?: Iterator): T {
+    /**
+     * Decodes the TypeContext from a buffer into a Decoder instance.
+     *
+     * @param bytes Reflection.encode() output
+     * @param it
+     * @returns Decoder instance
+     */
+    static decode<T extends Schema = Schema>(bytes: Buffer, it?: Iterator): Decoder<T> {
         const reflection = new Reflection();
 
         const reflectionDecoder = new Decoder(reflection);
@@ -160,7 +172,8 @@ export class Reflection extends Schema {
             });
         });
 
-        // @ts-ignore
-        return new (typeContext.get(0))();
+        const state: T = new (typeContext.get(0) as unknown as any)();
+
+        return new Decoder<T>(state, typeContext);
     }
 }

package/src/Schema.ts

@@ -3,7 +3,7 @@ import { DEFAULT_VIEW_TAG, DefinitionType } from "./annotations";
 
 import { NonFunctionPropNames, ToJSON } from './types/HelperTypes';
 
-import { ChangeTree, Ref } from './encoder/ChangeTree';
+import { ChangeSet, ChangeTree, Ref } from './encoder/ChangeTree';
 import { $changes, $decoder, $deleteByIndex, $descriptors, $encoder, $filter, $getByIndex, $track } from './types/symbols';
 import { StateView } from './encoder/StateView';
 
@@ -19,6 +19,8 @@ export abstract class Schema {
     static [$encoder] = encodeSchemaOperation;
     static [$decoder] = decodeSchemaOperation;
 
+    // public [$changes]: ChangeTree;
+
     /**
      * Assign the property descriptors required to track changes on this instance.
      * @param instance
@@ -84,14 +86,7 @@ export abstract class Schema {
         // inline
         // Schema.initialize(this);
         //
-
-        Object.defineProperty(this, $changes, {
-            value: new ChangeTree(this),
-            enumerable: false,
-            writable: true
-        });
-
-        Object.defineProperties(this, this.constructor[Symbol.metadata]?.[$descriptors] || {});
+        Schema.initialize(this);
 
         //
         // Assign initial values
@@ -187,7 +182,7 @@ export abstract class Schema {
         const contents = (jsonContents) ? ` - ${JSON.stringify(ref.toJSON())}` : "";
 
         let output = "";
-        output += `${getIndent(level)}${ref.constructor.name} (${ref[$changes].refId})${contents}\n`;
+        output += `${getIndent(level)}${ref.constructor.name} (refId: ${ref[$changes].refId})${contents}\n`;
 
         changeTree.forEachChild((childChangeTree) =>
             output += this.debugRefIds(childChangeTree.ref, jsonContents, level + 1));
@@ -204,31 +199,41 @@ export abstract class Schema {
      * @returns
      */
     static debugChanges(instance: Ref, isEncodeAll: boolean = false) {
-        const changeTree = instance[$changes];
+        const changeTree: ChangeTree = instance[$changes];
 
         const changeSet = (isEncodeAll) ? changeTree.allChanges : changeTree.changes;
         const changeSetName = (isEncodeAll) ? "allChanges" : "changes";
 
         let output = `${instance.constructor.name} (${changeTree.refId}) -> .${changeSetName}:\n`;
 
-        function dumpChangeSet(changeSet: Map<number, OPERATION>) {
-            Array.from(changeSet)
-                .sort((a, b) => a[0] - b[0])
-                .forEach(([index, operation]) =>
-                    output += `- [${index}]: ${OPERATION[operation]} (${JSON.stringify(changeTree.getValue(index, isEncodeAll))})\n`
-                );
+        function dumpChangeSet(changeSet: ChangeSet) {
+            changeSet.operations
+                .filter(op => op)
+                .forEach((index) => {
+                    const operation = changeTree.indexedOperations[index];
+                    console.log({ index, operation })
+                    output += `- [${index}]: ${OPERATION[operation]} (${JSON.stringify(changeTree.getValue(Number(index), isEncodeAll))})\n`
+                });
         }
 
         dumpChangeSet(changeSet);
 
         // display filtered changes
-        if (!isEncodeAll && changeTree.filteredChanges?.size > 0) {
+        if (
+            !isEncodeAll &&
+            changeTree.filteredChanges &&
+            (changeTree.filteredChanges.operations).filter(op => op).length > 0
+        ) {
             output += `${instance.constructor.name} (${changeTree.refId}) -> .filteredChanges:\n`;
             dumpChangeSet(changeTree.filteredChanges);
         }
 
         // display filtered changes
-        if (isEncodeAll && changeTree.allFilteredChanges?.size > 0) {
+        if (
+            isEncodeAll &&
+            changeTree.allFilteredChanges &&
+            (changeTree.allFilteredChanges.operations).filter(op => op).length > 0
+        ) {
             output += `${instance.constructor.name} (${changeTree.refId}) -> .allFilteredChanges:\n`;
             dumpChangeSet(changeTree.allFilteredChanges);
         }
@@ -240,12 +245,15 @@ export abstract class Schema {
         let output = "";
 
         const rootChangeTree = ref[$changes];
+        const root = rootChangeTree.root;
         const changeTrees: Map<ChangeTree, ChangeTree[]> = new Map();
 
         let totalInstances = 0;
         let totalOperations = 0;
 
-        for (const [changeTree, changes] of (rootChangeTree.root[changeSetName].entries())) {
+        for (const [refId, changes] of Object.entries(root[changeSetName])) {
+            const changeTree = root.changeTrees[refId];
+
             let includeChangeTree = false;
             let parentChangeTrees: ChangeTree[] = [];
             let parentChangeTree = changeTree.parent?.[$changes];
@@ -266,7 +274,7 @@ export abstract class Schema {
 
             if (includeChangeTree) {
                 totalInstances += 1;
-                totalOperations += changes.size;
+                totalOperations += Object.keys(changes).length;
                 changeTrees.set(changeTree, parentChangeTrees.reverse());
             }
         }
@@ -287,17 +295,17 @@ export abstract class Schema {
                 }
             });
 
-            const changes = changeTree.changes;
+            const changes = changeTree.indexedOperations;
             const level = parentChangeTrees.length;
             const indent = getIndent(level);
 
             const parentIndex = (level > 0) ? `(${changeTree.parentIndex}) ` : "";
-            output += `${indent}${parentIndex}${changeTree.ref.constructor.name} (refId: ${changeTree.refId}) - changes: ${changes.size}\n`;
+            output += `${indent}${parentIndex}${changeTree.ref.constructor.name} (refId: ${changeTree.refId}) - changes: ${Object.keys(changes).length}\n`;
 
-            for (const [index, operation] of changes) {
+            for (const index in changes) {
+                const operation = changes[index];
                 output += `${getIndent(level + 1)}${OPERATION[operation]}: ${index}\n`;
             }
-
         }
 
         return `${output}`;

package/src/annotations.ts

@@ -3,7 +3,7 @@ import { Schema } from './Schema';
 import { ArraySchema } from './types/custom/ArraySchema';
 import { MapSchema } from './types/custom/MapSchema';
 import { Metadata } from "./Metadata";
-import { $changes, $childType, $descriptors, $track } from "./types/symbols";
+import { $changes, $childType, $descriptors, $numFields, $track } from "./types/symbols";
 import { TypeDefinition, getType } from "./types/registry";
 import { OPERATION } from "./encoding/spec";
 import { TypeContext } from "./types/TypeContext";
@@ -45,12 +45,8 @@ export interface TypeOptions {
 
 export const DEFAULT_VIEW_TAG = -1;
 
-export function entity(constructor, context: ClassDecoratorContext) {
-    if (!constructor._definition) {
-        // for inheritance support
-        TypeContext.register(constructor);
-    }
-
+export function entity(constructor) {
+    TypeContext.register(constructor);
     return constructor;
 }
 
@@ -82,8 +78,8 @@ export function entity(constructor, context: ClassDecoratorContext) {
 //         // detect index for this field, considering inheritance
 //         //
 //         const parent = Object.getPrototypeOf(context.metadata);
-//         let fieldIndex: number = context.metadata[-1] // current structure already has fields defined
-//             ?? (parent && parent[-1]) // parent structure has fields defined
+//         let fieldIndex: number = context.metadata[$numFields] // current structure already has fields defined
+//             ?? (parent && parent[$numFields]) // parent structure has fields defined
 //             ?? -1; // no fields defined
 //         fieldIndex++;
 
@@ -237,8 +233,8 @@ export function view<T> (tag: number = DEFAULT_VIEW_TAG) {
         //     //
         //     metadata[fieldIndex] = {
         //         type: undefined,
-        //         index: (metadata[-1] // current structure already has fields defined
-        //             ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+        //         index: (metadata[$numFields] // current structure already has fields defined
+        //             ?? (parentMetadata && parentMetadata[$numFields]) // parent structure has fields defined
         //             ?? -1) + 1 // no fields defined
         //     }
         // }
@@ -265,8 +261,8 @@ export function unreliable<T> (target: T, field: string) {
     //     //
     //     metadata[field] = {
     //         type: undefined,
-    //         index: (metadata[-1] // current structure already has fields defined
-    //             ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+    //         index: (metadata[$numFields] // current structure already has fields defined
+    //             ?? (parentMetadata && parentMetadata[$numFields]) // parent structure has fields defined
     //             ?? -1) + 1 // no fields defined
     //     }
     // }
@@ -319,8 +315,8 @@ export function type (
             //
             // detect index for this field, considering inheritance
             //
-            fieldIndex = metadata[-1] // current structure already has fields defined
-                ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+            fieldIndex = metadata[$numFields] // current structure already has fields defined
+                ?? (parentMetadata && parentMetadata[$numFields]) // parent structure has fields defined
                 ?? -1; // no fields defined
             fieldIndex++;
         }
@@ -368,7 +364,7 @@ export function getPropertyDescriptor(
     return {
         get: function () { return this[fieldCached]; },
         set: function (this: Schema, value: any) {
-            const previousValue = this[fieldCached] || undefined;
+            const previousValue = this[fieldCached] ?? undefined;
 
             // skip if value is the same as cached.
             if (value === previousValue) { return; }
@@ -454,8 +450,8 @@ export function deprecated(throws: boolean = true): PropertyDecorator {
         //     //
         //     metadata[field] = {
         //         type: undefined,
-        //         index: (metadata[-1] // current structure already has fields defined
-        //             ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+        //         index: (metadata[$numFields] // current structure already has fields defined
+        //             ?? (parentMetadata && parentMetadata[$numFields]) // parent structure has fields defined
         //             ?? -1) + 1 // no fields defined
         //     }
         // }

package/src/bench_encode.ts

@@ -1,8 +1,5 @@
 import { nanoid } from "nanoid";
 import { Schema, type, MapSchema, ArraySchema, Encoder } from ".";
-import * as benchmark from "benchmark";
-
-const suite = new benchmark.Suite();
 
 class Attribute extends Schema {
     @type("string") name: string;
@@ -66,8 +63,13 @@ now = Date.now();
 // }
 // console.log(Date.now() - now);
 
+const total = 100;
 const allEncodes = Date.now();
-for (let i = 0; i < 100; i++) {
+
+let avgTimeToEncode = 0;
+let avgTimeToMakeChanges = 0;
+
+for (let i = 0; i < total; i++) {
     now = Date.now();
     for (let j = 0; j < 50; j++) {
         const player = new Player();
@@ -87,13 +89,20 @@ for (let i = 0; i < 100; i++) {
             player.items.set(`item-${k}`, item);
         }
     }
-    console.log("time to make changes:", Date.now() - now);
+    const timeToMakeChanges = Date.now() - now;
+    console.log("time to make changes:", timeToMakeChanges);
+    avgTimeToMakeChanges += timeToMakeChanges;
 
     now = Date.now();
     encoder.encode();
     encoder.discardChanges();
-    console.log("time to encode:", Date.now() - now);
+
+    const timeToEncode = Date.now() - now;
+    console.log("time to encode:", timeToEncode);
+    avgTimeToEncode += timeToEncode;
 }
+console.log("avg time to encode:", (avgTimeToEncode) / total);
+console.log("avg time to make changes:", (avgTimeToMakeChanges) / total);
 console.log("time for all encodes:", Date.now() - allEncodes);
 
 console.log(Array.from(encoder.encodeAll()).length, "bytes");

package/src/debug.ts

@@ -42,8 +42,7 @@ contents.split("\n").forEach((line) => {
     isCommentBlock = false;
 
     if (line.startsWith("handshake:") && !decoder) {
-        const state = Reflection.decode(getBuffer(line));
-        decoder = new Decoder(state);
+        decoder = Reflection.decode(getBuffer(line));
 
     } else if (line.startsWith("state:")) {
         decode(getBuffer(line));

package/src/decoder/Decoder.ts

@@ -68,7 +68,7 @@ export class Decoder<T extends Schema = any> {
                 ref[$onDecodeEnd]?.()
                 ref = nextRef;
 
-                decoder = ref['constructor'][$decoder];
+                decoder = ref.constructor[$decoder];
 
                 continue;
             }