@colyseus/schema 3.0.0-alpha.47 → 3.0.0-alpha.49

package/src/Schema.ts

@@ -174,17 +174,24 @@ export class Schema {
         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} (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;
     }

package/src/encoder/ChangeTree.ts

@@ -507,10 +507,13 @@ export class ChangeTree<T extends Ref=any> {
         // skip if parent is not set
         if (!parent) { return; }
 
+        //
         // ArraySchema | MapSchema - get the child type
+        // (if refType is typeof string, the parentFiltered[key] below will always be invalid)
+        //
         const refType = Metadata.isValidInstance(this.ref)
             ? this.ref.constructor
-            : this.ref[$childType];
+            :  this.ref[$childType];
 
         if (!Metadata.isValidInstance(parent)) {
             const parentChangeTree = parent[$changes];
@@ -521,10 +524,13 @@ export class ChangeTree<T extends Ref=any> {
         const parentConstructor = parent.constructor as typeof Schema;
 
         let key = `${this.root.types.getTypeId(refType as typeof Schema)}`;
-        if (parentConstructor) { key += `-${this.root.types.schemas.get(parentConstructor)}`; }
+        if (parentConstructor) {
+            key += `-${this.root.types.schemas.get(parentConstructor)}`;
+        }
         key += `-${parentIndex}`;
 
-        this.isFiltered = this.root.types.parentFiltered[key];
+        this.isFiltered = parent[$changes].isFiltered // in case parent is already filtered
+            || this.root.types.parentFiltered[key];
 
         // const parentMetadata = parentConstructor?.[Symbol.metadata];
         // this.isFiltered = parentMetadata?.[$viewFieldIndexes]?.includes(parentIndex) || this.root.types.parentFiltered[key];

package/src/types/custom/MapSchema.ts

@@ -9,11 +9,11 @@ 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]> {
+export class MapSchema<V=any> implements Map<string, V>, Collection<string, V, [string, V]> {
     protected childType: new () => V;
 
-    protected $items: Map<K, V> = new Map<K, V>();
-    protected $indexes: Map<number, K> = new Map<number, K>();
+    protected $items: Map<string, V> = new Map<string, V>();
+    protected $indexes: Map<number, string> = new Map<number, string>();
 
     protected [$changes]: ChangeTree;
 
@@ -41,7 +41,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
         return type['map'] !== undefined;
     }
 
-    constructor (initialValues?: Map<K, V> | Record<K, V>) {
+    constructor (initialValues?: Map<string, V> | Record<string, V>) {
         this[$changes] = new ChangeTree(this);
         this[$changes].indexes = {};
 
@@ -68,12 +68,12 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
     }
 
     /** Iterator */
-    [Symbol.iterator](): IterableIterator<[K, V]> { return this.$items[Symbol.iterator](); }
+    [Symbol.iterator](): IterableIterator<[string, V]> { return this.$items[Symbol.iterator](); }
     get [Symbol.toStringTag]() { return this.$items[Symbol.toStringTag] }
 
     static get [Symbol.species]() { return MapSchema; }
 
-    set(key: K, value: V) {
+    set(key: string, value: V) {
         if (value === undefined || value === null) {
             throw new Error(`MapSchema#set('${key}', ${value}): trying to set ${value} value on '${key}'.`);
 
@@ -83,7 +83,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
 
         // Force "key" as string
         // See: https://github.com/colyseus/colyseus/issues/561#issuecomment-1646733468
-        key = key.toString() as K;
+        key = key.toString() as string;
 
         const changeTree = this[$changes];
 
@@ -138,11 +138,11 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
         return this;
     }
 
-    get(key: K): V | undefined {
+    get(key: string): V | undefined {
         return this.$items.get(key);
     }
 
-    delete(key: K) {
+    delete(key: string) {
         const index = this[$changes].indexes[key];
 
         this[$changes].delete(index);
@@ -166,11 +166,11 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
         changeTree.operation(OPERATION.CLEAR);
     }
 
-    has (key: K) {
+    has (key: string) {
         return this.$items.has(key);
     }
 
-    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void) {
+    forEach(callbackfn: (value: V, key: string, map: Map<string, V>) => void) {
         this.$items.forEach(callbackfn);
     }
 
@@ -190,7 +190,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
         return this.$items.size;
     }
 
-    protected setIndex(index: number, key: K) {
+    protected setIndex(index: number, key: string) {
         this.$indexes.set(index, key);
     }