@colyseus/schema 3.0.0-alpha.8 → 3.0.0

package/src/types/custom/ArraySchema.ts

@@ -1,6 +1,6 @@
-import { $changes, $childType, $decoder, $deleteByIndex, $onEncodeEnd, $encoder, $filter, $getByIndex, $onDecodeEnd, $isNew } from "../symbols";
+import { $changes, $childType, $decoder, $deleteByIndex, $onEncodeEnd, $encoder, $filter, $getByIndex, $onDecodeEnd } from "../symbols";
 import type { Schema } from "../../Schema";
-import { ChangeTree } from "../../encoder/ChangeTree";
+import { ChangeTree, setOperationAtIndex } from "../../encoder/ChangeTree";
 import { OPERATION } from "../../encoding/spec";
 import { registerType } from "../registry";
 import { Collection } from "../HelperTypes";
@@ -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();
@@ -69,6 +70,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
             get: (obj, prop) => {
                 if (
                     typeof (prop) !== "symbol" &&
+                    // FIXME: d8 accuses this as low performance
                     !isNaN(prop as any) // https://stackoverflow.com/a/175787/892698
                 ) {
                     return this.items[prop];
@@ -85,8 +87,10 @@ 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]) {
+                                if (setValue[$changes].isNew) {
                                     this[$changes].indexedOperation(Number(key), OPERATION.MOVE_AND_ADD);
 
                                 } else {
@@ -96,9 +100,10 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
                                         this[$changes].indexedOperation(Number(key), OPERATION.MOVE);
                                     }
                                 }
-                            } else if (setValue[$changes][$isNew]) {
+                            } else if (setValue[$changes].isNew) {
                                 this[$changes].indexedOperation(Number(key), OPERATION.ADD);
                             }
+
                         } else {
                             obj.$changeAt(Number(key), setValue);
                         }
@@ -133,7 +138,11 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
         });
 
         this[$changes] = new ChangeTree(proxy);
-        this.push.apply(this, items);
+        this[$changes].indexes = {};
+
+        if (items.length > 0) {
+            this.push(...items);
+        }
 
         return proxy;
     }
@@ -155,15 +164,23 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
     push(...values: V[]) {
         let length = this.tmpItems.length;
 
-        values.forEach((value, i) => {
-            // skip null values
+        const changeTree = this[$changes];
+
+        // values.forEach((value, i) => {
+
+        for (let i = 0, l = values.length; i < values.length; i++, length++) {
+            const value = values[i];
+
             if (value === undefined || value === null) {
+                // skip null values
                 return;
+
+            } else if (typeof (value) === "object" && this[$childType]) {
+                assertInstanceType(value as any, this[$childType] as typeof Schema, this, i);
+                // TODO: move value[$changes]?.setParent() to this block.
             }
 
-            const changeTree = this[$changes];
             changeTree.indexedOperation(length, OPERATION.ADD, this.items.length);
-            // changeTree.indexes[length] = length;
 
             this.items.push(value);
             this.tmpItems.push(value);
@@ -173,9 +190,10 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
             // (to avoid encoding "refId" operations before parent's "ADD" operation)
             //
             value[$changes]?.setParent(this, changeTree.root, length);
+        }
 
-            length++;
-        });
+        //     length++;
+        // });
 
         return length;
     }
@@ -202,6 +220,8 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
         this[$changes].delete(index, undefined, this.items.length - 1);
 
         // this.tmpItems[index] = undefined;
+        // this.tmpItems.pop();
+
         this.deletedIndexes[index] = true;
 
         return this.items.pop();
@@ -263,10 +283,12 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
 
     clear() {
         // skip if already clear
-        if (this.items.length === 0) { return; }
+        if (this.items.length === 0) {
+            return;
+        }
 
         // discard previous operations.
-        const changeTree = this[$changes]
+        const changeTree = this[$changes];
 
         // discard children
         changeTree.forEachChild((changeTree, _) => {
@@ -278,9 +300,12 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
             //
             // TODO: do not use [$changes] at decoding time.
             //
-            changeTree.root?.changes.delete(changeTree);
-            changeTree.root?.allChanges.delete(changeTree);
-            changeTree.root?.allFilteredChanges.delete(changeTree);
+            const root = changeTree.root;
+            if (root !== undefined) {
+                root.removeChangeFromChangeSet("changes", changeTree);
+                root.removeChangeFromChangeSet("allChanges", changeTree);
+                root.removeChangeFromChangeSet("allFilteredChanges", changeTree);
+            }
         });
 
         changeTree.discard(true);
@@ -331,6 +356,8 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
         changeTree.delete(index);
         changeTree.shiftAllChangeIndexes(-1, index);
 
+        // this.deletedIndexes[index] = true;
+
         return this.items.shift();
     }
 
@@ -430,9 +457,11 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
 
         // new index
         if (changeTree.isFiltered) {
-            changeTree.filteredChanges.set(this.items.length, OPERATION.ADD);
+            setOperationAtIndex(changeTree.filteredChanges, this.items.length);
+            // changeTree.filteredChanges[this.items.length] = OPERATION.ADD;
         } else {
-            changeTree.allChanges.set(this.items.length, OPERATION.ADD);
+            setOperationAtIndex(changeTree.allChanges, this.items.length);
+            // changeTree.allChanges[this.items.length] = OPERATION.ADD;
         }
 
         // FIXME: should we use OPERATION.MOVE here instead?
@@ -471,6 +500,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 +720,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);

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

@@ -1,4 +1,4 @@
-import { $changes, $childType, $decoder, $deleteByIndex, $onEncodeEnd, $encoder, $filter, $getByIndex } from "../symbols";
+import { $changes, $childType, $decoder, $deleteByIndex, $onEncodeEnd, $encoder, $filter, $getByIndex, $numFields } from "../symbols";
 import { ChangeTree } from "../../encoder/ChangeTree";
 import { OPERATION } from "../../encoding/spec";
 import { registerType } from "../registry";
@@ -6,12 +6,16 @@ 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]> {
+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;
 
     static [$encoder] = encodeKeyValueOperation;
     static [$decoder] = decodeKeyValueOperation;
@@ -37,8 +41,9 @@ 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 = {};
 
         if (initialValues) {
             if (
@@ -63,19 +68,22 @@ 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}'.`);
+
+        } else if (typeof(value) === "object" && this[$childType]) {
+            assertInstanceType(value as any, this[$childType] as typeof Schema, this, key);
         }
 
         // 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];
 
@@ -84,7 +92,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
 
         const index = (isReplace)
             ? changeTree.indexes[key]
-            : changeTree.indexes[-1] ?? 0;
+            : changeTree.indexes[$numFields] ?? 0;
 
         let operation: OPERATION = (isReplace)
             ? OPERATION.REPLACE
@@ -99,7 +107,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
         if (!isReplace) {
             this.$indexes.set(index, key);
             changeTree.indexes[key] = index;
-            changeTree.indexes[-1] = index + 1;
+            changeTree.indexes[$numFields] = index + 1;
 
         } else if (
             !isRef &&
@@ -130,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);
@@ -158,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);
     }
 
@@ -182,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);
     }
 
@@ -202,8 +210,13 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
 
     protected [$onEncodeEnd]() {
         const changeTree = this[$changes];
-        const changes = changeTree.changes.entries();
-        for (const [fieldIndex, operation] of changes) {
+        const keys = Object.keys(changeTree.indexedOperations);
+
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const fieldIndex = Number(key);
+            const operation = changeTree.indexedOperations[key];
+
             if (operation === OPERATION.DELETE) {
                 const index = this[$getByIndex](fieldIndex) as string;
                 delete changeTree.indexes[index];

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/registry.ts

@@ -1,13 +1,24 @@
+import { DefinitionType, type } from "../annotations";
+import { BufferLike, encode } from "../encoding/encode";
+import { decode, Iterator } from "../encoding/decode";
+
 export interface TypeDefinition {
-    constructor: any,
+    constructor?: any,
+    encode?: (bytes: BufferLike, value: any, it: Iterator) => any;
+    decode?: (bytes: BufferLike, it: Iterator) => any;
 }
 
 const registeredTypes: {[identifier: string] : TypeDefinition} = {};
 const identifiers = new Map<any, string>();
 
 export function registerType(identifier: string, definition: TypeDefinition) {
-    identifiers.set(definition.constructor, identifier);
-    registeredTypes[identifier] = definition;
+    if (definition.constructor) {
+        identifiers.set(definition.constructor, identifier);
+        registeredTypes[identifier] = definition;
+    }
+
+    if (definition.encode) { encode[identifier] = definition.encode; }
+    if (definition.decode) { decode[identifier] = definition.decode; }
 }
 
 export function getIdentifier(klass: any): string {
@@ -17,3 +28,11 @@ export function getIdentifier(klass: any): string {
 export function getType(identifier: string): TypeDefinition {
     return registeredTypes[identifier];
 }
+
+export function defineCustomTypes<T extends {[key: string]: TypeDefinition}>(types: T) {
+    for (const identifier in types) {
+        registerType(identifier, types[identifier]);
+    }
+
+    return (t: keyof T) => type(t as DefinitionType);
+}

package/src/types/symbols.ts

@@ -18,12 +18,6 @@ export const $changes = Symbol('$changes');
  */
 export const $childType = Symbol('$childType');
 
-/**
- * Special ChangeTree property to identify new instances
- * (Once they're encoded, they're not new anymore)
- */
-export const $isNew = Symbol("$isNew");
-
 /**
  * Optional "discard" method for custom types (ArraySchema)
  * (Discards changes for next serialization)
@@ -33,4 +27,13 @@ export const $onEncodeEnd = Symbol('$onEncodeEnd');
 /**
  * When decoding, this method is called after the instance is fully decoded
  */
-export const $onDecodeEnd = Symbol("$onDecodeEnd");
+export const $onDecodeEnd = Symbol("$onDecodeEnd");
+
+/**
+ * Metadata
+ */
+export const $descriptors = Symbol("$descriptors");
+export const $numFields = "$__numFields";
+export const $refTypeFieldIndexes = "$__refTypeFieldIndexes";
+export const $viewFieldIndexes = "$__viewFieldIndexes";
+export const $fieldIndexesByViewTag = "$__fieldIndexesByViewTag";

package/src/utils.ts

@@ -27,13 +27,17 @@ export function dumpChanges(schema: Schema) {
         refs: []
     };
 
-    $root.changes.forEach((operations, changeTree) => {
+    // for (const refId in $root.changes) {
+    $root.changes.forEach(changeTree => {
+        const changes = changeTree.indexedOperations;
+
         dump.refs.push(`refId#${changeTree.refId}`);
-        operations.forEach((op, index) => {
+        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]]++;
-        });
+        }
     });
 
     return dump;