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

package/src/encoder/Encoder.ts

@@ -1,6 +1,6 @@
 import type { Schema } from "../Schema";
 import { TypeContext } from "../types/TypeContext";
-import { $changes, $encoder, $filter } from "../types/symbols";
+import { $changes, $encoder, $filter, $isNew, $onEncodeEnd } from "../types/symbols";
 
 import * as encode from "../encoding/encode";
 import type { Iterator } from "../encoding/decode";
@@ -55,12 +55,12 @@ export class Encoder<T extends Schema = any> {
         const hasView = (view !== undefined);
         const rootChangeTree = this.state[$changes];
 
-        const changeTreesIterator = changeTrees.entries();
+        const shouldClearChanges = !isEncodeAll && !hasView;
 
-        for (const [changeTree, changes] of changeTreesIterator) {
+        for (const [changeTree, changes] of changeTrees.entries()) {
             const ref = changeTree.ref;
 
-            const ctor = ref['constructor'];
+            const ctor = ref.constructor;
             const encoder = ctor[$encoder];
             const filter = ctor[$filter];
 
@@ -88,9 +88,7 @@ export class Encoder<T extends Schema = any> {
                 encode.number(buffer, changeTree.refId, it);
             }
 
-            const changesIterator = changes.entries();
-
-            for (const [fieldIndex, operation] of changesIterator) {
+            for (const [fieldIndex, operation] of changes.entries()) {
                 //
                 // first pass (encodeAll), identify "filtered" operations without encoding them
                 // they will be encoded per client, based on their view.
@@ -117,6 +115,17 @@ export class Encoder<T extends Schema = any> {
 
                 encoder(this, buffer, changeTree, fieldIndex, operation, it, isEncodeAll, hasView);
             }
+
+            // if (shouldClearChanges) {
+            //     // changeTree.endEncode();
+            //     changeTree.changes.clear();
+
+            //     // ArraySchema and MapSchema have a custom "encode end" method
+            //     changeTree.ref[$onEncodeEnd]?.();
+
+            //     // Not a new instance anymore
+            //     delete changeTree[$isNew];
+            // }
         }
 
         if (it.offset > buffer.byteLength) {
@@ -143,7 +152,7 @@ export class Encoder<T extends Schema = any> {
             //
             // only clear changes after making sure buffer resize is not required.
             //
-            if (!isEncodeAll && !hasView) {
+            if (shouldClearChanges) {
                 //
                 // FIXME: avoid iterating over change trees twice.
                 //
@@ -251,6 +260,14 @@ export class Encoder<T extends Schema = any> {
         const changeTreesIterator = changeTrees.entries();
         for (const [changeTree, _] of changeTreesIterator) {
             changeTree.endEncode();
+            // changeTree.changes.clear();
+
+            // // ArraySchema and MapSchema have a custom "encode end" method
+            // changeTree.ref[$onEncodeEnd]?.();
+
+            // // Not a new instance anymore
+            // delete changeTree[$isNew];
+
         }
     }
 

package/src/encoder/Root.ts

@@ -21,13 +21,28 @@ export class Root {
     }
 
     add(changeTree: ChangeTree) {
-        const refCount = this.refCount.get(changeTree) || 0;
-        this.refCount.set(changeTree, refCount + 1);
+        const previousRefCount = this.refCount.get(changeTree);
+
+        if (previousRefCount === 0) {
+            //
+            // When a ChangeTree is re-added, it means that it was previously removed.
+            // We need to re-add all changes to the `changes` map.
+            //
+            changeTree.allChanges.forEach((operation, index) => {
+                changeTree.changes.set(index, operation);
+            });
+        }
+
+        const refCount = (previousRefCount || 0) + 1;
+        this.refCount.set(changeTree, refCount);
+
+        return refCount;
     }
 
     remove(changeTree: ChangeTree) {
-        const refCount = this.refCount.get(changeTree);
-        if (refCount <= 1) {
+        const refCount = (this.refCount.get(changeTree)) - 1;
+
+        if (refCount <= 0) {
             this.allChanges.delete(changeTree);
             this.changes.delete(changeTree);
 
@@ -36,13 +51,15 @@ export class Root {
                 this.filteredChanges.delete(changeTree);
             }
 
-            this.refCount.delete(changeTree);
+            this.refCount.set(changeTree, 0);
 
         } else {
-            this.refCount.set(changeTree, refCount - 1);
+            this.refCount.set(changeTree, refCount);
         }
 
         changeTree.forEachChild((child, _) => this.remove(child));
+
+        return refCount;
     }
 
     clear() {

package/src/encoder/StateView.ts

@@ -34,7 +34,7 @@ export class StateView {
             return this;
         }
 
-        // FIXME: ArraySchema/MapSchema does not have metadata
+        // FIXME: ArraySchema/MapSchema do not have metadata
         const metadata: Metadata = obj.constructor[Symbol.metadata];
         const changeTree: ChangeTree = obj[$changes];
         this.items.add(changeTree);
@@ -84,7 +84,7 @@ export class StateView {
                 : changeTree.allChanges;
 
             changeSet.forEach((op, index) => {
-                const tagAtIndex = metadata?.[metadata?.[index]].tag;
+                const tagAtIndex = metadata?.[index].tag;
                 if (
                     (
                         isInvisible || // if "invisible", include all
@@ -101,7 +101,7 @@ export class StateView {
         // Add children of this ChangeTree to this view
         changeTree.forEachChild((change, index) => {
             // Do not ADD children that don't have the same tag
-            if (metadata && metadata[metadata[index]].tag !== tag) {
+            if (metadata && metadata[index].tag !== tag) {
                 return;
             }
             this.add(change.ref, tag, false);
@@ -166,7 +166,7 @@ export class StateView {
         let changes = this.changes.get(changeTree);
         if (changes === undefined) {
             changes = new Map<number, OPERATION>();
-            this.changes.set(changeTree, changes)
+            this.changes.set(changeTree, changes);
         }
 
         if (tag === DEFAULT_VIEW_TAG) {

package/src/encoding/assert.ts

@@ -3,6 +3,7 @@ import { CollectionSchema } from "../types/custom/CollectionSchema";
 import { MapSchema } from "../types/custom/MapSchema";
 import { SetSchema } from "../types/custom/SetSchema";
 import { ArraySchema } from "../types/custom/ArraySchema";
+import type { Ref } from "../encoder/ChangeTree";
 
 export class EncodeSchemaError extends Error {}
 
@@ -43,16 +44,16 @@ export function assertType(value: any, type: string, klass: Schema, field: strin
 }
 
 export function assertInstanceType(
-    value: Schema,
+    value: Ref,
     type: typeof Schema
         | typeof ArraySchema
         | typeof MapSchema
         | typeof CollectionSchema
         | typeof SetSchema,
-    klass: Schema,
+    instance: Ref,
     field: string | number,
 ) {
     if (!(value instanceof type)) {
-        throw new EncodeSchemaError(`a '${type.name}' was expected, but '${value && (value as any).constructor.name}' was provided in ${klass.constructor.name}#${field}`);
+        throw new EncodeSchemaError(`a '${type.name}' was expected, but '${value && (value as any).constructor.name}' was provided in ${instance.constructor.name}#${field}`);
     }
 }

package/src/index.ts

@@ -1,9 +1,5 @@
 export { Schema } from "./Schema";
 export type { DataChange } from "./decoder/DecodeOperation";
-
-import { $track, $encoder, $decoder, $filter, $getByIndex, $deleteByIndex, $changes, $childType } from "./types/symbols";
-export { $track, $encoder, $decoder, $filter, $getByIndex, $deleteByIndex, $changes, $childType };
-
 export type { ToJSON } from "./types/HelperTypes";
 
 import { MapSchema } from "./types/custom/MapSchema"
@@ -30,6 +26,7 @@ registerType("collection", { constructor: CollectionSchema, });
 export { dumpChanges } from "./utils";
 
 // Encoder / Decoder
+export { $track, $encoder, $decoder, $filter, $getByIndex, $deleteByIndex, $changes, $childType } from "./types/symbols";
 export type { Iterator } from "./encoding/decode";
 import * as encode from "./encoding/encode";
 import * as decode from "./encoding/decode";

package/src/types/TypeContext.ts

@@ -84,19 +84,11 @@ export class TypeContext {
             this.parentFiltered[`${this.schemas.get(klass)}-${parentIndex}`] = true;
         }
 
-        for (const field in metadata) {
-            // //
-            // // Modify the field's metadata to include the parent field's view tag
-            // //
-            // if (
-            //     parentFieldViewTag !== undefined &&
-            //     metadata[field].tag === undefined
-            // ) {
-            //     metadata[field].tag = parentFieldViewTag;
-            // }
-
-            const fieldType = metadata[field].type;
-            const viewTag = metadata[field].tag;
+        for (const fieldIndex in metadata) {
+            const index = fieldIndex as any as number;
+
+            const fieldType = metadata[index].type;
+            const viewTag = metadata[index].tag;
 
             if (typeof (fieldType) === "string") {
                 continue;
@@ -104,10 +96,13 @@ export class TypeContext {
 
             if (Array.isArray(fieldType)) {
                 const type = fieldType[0];
+
+                // skip primitive types
                 if (type === "string") {
                     continue;
                 }
-                this.discoverTypes(type as typeof Schema, metadata[field].index, viewTag);
+
+                this.discoverTypes(type as typeof Schema, index, viewTag);
 
             } else if (typeof (fieldType) === "function") {
                 this.discoverTypes(fieldType as typeof Schema, viewTag);
@@ -120,7 +115,7 @@ export class TypeContext {
                     continue;
                 }
 
-                this.discoverTypes(type as typeof Schema, metadata[field].index, viewTag);
+                this.discoverTypes(type as typeof Schema, index, viewTag);
             }
         }
     }

package/src/types/custom/ArraySchema.ts

@@ -8,6 +8,7 @@ import { Collection } from "../HelperTypes";
 import { encodeArray } from "../../encoder/EncodeOperation";
 import { decodeArray } from "../../decoder/DecodeOperation";
 import type { StateView } from "../../encoder/StateView";
+import { assertInstanceType } from "../../encoding/assert";
 
 const DEFAULT_SORT = (a: any, b: any) => {
     const A = a.toString();
@@ -85,6 +86,8 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
 
                     } else {
                         if (setValue[$changes]) {
+                            assertInstanceType(setValue, obj[$childType] as typeof Schema, obj, key);
+
                             if (obj.items[key as unknown as number] !== undefined) {
                                 if (setValue[$changes][$isNew]) {
                                     this[$changes].indexedOperation(Number(key), OPERATION.MOVE_AND_ADD);
@@ -99,6 +102,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
                             } else if (setValue[$changes][$isNew]) {
                                 this[$changes].indexedOperation(Number(key), OPERATION.ADD);
                             }
+
                         } else {
                             obj.$changeAt(Number(key), setValue);
                         }
@@ -133,6 +137,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
         });
 
         this[$changes] = new ChangeTree(proxy);
+        this[$changes].indexes = {};
         this.push.apply(this, items);
 
         return proxy;
@@ -159,6 +164,9 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
             // skip null values
             if (value === undefined || value === null) {
                 return;
+
+            } else if (typeof (value) === "object" && this[$childType]) {
+                assertInstanceType(value as any, this[$childType] as typeof Schema, this, i);
             }
 
             const changeTree = this[$changes];

package/src/types/custom/CollectionSchema.ts

@@ -41,6 +41,7 @@ export class CollectionSchema<V=any> implements Collection<K, V>{
 
     constructor (initialValues?: Array<V>) {
         this[$changes] = new ChangeTree(this);
+        this[$changes].indexes = {};
 
         if (initialValues) {
             initialValues.forEach((v) => this.add(v));

package/src/types/custom/MapSchema.ts

@@ -6,6 +6,8 @@ import { Collection } from "../HelperTypes";
 import { decodeKeyValueOperation } from "../../decoder/DecodeOperation";
 import { encodeKeyValueOperation } from "../../encoder/EncodeOperation";
 import type { StateView } from "../../encoder/StateView";
+import type { Schema } from "../../Schema";
+import { assertInstanceType } from "../../encoding/assert";
 
 export class MapSchema<V=any, K extends string = string> implements Map<K, V>, Collection<K, V, [K, V]> {
     protected childType: new () => V;
@@ -39,6 +41,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
 
     constructor (initialValues?: Map<K, V> | Record<K, V>) {
         this[$changes] = new ChangeTree(this);
+        this[$changes].indexes = {};
 
         if (initialValues) {
             if (
@@ -71,6 +74,9 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
     set(key: K, value: V) {
         if (value === undefined || value === null) {
             throw new Error(`MapSchema#set('${key}', ${value}): trying to set ${value} value on '${key}'.`);
+
+        } else if (typeof(value) === "object" && this[$childType]) {
+            assertInstanceType(value as any, this[$childType] as typeof Schema, this, key);
         }
 
         // Force "key" as string

package/src/types/custom/SetSchema.ts

@@ -40,6 +40,7 @@ export class SetSchema<V=any> implements Collection<number, V> {
 
     constructor (initialValues?: Array<V>) {
         this[$changes] = new ChangeTree(this);
+        this[$changes].indexes = {};
 
         if (initialValues) {
             initialValues.forEach((v) => this.add(v));

package/src/types/symbols.ts

@@ -7,6 +7,8 @@ export const $filter = Symbol("$filter");
 export const $getByIndex = Symbol("$getByIndex");
 export const $deleteByIndex = Symbol("$deleteByIndex");
 
+export const $descriptors = Symbol("$descriptors");
+
 /**
  * Used to hold ChangeTree instances whitin the structures
  */