@colyseus/schema 2.0.32 → 3.0.0-alpha.0

package/src/types/{SetSchema.ts → custom/SetSchema.ts}

@@ -1,42 +1,56 @@
-import { ChangeTree } from "../changes/ChangeTree";
-import { OPERATION } from "../spec";
-import { SchemaDecoderCallbacks } from "../Schema";
-import { addCallback, removeChildRefs } from "./utils";
-import { DataChange } from "..";
+import { OPERATION } from "../../encoding/spec";
+import { registerType } from "../registry";
+import { $changes, $childType, $decoder, $deleteByIndex, $encoder, $filter, $getByIndex } from "../symbols";
+import { Collection } from "../HelperTypes";
+import { ChangeTree } from "../../encoder/ChangeTree";
+import { encodeKeyValueOperation } from "../../encoder/EncodeOperation";
+import { decodeKeyValueOperation } from "../../decoder/DecodeOperation";
+import type { StateView } from "../../encoder/StateView";
 
-export class SetSchema<V=any> implements SchemaDecoderCallbacks {
-    protected $changes: ChangeTree = new ChangeTree(this);
+export class SetSchema<V=any> implements Collection<number, V> {
 
     protected $items: Map<number, V> = new Map<number, V>();
     protected $indexes: Map<number, number> = new Map<number, number>();
 
     protected $refId: number = 0;
 
-    //
-    // Decoding callbacks
-    //
-    public $callbacks: { [operation: number]: Array<(item: V, key: string) => void> };
-    public onAdd(callback: (item: V, key: string) => void, triggerAll: boolean = true) {
-        return addCallback(
-            (this.$callbacks || (this.$callbacks = [])),
-            OPERATION.ADD,
-            callback,
-            (triggerAll)
-                ? this.$items
-                : undefined
+    static [$encoder] = encodeKeyValueOperation;
+    static [$decoder] = decodeKeyValueOperation;
+
+    /**
+     * Determine if a property must be filtered.
+     * - If returns false, the property is NOT going to be encoded.
+     * - If returns true, the property is going to be encoded.
+     *
+     * Encoding with "filters" happens in two steps:
+     * - First, the encoder iterates over all "not owned" properties and encodes them.
+     * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
+     */
+    static [$filter] (ref: SetSchema, index: number, view: StateView) {
+        return (
+            !view ||
+            typeof (ref[$childType]) === "string" ||
+            view.items.has(ref[$getByIndex](index)[$changes])
         );
     }
-    public onRemove(callback: (item: V, key: string) => void) { return addCallback(this.$callbacks || (this.$callbacks = []), OPERATION.DELETE, callback); }
-    public onChange(callback: (item: V, key: string) => void) { return addCallback(this.$callbacks || (this.$callbacks = []), OPERATION.REPLACE, callback); }
 
     static is(type: any) {
         return type['set'] !== undefined;
     }
 
     constructor (initialValues?: Array<V>) {
+        this[$changes] = new ChangeTree(this);
+
         if (initialValues) {
             initialValues.forEach((v) => this.add(v));
         }
+
+        Object.defineProperty(this, $childType, {
+            value: undefined,
+            enumerable: false,
+            writable: true,
+            configurable: true,
+        });
     }
 
     add(value: V) {
@@ -46,18 +60,18 @@ export class SetSchema<V=any> implements SchemaDecoderCallbacks {
         // set "index" for reference.
         const index = this.$refId++;
 
-        if ((value['$changes']) !== undefined) {
-            (value['$changes'] as ChangeTree).setParent(this, this.$changes.root, index);
+        if ((value[$changes]) !== undefined) {
+            value[$changes].setParent(this, this[$changes].root, index);
         }
 
-        const operation = this.$changes.indexes[index]?.op ?? OPERATION.ADD;
+        const operation = this[$changes].indexes[index]?.op ?? OPERATION.ADD;
 
-        this.$changes.indexes[index] = index;
+        this[$changes].indexes[index] = index;
 
         this.$indexes.set(index, index);
         this.$items.set(index, value);
 
-        this.$changes.change(index, operation);
+        this[$changes].change(index, operation);
         return index;
     }
 
@@ -83,36 +97,26 @@ export class SetSchema<V=any> implements SchemaDecoderCallbacks {
             return false;
         }
 
-        this.$changes.delete(index);
+        this[$changes].delete(index);
         this.$indexes.delete(index);
 
         return this.$items.delete(index);
     }
 
-    clear(changes?: DataChange[]) {
+    clear() {
+        const changeTree = this[$changes];
+
         // discard previous operations.
-        this.$changes.discard(true, true);
-        this.$changes.indexes = {};
+        changeTree.discard(true);
+        changeTree.indexes = {};
 
         // clear previous indexes
         this.$indexes.clear();
 
-        //
-        // When decoding:
-        // - enqueue items for DELETE callback.
-        // - flag child items for garbage collection.
-        //
-        if (changes) {
-            removeChildRefs.call(this, changes);
-        }
-
         // clear items
         this.$items.clear();
 
-        this.$changes.operation({ index: 0, op: OPERATION.CLEAR });
-
-        // touch all structures until reach root
-        this.$changes.touchParents();
+        changeTree.operation(OPERATION.CLEAR);
     }
 
     has (value: V): boolean {
@@ -144,6 +148,11 @@ export class SetSchema<V=any> implements SchemaDecoderCallbacks {
         return this.$items.size;
     }
 
+    /** Iterator */
+    [Symbol.iterator](): IterableIterator<V> {
+        return this.$items.values();
+    }
+
     protected setIndex(index: number, key: number) {
         this.$indexes.set(index, key);
     }
@@ -152,11 +161,11 @@ export class SetSchema<V=any> implements SchemaDecoderCallbacks {
         return this.$indexes.get(index);
     }
 
-    protected getByIndex(index: number) {
+    protected [$getByIndex](index: number) {
         return this.$items.get(this.$indexes.get(index));
     }
 
-    protected deleteByIndex(index: number) {
+    protected [$deleteByIndex](index: number) {
         const key = this.$indexes.get(index);
         this.$items.delete(key);
         this.$indexes.delete(index);
@@ -194,7 +203,7 @@ export class SetSchema<V=any> implements SchemaDecoderCallbacks {
             // server-side
             cloned = new SetSchema();
             this.forEach((value) => {
-                if (value['$changes']) {
+                if (value[$changes]) {
                     cloned.add(value['clone']());
                 } else {
                     cloned.add(value);
@@ -205,4 +214,6 @@ export class SetSchema<V=any> implements SchemaDecoderCallbacks {
         return cloned;
     }
 
-}
+}
+
+registerType("set", { constructor: SetSchema });

package/src/types/{typeRegistry.ts → registry.ts}

@@ -1,19 +1,19 @@
 export interface TypeDefinition {
     constructor: any,
-
-    // //
-    // // TODO: deprecate proxy on next version
-    // // the proxy is used for compatibility with versions <1.0.0 of @colyseus/schema
-    // //
-    // getProxy?: 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;
 }
 
+export function getIdentifier(klass: any): string {
+    return identifiers.get(klass);
+}
+
 export function getType(identifier: string): TypeDefinition {
     return registeredTypes[identifier];
 }

package/src/types/symbols.ts

@@ -0,0 +1,36 @@
+export const $track = Symbol("$track");
+export const $encoder = Symbol("$encoder");
+export const $decoder = Symbol("$decoder");
+
+export const $filter = Symbol("$filter");
+
+export const $getByIndex = Symbol("$getByIndex");
+export const $deleteByIndex = Symbol("$deleteByIndex");
+
+/**
+ * Used to hold ChangeTree instances whitin the structures
+ */
+export const $changes = Symbol('$changes');
+
+/**
+ * Used to keep track of the type of the child elements of a collection
+ * (MapSchema, ArraySchema, etc.)
+ */
+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)
+ */
+export const $onEncodeEnd = Symbol('$onEncodeEnd');
+
+/**
+ * When decoding, this method is called after the instance is fully decoded
+ */
+export const $onDecodeEnd = Symbol("$onDecodeEnd");

package/src/types/utils.ts

@@ -1,49 +1,3 @@
-import { CollectionSchema, DataChange } from "..";
-import { OPERATION } from "../spec";
-
-export function addCallback(
-    $callbacks: { [op: number]: Function[] },
-    op: OPERATION,
-    callback: (item: any, key: any) => void,
-    existing?: { forEach(callback: (item: any, key: any) => void): void; }
-) {
-    // initialize list of callbacks
-    if (!$callbacks[op]) {
-        $callbacks[op] = [];
-    }
-
-    $callbacks[op].push(callback);
-
-    //
-    // Trigger callback for existing elements
-    // - OPERATION.ADD
-    // - OPERATION.REPLACE
-    //
-    existing?.forEach((item, key) => callback(item, key));
-
-    return () => spliceOne($callbacks[op], $callbacks[op].indexOf(callback));
-}
-
-
-export function removeChildRefs(this: CollectionSchema, changes: DataChange[]) {
-    const needRemoveRef = (typeof (this.$changes.getType()) !== "string");
-
-    this.$items.forEach((item: any, key: any) => {
-        changes.push({
-            refId: this.$changes.refId,
-            op: OPERATION.DELETE,
-            field: key,
-            value: undefined,
-            previousValue: item
-        });
-
-        if (needRemoveRef) {
-            this.$changes.root.removeRef(item['$changes'].refId);
-        }
-    });
-}
-
-
 export function spliceOne(arr: any[], index: number): boolean {
     // manually splice an array
     if (index === -1 || index >= arr.length) {

package/src/utils.ts

@@ -1,28 +1,57 @@
-import { Schema } from "./Schema";
-import { ChangeTree } from "./changes/ChangeTree";
-
-export function dumpChanges(schema: Schema) {
-    const changeTrees: ChangeTree[] = [schema['$changes']];
-    let numChangeTrees = 1;
-
-    const dump = {};
-    let currentStructure = dump;
+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;
+        REMOVE?: number;
+        REPLACE?: number;
+    },
+    refs: string[],
+}
 
-    for (let i = 0; i < numChangeTrees; i++) {
-        const changeTree = changeTrees[i];
+export function getIndent(level: number) {
+    return (new Array(level).fill(0)).map((_, i) =>
+        (i === level - 1) ? `└─ ` : `   `
+    ).join("");
+}
 
-        changeTree.changes.forEach((change) => {
-            const ref = changeTree.ref;
-            const fieldIndex = change.index;
+export function dumpChanges(schema: Schema) {
+    const $root = schema[$changes].root;
+
+    const dump: ChangeDump = {
+        ops: {},
+        refs: []
+    };
+
+    $root.changes.forEach((operations, changeTree) => {
+        dump.refs.push(`refId#${changeTree.refId}`);
+        operations.forEach((op, index) => {
+            const opName = OPERATION[op];
+            if (!dump.ops[opName]) { dump.ops[opName] = 0; }
+            dump.ops[OPERATION[op]]++;
+        });
+    });
 
-            const field = ((ref as Schema)['_definition'])
-                ? ref['_definition'].fieldsByIndex[fieldIndex]
-                : ref['$indexes'].get(fieldIndex);
+    return dump;
+}
 
-            currentStructure[field] = changeTree.getValue(fieldIndex);
-        });
+export function getNextPowerOf2(number: number) {
+    // If number is already a power of 2, return it
+    if ((number & (number - 1)) === 0) {
+        return number;
+    }
 
+    // Find the position of the most significant bit
+    let msbPosition = 0;
+    while (number > 0) {
+        number >>= 1;
+        msbPosition++;
     }
 
-    return dump;
-}
+    // Return the next power of 2
+    return 1 << msbPosition;
+}

package/src/v3_bench.ts

@@ -0,0 +1,107 @@
+import { Schema, type, MapSchema, ArraySchema, Reflection, Encoder, Decoder } from "./index";
+
+// globalThis.interval = setInterval(() => {}, 1000);
+
+// class Item extends Schema {
+//     @type("string") name: string;
+// }
+
+// class RootState extends Schema {
+//     @type([Item]) items = new ArraySchema<Item>();
+// }
+// const state = new RootState();
+// state.items.push(new Item().assign({ name: "hello" }));
+
+// console.log("Encoded:", state.encode());
+
+class Vec3 extends Schema {
+    @type("number") x: number;
+    @type("number") y: number;
+    @type("number") z: number;
+}
+
+class Base extends Schema {}
+
+class Entity extends Schema {
+    @type(Vec3) position = new Vec3().assign({ x: 0, y: 0, z: 0 });
+}
+
+class Player extends Entity {
+    @type(Vec3) rotation = new Vec3().assign({ x: 0, y: 0, z: 0 });
+    @type("string") secret: string = "private info only for this player";
+}
+
+class State extends Schema {
+    // @type({ map: Base }) players = new MapSchema<Entity>();
+    @type("number") num: number = 0;
+    @type("string") str = "Hello world!";
+    // @type(Entity) entity = new Player().assign({
+    //     position: new Vec3().assign({ x: 1, y: 2, z: 3 }),
+    //     rotation: new Vec3().assign({ x: 4, y: 5, z: 6 }),
+    // });
+    @type({ map: Entity }) entities = new MapSchema();
+}
+
+const state = new State();
+
+state.entities.set("one", new Player().assign({
+  position: new Vec3().assign({ x: 1, y: 2, z: 3 }),
+  rotation: new Vec3().assign({ x: 1, y: 2, z: 3 }),
+}));
+
+state.entities.set("two", new Player().assign({
+  position: new Vec3().assign({ x: 4, y: 5, z: 6 }),
+  rotation: new Vec3().assign({ x: 7, y: 8, z: 9 }),
+}));
+
+const encoder = new Encoder(state);
+let encoded = encoder.encode();
+console.log(`(${encoded.length})`, [...encoded]);
+
+globalThis.perform = function() {
+    for (let i = 0; i < 500000; i++) {
+        encoder.encodeAll();
+    }
+}
+
+function logTime(label: string, callback: Function) {
+    const time = Date.now();
+    for (let i = 0; i < 500000; i++) {
+        callback();
+    }
+    console.log(`${label}:`, Date.now() - time);
+}
+logTime("encode time", () => encoder.encodeAll());
+
+const decoder = new Decoder(new State());
+logTime("decode time", () => decoder.decode(encoded));
+
+// const time = Date.now();
+// console.profile();
+// for (let i = 0; i < 300000; i++) {
+//   state.encodeAll();
+// }
+// console.profileEnd();
+// console.log("encode time:", Date.now() - time);
+
+// const decoded = Reflection.decode(Reflection.encode(state));
+// decoded.decode(encoded);
+//
+// console.log(decoded.toJSON());
+//
+// const rotation = state.entity.rotation;
+// rotation.x = 100;
+//
+// encoded = state.encode();
+// console.log({encoded});
+//
+// decoded.decode(encoded);
+// console.log(decoded.toJSON());
+
+// const time = Date.now();
+// for (let i = 0; i < 300000; i++) {
+//   const state = new State();
+//   state.encode();
+// }
+// console.log("encode time:", Date.now() - time);
+