@colyseus/schema 3.0.0-alpha.9 → 3.0.1

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;

package/lib/Decoder.d.ts

@@ -1,16 +0,0 @@
-import { TypeContext } from "./annotations";
-import { DataChange, Schema } from "./Schema";
-import { Ref } from "./changes/ChangeTree";
-import { Iterator } from "./encoding/decode";
-import { ReferenceTracker } from "./changes/ReferenceTracker";
-export declare class Decoder<T extends Schema = any> {
-    context: TypeContext;
-    root: T;
-    refs: ReferenceTracker;
-    currentRefId: number;
-    constructor(root: T, context?: TypeContext);
-    protected setRoot(root: T): void;
-    decode(bytes: number[], it?: Iterator, ref?: Ref): DataChange<any, string>[];
-    getInstanceType(bytes: number[], it: Iterator, defaultType: typeof Schema): typeof Schema;
-    createInstanceOfType(type: typeof Schema): Schema;
-}

package/lib/Decoder.js

@@ -1,182 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Decoder = void 0;
-const annotations_1 = require("./annotations");
-const consts_1 = require("./changes/consts");
-const decode = require("./encoding/decode");
-const spec_1 = require("./spec");
-const ReferenceTracker_1 = require("./changes/ReferenceTracker");
-const DecodeOperation_1 = require("./changes/DecodeOperation");
-class Decoder {
-    constructor(root, context) {
-        this.currentRefId = 0;
-        this.setRoot(root);
-        this.context = context || new annotations_1.TypeContext(root.constructor);
-        // console.log(">>>>>>>>>>>>>>>> Decoder types");
-        // this.context.schemas.forEach((id, schema) => {
-        //     console.log("type:", id, schema.name, Object.keys(schema[Symbol.metadata]));
-        // });
-    }
-    setRoot(root) {
-        this.root = root;
-        this.refs = new ReferenceTracker_1.ReferenceTracker();
-        this.refs.addRef(0, root);
-    }
-    decode(bytes, it = { offset: 0 }, ref = this.root) {
-        // console.log("------------------- DECODE -------------------");
-        const allChanges = [];
-        const $root = this.refs;
-        const totalBytes = bytes.length;
-        this.currentRefId = 0;
-        while (it.offset < totalBytes) {
-            //
-            // Peek ahead, check if it's a switch to a different structure
-            //
-            if (bytes[it.offset] == spec_1.SWITCH_TO_STRUCTURE) {
-                it.offset++;
-                this.currentRefId = decode.number(bytes, it);
-                const nextRef = $root.refs.get(this.currentRefId);
-                //
-                // Trying to access a reference that haven't been decoded yet.
-                //
-                if (!nextRef) {
-                    throw new Error(`"refId" not found: ${this.currentRefId}`);
-                }
-                ref = nextRef;
-                continue;
-            }
-            const decoder = ref['constructor'][consts_1.$decoder];
-            const result = decoder(this, bytes, it, ref, allChanges);
-            if (result === DecodeOperation_1.DecodeState.DEFINITION_MISMATCH) {
-                console.warn("@colyseus/schema: definition mismatch");
-                //
-                // keep skipping next bytes until reaches a known structure
-                // by local decoder.
-                //
-                const nextIterator = { offset: it.offset };
-                while (it.offset < totalBytes) {
-                    if (decode.switchStructureCheck(bytes, it)) {
-                        nextIterator.offset = it.offset + 1;
-                        if ($root.refs.has(decode.number(bytes, nextIterator))) {
-                            break;
-                        }
-                    }
-                    it.offset++;
-                }
-                continue;
-            }
-        }
-        // FIXME: trigger callbacks
-        // this._triggerChanges(allChanges);
-        // drop references of unused schemas
-        $root.garbageCollectDeletedRefs();
-        return allChanges;
-    }
-    /*
-    private _triggerChanges(changes: DataChange[]) {
-        const uniqueRefIds = new Set<number>();
-        const $refs = this.refs.refs;
-
-        for (let i = 0; i < changes.length; i++) {
-            const change = changes[i];
-            const refId = change.refId;
-            const ref = $refs.get(refId);
-            const $callbacks: Schema['$callbacks'] | SchemaDecoderCallbacks['$callbacks'] = ref['$callbacks'];
-
-            //
-            // trigger onRemove on child structure.
-            //
-            if (
-                (change.op & OPERATION.DELETE) === OPERATION.DELETE &&
-                change.previousValue instanceof Schema
-            ) {
-                change.previousValue['$callbacks']?.[OPERATION.DELETE]?.forEach(callback => callback());
-            }
-
-            // no callbacks defined, skip this structure!
-            if (!$callbacks) { continue; }
-
-            if (ref instanceof Schema) {
-                if (!uniqueRefIds.has(refId)) {
-                    try {
-                        // trigger onChange
-                        ($callbacks as Schema['$callbacks'])?.[OPERATION.REPLACE]?.forEach(callback =>
-                            callback());
-
-                    } catch (e) {
-                        Schema.onError(e);
-                    }
-                }
-
-                try {
-                    if ($callbacks.hasOwnProperty(change.field)) {
-                        $callbacks[change.field]?.forEach((callback) =>
-                            callback(change.value, change.previousValue));
-                    }
-
-                } catch (e) {
-                    Schema.onError(e);
-                }
-
-            } else {
-                // is a collection of items
-
-                if (change.op === OPERATION.ADD && change.previousValue === undefined) {
-                    // triger onAdd
-                    $callbacks[OPERATION.ADD]?.forEach(callback =>
-                        callback(change.value, change.dynamicIndex ?? change.field));
-
-                } else if (change.op === OPERATION.DELETE) {
-                    //
-                    // FIXME: `previousValue` should always be available.
-                    // ADD + DELETE operations are still encoding DELETE operation.
-                    //
-                    if (change.previousValue !== undefined) {
-                        // triger onRemove
-                        $callbacks[OPERATION.DELETE]?.forEach(callback =>
-                            callback(change.previousValue, change.dynamicIndex ?? change.field));
-                    }
-
-                } else if (change.op === OPERATION.DELETE_AND_ADD) {
-                    // triger onRemove
-                    if (change.previousValue !== undefined) {
-                        $callbacks[OPERATION.DELETE]?.forEach(callback =>
-                            callback(change.previousValue, change.dynamicIndex ?? change.field));
-                    }
-
-                    // triger onAdd
-                    $callbacks[OPERATION.ADD]?.forEach(callback =>
-                        callback(change.value, change.dynamicIndex ?? change.field));
-                }
-
-                // trigger onChange
-                if (change.value !== change.previousValue) {
-                    $callbacks[OPERATION.REPLACE]?.forEach(callback =>
-                        callback(change.value, change.dynamicIndex ?? change.field));
-                }
-            }
-
-            uniqueRefIds.add(refId);
-        }
-
-    }
-    */
-    getInstanceType(bytes, it, defaultType) {
-        let type;
-        if (bytes[it.offset] === spec_1.TYPE_ID) {
-            it.offset++;
-            const type_id = decode.number(bytes, it);
-            type = this.context.get(type_id);
-        }
-        return type || defaultType;
-    }
-    createInstanceOfType(type) {
-        // let instance: Schema = new (type as any)();
-        // // assign root on $changes
-        // instance[$changes].root = this.root[$changes].root;
-        // return instance;
-        return new type();
-    }
-}
-exports.Decoder = Decoder;
-//# sourceMappingURL=Decoder.js.map

package/lib/Decoder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Decoder.js","sourceRoot":"","sources":["../src/Decoder.ts"],"names":[],"mappings":"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","sourcesContent":["import { Metadata } from \"./Metadata\";\nimport { TypeContext } from \"./annotations\";\nimport { $childType, $decoder } from \"./changes/consts\";\nimport { DataChange, Schema, SchemaDecoderCallbacks } from \"./Schema\";\nimport { CollectionSchema } from \"./types/CollectionSchema\";\nimport { MapSchema } from \"./types/MapSchema\";\nimport { SetSchema } from \"./types/SetSchema\";\nimport { ArraySchema } from \"./types/ArraySchema\";\n\nimport * as decode from \"./encoding/decode\";\nimport { getType } from './types/typeRegistry';\nimport { SWITCH_TO_STRUCTURE, TYPE_ID, OPERATION } from './spec';\nimport { Ref } from \"./changes/ChangeTree\";\nimport { Iterator } from \"./encoding/decode\";\nimport { ReferenceTracker } from \"./changes/ReferenceTracker\";\nimport { DecodeState } from \"./changes/DecodeOperation\";\n\nexport class Decoder<T extends Schema = any> {\n    context: TypeContext;\n\n    root: T;\n    refs: ReferenceTracker;\n\n    currentRefId: number = 0;\n\n    constructor(root: T, context?: TypeContext) {\n        this.setRoot(root);\n        this.context = context || new TypeContext(root.constructor as typeof Schema);\n\n        // console.log(\">>>>>>>>>>>>>>>> Decoder types\");\n        // this.context.schemas.forEach((id, schema) => {\n        //     console.log(\"type:\", id, schema.name, Object.keys(schema[Symbol.metadata]));\n        // });\n    }\n\n    protected setRoot(root: T) {\n        this.root = root;\n        this.refs = new ReferenceTracker();\n        this.refs.addRef(0, root);\n    }\n\n    decode(\n        bytes: number[],\n        it: Iterator = { offset: 0 },\n        ref: Ref = this.root,\n    ) {\n        // console.log(\"------------------- DECODE -------------------\");\n        const allChanges: DataChange[] = [];\n\n        const $root = this.refs;\n        const totalBytes = bytes.length;\n\n        this.currentRefId = 0;\n\n        while (it.offset < totalBytes) {\n            //\n            // Peek ahead, check if it's a switch to a different structure\n            //\n            if (bytes[it.offset] == SWITCH_TO_STRUCTURE) {\n                it.offset++;\n\n                this.currentRefId = decode.number(bytes, it);\n                const nextRef = $root.refs.get(this.currentRefId) as Schema;\n\n                //\n                // Trying to access a reference that haven't been decoded yet.\n                //\n                if (!nextRef) { throw new Error(`\"refId\" not found: ${this.currentRefId}`); }\n                ref = nextRef;\n\n                continue;\n            }\n\n            const decoder = ref['constructor'][$decoder];\n            const result = decoder(this, bytes, it, ref, allChanges);\n\n            if (result === DecodeState.DEFINITION_MISMATCH) {\n                console.warn(\"@colyseus/schema: definition mismatch\");\n\n                //\n                // keep skipping next bytes until reaches a known structure\n                // by local decoder.\n                //\n                const nextIterator: decode.Iterator = { offset: it.offset };\n                while (it.offset < totalBytes) {\n                    if (decode.switchStructureCheck(bytes, it)) {\n                        nextIterator.offset = it.offset + 1;\n                        if ($root.refs.has(decode.number(bytes, nextIterator))) {\n                            break;\n                        }\n                    }\n\n                    it.offset++;\n                }\n                continue;\n            }\n        }\n\n        // FIXME: trigger callbacks\n        // this._triggerChanges(allChanges);\n\n        // drop references of unused schemas\n        $root.garbageCollectDeletedRefs();\n\n        return allChanges;\n    }\n\n    /*\n    private _triggerChanges(changes: DataChange[]) {\n        const uniqueRefIds = new Set<number>();\n        const $refs = this.refs.refs;\n\n        for (let i = 0; i < changes.length; i++) {\n            const change = changes[i];\n            const refId = change.refId;\n            const ref = $refs.get(refId);\n            const $callbacks: Schema['$callbacks'] | SchemaDecoderCallbacks['$callbacks'] = ref['$callbacks'];\n\n            //\n            // trigger onRemove on child structure.\n            //\n            if (\n                (change.op & OPERATION.DELETE) === OPERATION.DELETE &&\n                change.previousValue instanceof Schema\n            ) {\n                change.previousValue['$callbacks']?.[OPERATION.DELETE]?.forEach(callback => callback());\n            }\n\n            // no callbacks defined, skip this structure!\n            if (!$callbacks) { continue; }\n\n            if (ref instanceof Schema) {\n                if (!uniqueRefIds.has(refId)) {\n                    try {\n                        // trigger onChange\n                        ($callbacks as Schema['$callbacks'])?.[OPERATION.REPLACE]?.forEach(callback =>\n                            callback());\n\n                    } catch (e) {\n                        Schema.onError(e);\n                    }\n                }\n\n                try {\n                    if ($callbacks.hasOwnProperty(change.field)) {\n                        $callbacks[change.field]?.forEach((callback) =>\n                            callback(change.value, change.previousValue));\n                    }\n\n                } catch (e) {\n                    Schema.onError(e);\n                }\n\n            } else {\n                // is a collection of items\n\n                if (change.op === OPERATION.ADD && change.previousValue === undefined) {\n                    // triger onAdd\n                    $callbacks[OPERATION.ADD]?.forEach(callback =>\n                        callback(change.value, change.dynamicIndex ?? change.field));\n\n                } else if (change.op === OPERATION.DELETE) {\n                    //\n                    // FIXME: `previousValue` should always be available.\n                    // ADD + DELETE operations are still encoding DELETE operation.\n                    //\n                    if (change.previousValue !== undefined) {\n                        // triger onRemove\n                        $callbacks[OPERATION.DELETE]?.forEach(callback =>\n                            callback(change.previousValue, change.dynamicIndex ?? change.field));\n                    }\n\n                } else if (change.op === OPERATION.DELETE_AND_ADD) {\n                    // triger onRemove\n                    if (change.previousValue !== undefined) {\n                        $callbacks[OPERATION.DELETE]?.forEach(callback =>\n                            callback(change.previousValue, change.dynamicIndex ?? change.field));\n                    }\n\n                    // triger onAdd\n                    $callbacks[OPERATION.ADD]?.forEach(callback =>\n                        callback(change.value, change.dynamicIndex ?? change.field));\n                }\n\n                // trigger onChange\n                if (change.value !== change.previousValue) {\n                    $callbacks[OPERATION.REPLACE]?.forEach(callback =>\n                        callback(change.value, change.dynamicIndex ?? change.field));\n                }\n            }\n\n            uniqueRefIds.add(refId);\n        }\n\n    }\n    */\n\n    getInstanceType(bytes: number[], it: Iterator, defaultType: typeof Schema): typeof Schema {\n        let type: typeof Schema;\n\n        if (bytes[it.offset] === TYPE_ID) {\n            it.offset++;\n            const type_id = decode.number(bytes, it);\n            type = this.context.get(type_id);\n        }\n\n        return type || defaultType;\n    }\n\n    createInstanceOfType (type: typeof Schema): Schema {\n        // let instance: Schema = new (type as any)();\n\n        // // assign root on $changes\n        // instance[$changes].root = this.root[$changes].root;\n\n        // return instance;\n        return new (type as any)();\n    }\n\n}\n\n"]}

package/lib/Encoder.d.ts

@@ -1,13 +0,0 @@
-import type { Schema } from "./Schema";
-import { TypeContext } from "./annotations";
-import { Root } from "./changes/ChangeTree";
-export declare class Encoder<T extends Schema = any> {
-    context: TypeContext;
-    root: T;
-    $root: Root;
-    constructor(root: T);
-    protected setRoot(root: T): void;
-    encode(encodeAll?: boolean, bytes?: number[], useFilters?: boolean): number[];
-    encodeAll(useFilters?: boolean): number[];
-    tryEncodeTypeId(bytes: number[], baseType: typeof Schema, targetType: typeof Schema): void;
-}