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

package/src/encoder/StateView.ts

@@ -28,25 +28,23 @@ export class StateView {
     changes = new Map<ChangeTree, Map<number, OPERATION>>();
 
     // TODO: allow to set multiple tags at once
-    add(obj: Ref, tag: number = DEFAULT_VIEW_TAG) {
+    add(obj: Ref, tag: number = DEFAULT_VIEW_TAG, checkIncludeParent: boolean = true) {
         if (!obj[$changes]) {
             console.warn("StateView#add(), invalid object:", obj);
             return this;
         }
 
-        let changeTree: ChangeTree = obj[$changes];
-        this.items.add(changeTree);
-
-        // Add children of this ChangeTree to this view
-        changeTree.forEachChild((change, _) =>
-            this.add(change.ref, tag));
-
-        // FIXME: ArraySchema/MapSchema does not have metadata
+        // FIXME: ArraySchema/MapSchema do not have metadata
         const metadata: Metadata = obj.constructor[Symbol.metadata];
+        const changeTree: ChangeTree = obj[$changes];
+        this.items.add(changeTree);
 
-        // add parent ChangeTree's, if they are invisible to this view
-        // TODO: REFACTOR addParent()
-        this.addParent(changeTree, tag);
+        // add parent ChangeTree's
+        // - if it was invisible to this view
+        // - if it were previously filtered out
+        if (checkIncludeParent && changeTree.parent) {
+            this.addParent(changeTree.parent[$changes], changeTree.parentIndex, tag);
+        }
 
         //
         // TODO: when adding an item of a MapSchema, the changes may not
@@ -72,8 +70,6 @@ export class StateView {
             }
             tags.add(tag);
 
-            // console.log("BY TAG:", tag);
-
             // Ref: add tagged properties
             metadata?.[-3]?.[tag]?.forEach((index) => {
                 if (changeTree.getChange(index) !== OPERATION.DELETE) {
@@ -82,89 +78,77 @@ export class StateView {
             });
 
         } else {
-
-            // console.log("DEFAULT TAG", changeTree.allChanges);
-
-            // // add default tag properties
-            // metadata?.[-3]?.[DEFAULT_VIEW_TAG]?.forEach((index) => {
-            //     if (changeTree.getChange(index) !== OPERATION.DELETE) {
-            //         changes.set(index, OPERATION.ADD);
-            //     }
-            // });
-
-            const allChangesSet = (changeTree.isFiltered || changeTree.isPartiallyFiltered)
+            const isInvisible = this.invisible.has(changeTree);
+            const changeSet = (changeTree.isFiltered || changeTree.isPartiallyFiltered)
                 ? changeTree.allFilteredChanges
                 : changeTree.allChanges;
-            const it = allChangesSet.keys();
-            const isInvisible = this.invisible.has(changeTree);
 
-            for (const index of it) {
+            changeSet.forEach((op, index) => {
+                const tagAtIndex = metadata?.[index].tag;
                 if (
-                    (isInvisible || metadata?.[metadata?.[index]].tag === tag) &&
-                    changeTree.getChange(index) !== OPERATION.DELETE
+                    (
+                        isInvisible || // if "invisible", include all
+                        tagAtIndex === undefined || // "all change" with no tag
+                        tagAtIndex === tag // tagged property
+                    ) &&
+                    op !== OPERATION.DELETE
                 ) {
-                    changes.set(index, OPERATION.ADD);
+                    changes.set(index, op);
                 }
-            }
+            });
         }
 
-        // TODO: avoid unnecessary iteration here
-        while (
-            changeTree.parent &&
-            (changeTree = changeTree.parent[$changes]) &&
-            (changeTree.isFiltered || changeTree.isPartiallyFiltered)
-        ) {
-            this.items.add(changeTree);
-        }
+        // Add children of this ChangeTree to this view
+        changeTree.forEachChild((change, index) => {
+            // Do not ADD children that don't have the same tag
+            if (metadata && metadata[index].tag !== tag) {
+                return;
+            }
+            this.add(change.ref, tag, false);
+        });
 
         return this;
     }
 
-    protected addParent(changeTree: ChangeTree, tag: number) {
-        const parentRef = changeTree.parent;
-        if (!parentRef) { return; }
+    protected addParent(changeTree: ChangeTree, parentIndex: number, tag: number) {
+        // view must have all "changeTree" parent tree
+        this.items.add(changeTree);
 
-        const parentChangeTree = parentRef[$changes];
-        const parentIndex = changeTree.parentIndex;
+        // add parent's parent
+        const parentChangeTree = changeTree.parent?.[$changes];
+        if (parentChangeTree && (parentChangeTree.isFiltered || parentChangeTree.isPartiallyFiltered)) {
+            this.addParent(parentChangeTree, changeTree.parentIndex, tag);
+        }
 
-        if (!this.invisible.has(parentChangeTree)) {
-            // parent is already available, no need to add it!
+        // parent is already available, no need to add it!
+        if (!this.invisible.has(changeTree)) {
             return;
         }
 
-        this.addParent(parentChangeTree, tag);
-
         // add parent's tag properties
-        if (parentChangeTree.getChange(parentIndex) !== OPERATION.DELETE) {
+        if (changeTree.getChange(parentIndex) !== OPERATION.DELETE) {
 
-            let parentChanges = this.changes.get(parentChangeTree);
-            if (parentChanges === undefined) {
-                parentChanges = new Map<number, OPERATION>();
-                this.changes.set(parentChangeTree, parentChanges);
+            let changes = this.changes.get(changeTree);
+            if (changes === undefined) {
+                changes = new Map<number, OPERATION>();
+                this.changes.set(changeTree, changes);
             }
 
-            // console.log("add parent change", {
-            //     parentIndex,
-            //     parentChanges,
-            //     parentChange: (
-            //         parentChangeTree.getChange(parentIndex) &&
-            //         OPERATION[parentChangeTree.getChange(parentIndex)]
-            //     ),
-            // })
+            if (!this.tags) {
+                this.tags = new WeakMap<ChangeTree, Set<number>>();
+            }
 
-            if (!this.tags) { this.tags = new WeakMap<ChangeTree, Set<number>>(); }
             let tags: Set<number>;
-            if (!this.tags.has(parentChangeTree)) {
+            if (!this.tags.has(changeTree)) {
                 tags = new Set<number>();
-                this.tags.set(parentChangeTree, tags);
+                this.tags.set(changeTree, tags);
             } else {
-                tags = this.tags.get(parentChangeTree);
+                tags = this.tags.get(changeTree);
             }
             tags.add(tag);
 
-            parentChanges.set(parentIndex, OPERATION.ADD);
+            changes.set(parentIndex, OPERATION.ADD);
         }
-
     }
 
     remove(obj: Ref, tag: number = DEFAULT_VIEW_TAG) {
@@ -182,7 +166,7 @@ export class StateView {
         let changes = this.changes.get(changeTree);
         if (changes === undefined) {
             changes = new Map<number, OPERATION>();
-            this.changes.set(changeTree, changes)
+            this.changes.set(changeTree, changes);
         }
 
         if (tag === DEFAULT_VIEW_TAG) {

package/src/encoding/assert.ts

@@ -3,6 +3,7 @@ import { CollectionSchema } from "../types/custom/CollectionSchema";
 import { MapSchema } from "../types/custom/MapSchema";
 import { SetSchema } from "../types/custom/SetSchema";
 import { ArraySchema } from "../types/custom/ArraySchema";
+import type { Ref } from "../encoder/ChangeTree";
 
 export class EncodeSchemaError extends Error {}
 
@@ -43,16 +44,16 @@ export function assertType(value: any, type: string, klass: Schema, field: strin
 }
 
 export function assertInstanceType(
-    value: Schema,
+    value: Ref,
     type: typeof Schema
         | typeof ArraySchema
         | typeof MapSchema
         | typeof CollectionSchema
         | typeof SetSchema,
-    klass: Schema,
+    instance: Ref,
     field: string | number,
 ) {
     if (!(value instanceof type)) {
-        throw new EncodeSchemaError(`a '${type.name}' was expected, but '${value && (value as any).constructor.name}' was provided in ${klass.constructor.name}#${field}`);
+        throw new EncodeSchemaError(`a '${type.name}' was expected, but '${value && (value as any).constructor.name}' was provided in ${instance.constructor.name}#${field}`);
     }
 }

package/src/encoding/decode.ts

@@ -32,8 +32,6 @@ import type { BufferLike } from "./encode";
 export interface Iterator { offset: number; }
 
 export function utf8Read(bytes: BufferLike, it: Iterator, length: number) {
-  it.offset += length;
-
   var string = '', chr = 0;
   for (var i = it.offset, end = it.offset + length; i < end; i++) {
     var byte = bytes[i];
@@ -74,6 +72,7 @@ export function utf8Read(bytes: BufferLike, it: Iterator, length: number) {
     // (do not throw error to avoid server/client from crashing due to hack attemps)
     // throw new Error('Invalid byte ' + byte.toString(16));
   }
+  it.offset += length;
   return string;
 }
 

package/src/encoding/encode.ts

@@ -35,28 +35,32 @@ let textEncoder: TextEncoder;
 // @ts-ignore
 try { textEncoder = new TextEncoder(); } catch (e) { }
 
-export function utf8Length(str) {
-  var c = 0, length = 0;
-  for (var i = 0, l = str.length; i < l; i++) {
-    c = str.charCodeAt(i);
-    if (c < 0x80) {
-      length += 1;
-    }
-    else if (c < 0x800) {
-      length += 2;
-    }
-    else if (c < 0xd800 || c >= 0xe000) {
-      length += 3;
-    }
-    else {
-      i++;
-      length += 4;
+const hasBufferByteLength = (typeof Buffer !== 'undefined' && Buffer.byteLength);
+
+export const utf8Length = (hasBufferByteLength)
+    ? Buffer.byteLength // node
+    : function (str: string, _?: any) {
+        var c = 0, length = 0;
+        for (var i = 0, l = str.length; i < l; i++) {
+            c = str.charCodeAt(i);
+            if (c < 0x80) {
+                length += 1;
+            }
+            else if (c < 0x800) {
+                length += 2;
+            }
+            else if (c < 0xd800 || c >= 0xe000) {
+                length += 3;
+            }
+            else {
+                i++;
+                length += 4;
+            }
+        }
+        return length;
     }
-  }
-  return length;
-}
 
-export function utf8Write(view, str, it) {
+export function utf8Write(view: BufferLike, str: string, it: Iterator) {
   var c = 0;
   for (var i = 0, l = str.length; i < l; i++) {
     c = str.charCodeAt(i);
@@ -166,8 +170,7 @@ export function string(bytes: BufferLike, value: string, it: Iterator) {
   // encode `null` strings as empty.
   if (!value) { value = ""; }
 
-  // let length = utf8Length(value);
-  let length = Buffer.byteLength(value, "utf8");
+  let length = utf8Length(value, "utf8");
   let size = 0;
 
   // fixstr

package/src/encoding/spec.ts

@@ -25,5 +25,6 @@ export enum OPERATION {
     REVERSE = 15,
     MOVE = 32,
     DELETE_BY_REFID = 33, // This operation is only used at ENCODING time. During DECODING, DELETE_BY_REFID is converted to DELETE
+    ADD_BY_REFID = 129,
 
 }

package/src/index.ts

@@ -1,8 +1,6 @@
 export { Schema } from "./Schema";
 export type { DataChange } from "./decoder/DecodeOperation";
-
-import { $track, $encoder, $decoder, $filter, $getByIndex, $deleteByIndex, $changes, $childType } from "./types/symbols";
-export { $track, $encoder, $decoder, $filter, $getByIndex, $deleteByIndex, $changes, $childType };
+export type { ToJSON } from "./types/HelperTypes";
 
 import { MapSchema } from "./types/custom/MapSchema"
 export { MapSchema };
@@ -28,6 +26,7 @@ registerType("collection", { constructor: CollectionSchema, });
 export { dumpChanges } from "./utils";
 
 // Encoder / Decoder
+export { $track, $encoder, $decoder, $filter, $getByIndex, $deleteByIndex, $changes, $childType } from "./types/symbols";
 export type { Iterator } from "./encoding/decode";
 import * as encode from "./encoding/encode";
 import * as decode from "./encoding/decode";
@@ -40,22 +39,17 @@ export {
     ReflectionField,
 } from "./Reflection";
 
+// Annotations, Metadata and TypeContext
 export { Metadata } from "./Metadata";
-
-export {
-    // Annotations
-    type,
-    deprecated,
-    defineTypes,
-    view,
-
-    // Internals
-    TypeContext,
-} from "./annotations";
+export { type, deprecated, defineTypes, view, } from "./annotations";
+export { TypeContext } from "./types/TypeContext";
 
 // Annotation types
 export type { DefinitionType, PrimitiveType, Definition, } from "./annotations";
 
+export { getDecoderStateCallbacks, CallbackProxy, GetCallbackProxy } from "./decoder/strategy/StateCallbacks";
+export { getRawChangesCallback } from "./decoder/strategy/RawChanges";
+
 export { Encoder } from "./encoder/Encoder";
 export { encodeSchemaOperation, encodeArray as encodeKeyValueOperation } from "./encoder/EncodeOperation";
 export { ChangeTree, Ref } from "./encoder/ChangeTree";

package/src/types/TypeContext.ts

@@ -0,0 +1,122 @@
+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 fieldIndex in metadata) {
+            const index = fieldIndex as any as number;
+
+            const fieldType = metadata[index].type;
+            const viewTag = metadata[index].tag;
+
+            if (typeof (fieldType) === "string") {
+                continue;
+            }
+
+            if (Array.isArray(fieldType)) {
+                const type = fieldType[0];
+
+                // skip primitive types
+                if (type === "string") {
+                    continue;
+                }
+
+                this.discoverTypes(type as typeof Schema, 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, index, viewTag);
+            }
+        }
+    }
+}

package/src/types/custom/ArraySchema.ts

@@ -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();
@@ -85,6 +86,8 @@ 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]) {
                                     this[$changes].indexedOperation(Number(key), OPERATION.MOVE_AND_ADD);
@@ -99,6 +102,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
                             } else if (setValue[$changes][$isNew]) {
                                 this[$changes].indexedOperation(Number(key), OPERATION.ADD);
                             }
+
                         } else {
                             obj.$changeAt(Number(key), setValue);
                         }
@@ -133,6 +137,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
         });
 
         this[$changes] = new ChangeTree(proxy);
+        this[$changes].indexes = {};
         this.push.apply(this, items);
 
         return proxy;
@@ -159,11 +164,13 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
             // skip null values
             if (value === undefined || value === null) {
                 return;
+
+            } else if (typeof (value) === "object" && this[$childType]) {
+                assertInstanceType(value as any, this[$childType] as typeof Schema, this, i);
             }
 
             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 +478,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 +698,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

@@ -6,6 +6,8 @@ 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]> {
     protected childType: new () => V;
@@ -39,6 +41,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
 
     constructor (initialValues?: Map<K, V> | Record<K, V>) {
         this[$changes] = new ChangeTree(this);
+        this[$changes].indexes = {};
 
         if (initialValues) {
             if (
@@ -71,6 +74,9 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
     set(key: K, 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

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

@@ -7,6 +7,8 @@ export const $filter = Symbol("$filter");
 export const $getByIndex = Symbol("$getByIndex");
 export const $deleteByIndex = Symbol("$deleteByIndex");
 
+export const $descriptors = Symbol("$descriptors");
+
 /**
  * Used to hold ChangeTree instances whitin the structures
  */