@colyseus/schema 3.0.0-alpha.9 → 3.0.0

package/src/Schema.ts

@@ -1,10 +1,10 @@
 import { OPERATION } from './encoding/spec';
-import { DEFAULT_VIEW_TAG, DefinitionType } from "./annotations";
+import { DEFAULT_VIEW_TAG, type 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 { ChangeSet, ChangeTree, Ref } from './encoder/ChangeTree';
+import { $changes, $decoder, $deleteByIndex, $descriptors, $encoder, $filter, $getByIndex, $track } from './types/symbols';
 import { StateView } from './encoder/StateView';
 
 import { encodeSchemaOperation } from './encoder/EncodeOperation';
@@ -15,11 +15,12 @@ import { getIndent } from './utils';
 /**
  * Schema encoder / decoder
  */
-export abstract class Schema {
-
+export class Schema {
     static [$encoder] = encodeSchemaOperation;
     static [$decoder] = decodeSchemaOperation;
 
+    // public [$changes]: ChangeTree;
+
     /**
      * Assign the property descriptors required to track changes on this instance.
      * @param instance
@@ -31,37 +32,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 +59,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 +82,17 @@ export abstract class Schema {
 
     // allow inherited classes to have a constructor
     constructor(...args: any[]) {
+        //
+        // inline
+        // Schema.initialize(this);
+        //
         Schema.initialize(this);
 
         //
         // Assign initial values
         //
         if (args[0]) {
-            this.assign(args[0]);
+            Object.assign(this, args[0]);
         }
     }
 
@@ -135,21 +110,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 +141,16 @@ 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,24 +165,33 @@ 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) {
+    /**
+     * Inspect the `refId` of all Schema instances in the tree. Optionally display the contents of the instance.
+     *
+     * @param instance Schema instance
+     * @param showContents display JSON contents of the instance
+     * @returns
+     */
+    static debugRefIds(instance: Ref, showContents: boolean = false, level: number = 0) {
         const ref = instance;
         const changeTree = ref[$changes];
 
-        const contents = (jsonContents) ? ` - ${JSON.stringify(ref.toJSON())}` : "";
+        const contents = (showContents) ? ` - ${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));
+            output += this.debugRefIds(childChangeTree.ref, showContents, level + 1));
 
         return output;
     }
@@ -216,31 +205,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);
         }
@@ -248,16 +247,19 @@ export abstract class Schema {
         return output;
     }
 
-    static debugChangesDeep(ref: Ref) {
+    static debugChangesDeep(ref: Ref, changeSetName: "changes" | "allChanges" | "allFilteredChanges" | "filteredChanges" = "changes") {
         let output = "";
 
         const rootChangeTree = ref[$changes];
+        const root = rootChangeTree.root;
         const changeTrees: Map<ChangeTree, ChangeTree[]> = new Map();
 
-        let totalInstances = 0;
+        const instanceRefIds = [];
         let totalOperations = 0;
 
-        for (const [changeTree, changes] of (rootChangeTree.root.changes.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];
@@ -277,15 +279,15 @@ export abstract class Schema {
             }
 
             if (includeChangeTree) {
-                totalInstances += 1;
-                totalOperations += changes.size;
+                instanceRefIds.push(changeTree.refId);
+                totalOperations += Object.keys(changes).length;
                 changeTrees.set(changeTree, parentChangeTrees.reverse());
             }
         }
 
         output += "---\n"
         output += `root refId: ${rootChangeTree.refId}\n`;
-        output += `Total instances: ${totalInstances}\n`;
+        output += `Total instances: ${instanceRefIds.length} (refIds: ${instanceRefIds.join(", ")})\n`;
         output += `Total changes: ${totalOperations}\n`;
         output += "---\n"
 
@@ -299,17 +301,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}`;