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

package/src/types/TypeContext.ts

@@ -0,0 +1,127 @@
+import { Metadata } from "../Metadata";
+import { Schema } from "../Schema";
+
+export class TypeContext {
+    types: { [id: number]: typeof Schema; } = {};
+    schemas = new Map<typeof Schema, number>();
+
+    hasFilters: boolean = false;
+    parentFiltered: {[typeIdAndParentIndex: string]: boolean} = {};
+
+    /**
+     * For inheritance support
+     * Keeps track of which classes extends which. (parent -> children)
+     */
+    static inheritedTypes = new Map<typeof Schema, Set<typeof Schema>>();
+
+    static register(target: typeof Schema) {
+        const parent = Object.getPrototypeOf(target);
+        if (parent !== Schema) {
+            let inherits = TypeContext.inheritedTypes.get(parent);
+            if (!inherits) {
+                inherits = new Set<typeof Schema>();
+                TypeContext.inheritedTypes.set(parent, inherits);
+            }
+            inherits.add(target);
+        }
+    }
+
+    constructor(rootClass?: typeof Schema) {
+        if (rootClass) {
+            this.discoverTypes(rootClass);
+        }
+    }
+
+    has(schema: typeof Schema) {
+        return this.schemas.has(schema);
+    }
+
+    get(typeid: number) {
+        return this.types[typeid];
+    }
+
+    add(schema: typeof Schema, typeid: number = this.schemas.size) {
+        // skip if already registered
+        if (this.schemas.has(schema)) {
+            return false;
+        }
+
+        this.types[typeid] = schema;
+
+        //
+        // Workaround to allow using an empty Schema (with no `@type()` fields)
+        //
+        if (schema[Symbol.metadata] === undefined) {
+            Metadata.init(schema);
+        }
+
+        this.schemas.set(schema, typeid);
+        return true;
+    }
+
+    getTypeId(klass: typeof Schema) {
+        return this.schemas.get(klass);
+    }
+
+    private discoverTypes(klass: typeof Schema, parentIndex?: number, parentFieldViewTag?: number) {
+        if (!this.add(klass)) {
+            return;
+        }
+
+        // add classes inherited from this base class
+        TypeContext.inheritedTypes.get(klass)?.forEach((child) => {
+            this.discoverTypes(child, parentIndex, parentFieldViewTag);
+        });
+
+        const metadata: Metadata = (klass[Symbol.metadata] ??= {});
+
+        // if any schema/field has filters, mark "context" as having filters.
+        if (metadata[-2]) {
+            this.hasFilters = true;
+        }
+
+        if (parentFieldViewTag !== undefined) {
+            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;
+
+            if (typeof (fieldType) === "string") {
+                continue;
+            }
+
+            if (Array.isArray(fieldType)) {
+                const type = fieldType[0];
+                if (type === "string") {
+                    continue;
+                }
+                this.discoverTypes(type as typeof Schema, metadata[field].index, viewTag);
+
+            } else if (typeof (fieldType) === "function") {
+                this.discoverTypes(fieldType as typeof Schema, viewTag);
+
+            } else {
+                const type = Object.values(fieldType)[0];
+
+                // skip primitive types
+                if (typeof (type) === "string") {
+                    continue;
+                }
+
+                this.discoverTypes(type as typeof Schema, metadata[field].index, viewTag);
+            }
+        }
+    }
+}

package/src/types/custom/ArraySchema.ts

@@ -163,7 +163,6 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
 
             const changeTree = this[$changes];
             changeTree.indexedOperation(length, OPERATION.ADD, this.items.length);
-            // changeTree.indexes[length] = length;
 
             this.items.push(value);
             this.tmpItems.push(value);
@@ -471,6 +470,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
      * @param thisArg An object to which the this keyword can refer in the callbackfn function.
      * If thisArg is omitted, undefined is used as the this value.
      */
+    every<S extends V>(predicate: (value: V, index: number, array: V[]) => value is S, thisArg?: any): this is S[];
     every(callbackfn: (value: V, index: number, array: V[]) => unknown, thisArg?: any): boolean {
         return this.items.every(callbackfn, thisArg);
     }
@@ -690,7 +690,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
     //
     // ES2023
     //
-    with(index: number, value: V): V[] {
+    with(index: number, value: V): ArraySchema<V> {
         const copy = this.items.slice();
         copy[index] = value;
         return new ArraySchema(...copy);