@colyseus/schema 3.0.62 → 3.0.63

package/src/types/HelperTypes.ts

@@ -9,7 +9,7 @@ export type Constructor<T = {}> = new (...args: any[]) => T;
 
 export interface Collection<K = any, V = any, IT = V> {
     [Symbol.iterator](): IterableIterator<IT>;
-    forEach(callback: Function);
+    forEach(callback: Function): void;
     entries(): IterableIterator<[K, V]>;
 }
 
@@ -29,6 +29,7 @@ export type InferValueType<T extends DefinitionType> =
     : T extends "boolean" ? boolean
 
     // Handle { type: ... } patterns
+    : T extends { type: infer ChildType extends PrimitiveType } ? InferValueType<ChildType>
     : T extends { type: infer ChildType extends Constructor } ? InstanceType<ChildType>
     : T extends { type: Array<infer ChildType> } ? (ChildType extends Record<string | number, string | number> ? ChildType[keyof ChildType][] : ChildType[]) // TS ENUM
     : T extends { type: { map: infer ChildType } } ? (ChildType extends Record<string | number, string | number> ? MapSchema<ChildType[keyof ChildType]> : MapSchema<ChildType>) // TS ENUM
@@ -61,13 +62,11 @@ export type InferValueType<T extends DefinitionType> =
     : never;
 
 export type InferSchemaInstanceType<T extends Definition> = {
-    [K in keyof T]: InferValueType<T[K]>
+    [K in keyof T]: T[K] extends (...args: any[]) => any
+        ? (T[K] extends new (...args: any[]) => any ? InferValueType<T[K]> : T[K])
+        : InferValueType<T[K]>
 } & Schema;
 
-export type DefinedSchemaType<T extends Definition, P extends typeof Schema> = {
-    new (): InferSchemaInstanceType<T> & InstanceType<P>;
-} & typeof Schema;
-
 export type NonFunctionProps<T> = Omit<T, {
     [K in keyof T]: T[K] extends Function ? K : never;
 }[keyof T]>;
@@ -92,4 +91,27 @@ export type ToJSON<T> = NonFunctionProps<{
             : T[K] extends ArraySchema<infer U>
                 ? U[]
                 : T[K]
-}>;
+}>;
+
+// Helper type to check if T is exactly 'never' (meaning no InitProps was provided)
+export type IsNever<T> = [T] extends [never] ? true : false;
+
+/**
+ * Type helper for .assign() method - allows assigning values in a flexible way
+ * - Primitives can be assigned directly
+ * - Schema instances can be assigned from plain objects or Schema instances
+ * - Collections can be assigned from their JSON representations
+ */
+export type AssignableProps<T> = {
+    [K in NonFunctionPropNames<T>]?: T[K] extends MapSchema<infer U>
+        ? MapSchema<U> | Record<string, U extends Schema ? (U | AssignableProps<U>) : U>
+        : T[K] extends ArraySchema<infer U>
+            ? ArraySchema<U> | (U extends Schema ? (U | AssignableProps<U>)[] : U[])
+            : T[K] extends SetSchema<infer U>
+                ? SetSchema<U> | Set<U> | (U extends Schema ? (U | AssignableProps<U>)[] : U[])
+                : T[K] extends CollectionSchema<infer U>
+                    ? CollectionSchema<U> | (U extends Schema ? (U | AssignableProps<U>)[] : U[])
+                    : T[K] extends Schema
+                        ? T[K] | AssignableProps<T[K]>
+                        : T[K]
+};

package/src/types/TypeContext.ts

@@ -97,7 +97,7 @@ export class TypeContext {
             this.discoverTypes(parent);
         }
 
-        const metadata: Metadata = (klass[Symbol.metadata] ??= {});
+        const metadata: Metadata = (klass[Symbol.metadata] ??= {} as Metadata);
 
         // if any schema/field has filters, mark "context" as having filters.
         if (metadata[$viewFieldIndexes]) {

package/src/types/custom/ArraySchema.ts

@@ -1,6 +1,6 @@
 import { $changes, $childType, $decoder, $deleteByIndex, $onEncodeEnd, $encoder, $filter, $getByIndex, $onDecodeEnd } from "../symbols";
 import type { Schema } from "../../Schema";
-import { ChangeTree, setOperationAtIndex } from "../../encoder/ChangeTree";
+import { type IRef, ChangeTree, setOperationAtIndex } from "../../encoder/ChangeTree";
 import { OPERATION } from "../../encoding/spec";
 import { registerType } from "../registry";
 import { Collection } from "../HelperTypes";
@@ -18,18 +18,20 @@ const DEFAULT_SORT = (a: any, b: any) => {
     else return 0
 }
 
-export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
+export class ArraySchema<V = any> implements Array<V>, Collection<number, V>, IRef {
     [n: number]: V;
+    [$changes]: ChangeTree;
+
+    protected [$childType]: string | typeof Schema;
 
     protected items: V[] = [];
     protected tmpItems: V[] = [];
     protected deletedIndexes: {[index: number]: boolean} = {};
+    protected isMovingItems = false;
 
     static [$encoder] = encodeArray;
     static [$decoder] = decodeArray;
 
-    protected isMovingItems = false;
-
     /**
      * Determine if a property must be filtered.
      * - If returns false, the property is NOT going to be encoded.
@@ -76,7 +78,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
                     // FIXME: d8 accuses this as low performance
                     !isNaN(prop as any) // https://stackoverflow.com/a/175787/892698
                 ) {
-                    return this.items[prop];
+                    return this.items[prop as unknown as number];
 
                 } else {
                     return Reflect.get(obj, prop);
@@ -142,7 +144,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
                     obj.$deleteAt(prop);
 
                 } else {
-                    delete obj[prop];
+                    delete obj[prop as unknown as number];
                 }
 
                 return true;
@@ -759,7 +761,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
         return this.items.findLast.apply(this.items, arguments);
     }
 
-    findLastIndex(...args) {
+    findLastIndex(...args: any[]) {
         // @ts-ignore
         return this.items.findLastIndex.apply(this.items, arguments);
     }
@@ -821,7 +823,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
         return this;
     }
 
-    protected [$getByIndex](index: number, isEncodeAll: boolean = false) {
+    [$getByIndex](index: number, isEncodeAll: boolean = false): any {
         //
         // TODO: avoid unecessary `this.tmpItems` check during decoding.
         //
@@ -836,7 +838,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
                 : this.tmpItems[index] || this.items[index];
     }
 
-    protected [$deleteByIndex](index: number) {
+    [$deleteByIndex](index: number): void {
         this.items[index] = undefined;
         this.tmpItems[index] = undefined; // TODO: do not try to get "tmpItems" at decoding time.
     }
@@ -856,7 +858,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
     }
 
     toJSON() {
-        return this.toArray().map((value) => {
+        return this.toArray().map((value: any) => {
             return (typeof (value['toJSON']) === "function")
                 ? value['toJSON']()
                 : value;

package/src/types/custom/CollectionSchema.ts

@@ -1,15 +1,18 @@
 import { $changes, $childType, $decoder, $deleteByIndex, $encoder, $filter, $getByIndex, $onEncodeEnd } from "../symbols";
-import { ChangeTree } from "../../encoder/ChangeTree";
+import { ChangeTree, type IRef } from "../../encoder/ChangeTree";
 import { OPERATION } from "../../encoding/spec";
 import { registerType } from "../registry";
 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";
 
 type K = number; // TODO: allow to specify K generic on MapSchema.
 
-export class CollectionSchema<V=any> implements Collection<K, V>{
+export class CollectionSchema<V=any> implements Collection<K, V>, IRef {
+    public [$changes]: ChangeTree;
+    protected [$childType]: string | typeof Schema;
 
     protected $items: Map<number, V> = new Map<number, V>();
     protected $indexes: Map<number, number> = new Map<number, number>();
@@ -159,11 +162,11 @@ export class CollectionSchema<V=any> implements Collection<K, V>{
         return this.$indexes.get(index);
     }
 
-    protected [$getByIndex](index: number) {
+    [$getByIndex](index: number): any {
         return this.$items.get(this.$indexes.get(index));
     }
 
-    protected [$deleteByIndex](index: number) {
+    [$deleteByIndex](index: number): void {
         const key = this.$indexes.get(index);
         this.$items.delete(key);
         this.$indexes.delete(index);
@@ -180,7 +183,7 @@ export class CollectionSchema<V=any> implements Collection<K, V>{
     toJSON() {
         const values: V[] = [];
 
-        this.forEach((value, key) => {
+        this.forEach((value: any, key: K) => {
             values.push(
                 (typeof (value['toJSON']) === "function")
                     ? value['toJSON']()
@@ -204,7 +207,7 @@ export class CollectionSchema<V=any> implements Collection<K, V>{
         } else {
             // server-side
             cloned = new CollectionSchema();
-            this.forEach((value) => {
+            this.forEach((value: any) => {
                 if (value[$changes]) {
                     cloned.add(value['clone']());
                 } else {

package/src/types/custom/MapSchema.ts

@@ -1,5 +1,5 @@
 import { $changes, $childType, $decoder, $deleteByIndex, $onEncodeEnd, $encoder, $filter, $getByIndex, $numFields } from "../symbols";
-import { ChangeTree } from "../../encoder/ChangeTree";
+import { ChangeTree, IRef } from "../../encoder/ChangeTree";
 import { OPERATION } from "../../encoding/spec";
 import { registerType } from "../registry";
 import { Collection } from "../HelperTypes";
@@ -9,15 +9,15 @@ 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, K extends string = string> implements Map<K, V>, Collection<K, V, [K, V]>, IRef {
     protected childType: new () => V;
+    [$changes]: ChangeTree;
+    protected [$childType]: string | typeof Schema;
 
     protected $items: Map<K, V> = new Map<K, V>();
     protected $indexes: Map<number, K> = new Map<number, K>();
     protected deletedItems: { [index: string]: V } = {};
 
-    protected [$changes]: ChangeTree;
-
     static [$encoder] = encodeKeyValueOperation;
     static [$decoder] = decodeKeyValueOperation;
 
@@ -215,11 +215,11 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
         return this.$indexes.get(index);
     }
 
-    protected [$getByIndex](index: number) {
+    [$getByIndex](index: number): V | undefined {
         return this.$items.get(this.$indexes.get(index));
     }
 
-    protected [$deleteByIndex](index: number) {
+    [$deleteByIndex](index: number): void {
         const key = this.$indexes.get(index);
         this.$items.delete(key);
         this.$indexes.delete(index);
@@ -245,7 +245,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
     toJSON() {
         const map: any = {};
 
-        this.forEach((value, key) => {
+        this.forEach((value: any, key) => {
             map[key] = (typeof (value['toJSON']) === "function")
                 ? value['toJSON']()
                 : value;
@@ -269,7 +269,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
             // server-side
             cloned = new MapSchema();
 
-            this.forEach((value, key) => {
+            this.forEach((value: any, key) => {
                 if (value[$changes]) {
                     cloned.set(key, value['clone']());
                 } else {

package/src/types/custom/SetSchema.ts

@@ -2,12 +2,15 @@ import { OPERATION } from "../../encoding/spec";
 import { registerType } from "../registry";
 import { $changes, $childType, $decoder, $deleteByIndex, $encoder, $filter, $getByIndex, $onEncodeEnd } from "../symbols";
 import { Collection } from "../HelperTypes";
-import { ChangeTree } from "../../encoder/ChangeTree";
+import { ChangeTree, type IRef } from "../../encoder/ChangeTree";
 import { encodeKeyValueOperation } from "../../encoder/EncodeOperation";
 import { decodeKeyValueOperation } from "../../decoder/DecodeOperation";
 import type { StateView } from "../../encoder/StateView";
+import type { Schema } from "../../Schema";
 
-export class SetSchema<V=any> implements Collection<number, V> {
+export class SetSchema<V=any> implements Collection<number, V>, IRef {
+    [$changes]: ChangeTree;
+    protected [$childType]: string | typeof Schema;
 
     protected $items: Map<number, V> = new Map<number, V>();
     protected $indexes: Map<number, number> = new Map<number, number>();
@@ -163,11 +166,11 @@ export class SetSchema<V=any> implements Collection<number, V> {
         return this.$indexes.get(index);
     }
 
-    protected [$getByIndex](index: number) {
+    [$getByIndex](index: number): any {
         return this.$items.get(this.$indexes.get(index));
     }
 
-    protected [$deleteByIndex](index: number) {
+    [$deleteByIndex](index: number): void {
         const key = this.$indexes.get(index);
         this.$items.delete(key);
         this.$indexes.delete(index);
@@ -184,7 +187,7 @@ export class SetSchema<V=any> implements Collection<number, V> {
     toJSON() {
         const values: V[] = [];
 
-        this.forEach((value, key) => {
+        this.forEach((value: any, key: number) => {
             values.push(
                 (typeof (value['toJSON']) === "function")
                     ? value['toJSON']()
@@ -208,7 +211,7 @@ export class SetSchema<V=any> implements Collection<number, V> {
         } else {
             // server-side
             cloned = new SetSchema();
-            this.forEach((value) => {
+            this.forEach((value: any) => {
                 if (value[$changes]) {
                     cloned.add(value['clone']());
                 } else {

package/src/types/registry.ts

@@ -18,8 +18,8 @@ export function registerType(identifier: string, definition: TypeDefinition) {
         registeredTypes[identifier] = definition;
     }
 
-    if (definition.encode) { encode[identifier] = definition.encode; }
-    if (definition.decode) { decode[identifier] = definition.decode; }
+    if (definition.encode) { (encode as any)[identifier] = definition.encode; }
+    if (definition.decode) { (decode as any)[identifier] = definition.decode; }
 }
 
 export function getIdentifier(klass: any): string {

package/src/utils.ts

@@ -2,8 +2,6 @@ import type { Schema } from "./Schema";
 import { OPERATION } from "./encoding/spec";
 import { $changes } from "./types/symbols";
 
-type ChangeItem = [string, number | string, any?];
-
 interface ChangeDump {
     ops: {
         ADD?: number;
@@ -43,8 +41,8 @@ export function dumpChanges(schema: Schema) {
         for (const index in changes) {
             const op = changes[index];
             const opName = OPERATION[op];
-            if (!dump.ops[opName]) { dump.ops[opName] = 0; }
-            dump.ops[OPERATION[op]]++;
+            if (!dump.ops[opName as keyof ChangeDump['ops']]) { dump.ops[opName as keyof ChangeDump['ops']] = 0; }
+            dump.ops[OPERATION[op] as keyof ChangeDump['ops']]++;
         }
         current = current.next;
     }

package/src/v3_bench.ts

@@ -58,7 +58,7 @@ const encoder = new Encoder(state);
 let encoded = encoder.encode();
 console.log(`(${encoded.length})`, [...encoded]);
 
-globalThis.perform = function() {
+(globalThis as any).perform = function(): void {
     for (let i = 0; i < 500000; i++) {
         encoder.encodeAll();
     }