@colyseus/schema 3.0.0-alpha.4 → 3.0.0-alpha.40

package/src/encoder/StateView.ts

@@ -1,11 +1,11 @@
-import { ChangeTree, Ref } from "./ChangeTree";
-import { $changes } from "../types/symbols";
+import { ChangeSet, ChangeTree, IndexedOperations, Ref } from "./ChangeTree";
+import { $changes, $fieldIndexesByViewTag, $viewFieldIndexes } from "../types/symbols";
 import { DEFAULT_VIEW_TAG } from "../annotations";
 import { OPERATION } from "../encoding/spec";
 import { Metadata } from "../Metadata";
-import type { Schema } from "../Schema";
 
-export function createView(root: Schema) {
+export function createView() {
+    return new StateView();
 }
 
 export class StateView {
@@ -25,37 +25,35 @@ export class StateView {
      * Manual "ADD" operations for changes per ChangeTree, specific to this view.
      * (This is used to force encoding a property, even if it was not changed)
      */
-    changes = new Map<ChangeTree, Map<number, OPERATION>>();
+    changes: { [refId: number]: IndexedOperations } = {};
 
     // 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
         // be set (only the parent's changes are set)
         //
-        let changes = this.changes.get(changeTree);
+        let changes = this.changes[changeTree.refId];
         if (changes === undefined) {
-            changes = new Map<number, OPERATION>();
-            this.changes.set(changeTree, changes)
+            changes = {};
+            this.changes[changeTree.refId] = changes;
         }
 
         // set tag
@@ -72,99 +70,89 @@ export class StateView {
             }
             tags.add(tag);
 
-            // console.log("BY TAG:", tag);
-
             // Ref: add tagged properties
-            metadata?.[-3]?.[tag]?.forEach((index) => {
+            metadata?.[$fieldIndexesByViewTag]?.[tag]?.forEach((index) => {
                 if (changeTree.getChange(index) !== OPERATION.DELETE) {
-                    changes.set(index, OPERATION.ADD)
+                    changes[index] = OPERATION.ADD;
                 }
             });
 
         } 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) {
+            for (let i = 0, len = changeSet.operations.length; i < len; i++) {
+                const index = changeSet.operations[i];
+                if (index === undefined) { continue; } // skip "undefined" indexes
+
+                const op = changeTree.indexedOperations[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[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[changeTree.refId];
+            if (changes === undefined) {
+                changes = {};
+                this.changes[changeTree.refId] = 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[parentIndex] = OPERATION.ADD;
         }
-
     }
 
     remove(obj: Ref, tag: number = DEFAULT_VIEW_TAG) {
@@ -179,10 +167,10 @@ export class StateView {
         const ref = changeTree.ref;
         const metadata: Metadata = ref.constructor[Symbol.metadata];
 
-        let changes = this.changes.get(changeTree);
+        let changes = this.changes[changeTree.refId];
         if (changes === undefined) {
-            changes = new Map<number, OPERATION>();
-            this.changes.set(changeTree, changes)
+            changes = {};
+            this.changes[changeTree.refId] = changes;
         }
 
         if (tag === DEFAULT_VIEW_TAG) {
@@ -190,25 +178,25 @@ export class StateView {
             const parent = changeTree.parent;
             if (!Metadata.isValidInstance(parent)) {
                 const parentChangeTree = parent[$changes];
-                let changes = this.changes.get(parentChangeTree);
+                let changes = this.changes[parentChangeTree.refId];
                 if (changes === undefined) {
-                    changes = new Map<number, OPERATION>();
-                    this.changes.set(parentChangeTree, changes)
+                    changes = {};
+                    this.changes[parentChangeTree.refId] = changes;
                 }
                 // DELETE / DELETE BY REF ID
-                changes.set(changeTree.parentIndex, OPERATION.DELETE);
+                changes[changeTree.parentIndex] = OPERATION.DELETE;
 
             } else {
                 // delete all "tagged" properties.
-                metadata[-2].forEach((index) =>
-                    changes.set(index, OPERATION.DELETE));
+                metadata[$viewFieldIndexes].forEach((index) =>
+                    changes[index] = OPERATION.DELETE);
             }
 
 
         } else {
             // delete only tagged properties
-            metadata[-3][tag].forEach((index) =>
-                changes.set(index, OPERATION.DELETE));
+            metadata[$fieldIndexesByViewTag][tag].forEach((index) =>
+                changes[index] = OPERATION.DELETE);
         }
 
         // remove 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/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: (str: string, _?: any) => number = (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);
@@ -64,21 +68,24 @@ export function utf8Write(view, str, it) {
       view[it.offset++] = c;
     }
     else if (c < 0x800) {
-      view[it.offset++] = 0xc0 | (c >> 6);
-      view[it.offset++] = 0x80 | (c & 0x3f);
+      view[it.offset] = 0xc0 | (c >> 6);
+      view[it.offset + 1] = 0x80 | (c & 0x3f);
+      it.offset += 2;
     }
     else if (c < 0xd800 || c >= 0xe000) {
-      view[it.offset++] = 0xe0 | (c >> 12);
-      view[it.offset++] = 0x80 | (c >> 6 & 0x3f);
-      view[it.offset++] = 0x80 | (c & 0x3f);
+      view[it.offset] = 0xe0 | (c >> 12);
+      view[it.offset+1] = 0x80 | (c >> 6 & 0x3f);
+      view[it.offset+2] = 0x80 | (c & 0x3f);
+      it.offset += 3;
     }
     else {
       i++;
       c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
-      view[it.offset++] = 0xf0 | (c >> 18);
-      view[it.offset++] = 0x80 | (c >> 12 & 0x3f);
-      view[it.offset++] = 0x80 | (c >> 6 & 0x3f);
-      view[it.offset++] = 0x80 | (c & 0x3f);
+      view[it.offset] = 0xf0 | (c >> 18);
+      view[it.offset+1] = 0x80 | (c >> 12 & 0x3f);
+      view[it.offset+2] = 0x80 | (c >> 6 & 0x3f);
+      view[it.offset+3] = 0x80 | (c & 0x3f);
+      it.offset += 4;
     }
   }
 }
@@ -166,8 +173,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, schema, type SchemaWithExtends, } 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/HelperTypes.ts

@@ -1,5 +1,11 @@
-import { ArraySchema } from "./custom/ArraySchema";
-import { MapSchema } from "./custom/MapSchema";
+import type { Definition, DefinitionType, PrimitiveType, RawPrimitiveType } from "../annotations";
+import type { Schema } from "../Schema";
+import type { ArraySchema } from "./custom/ArraySchema";
+import type { CollectionSchema } from "./custom/CollectionSchema";
+import type { MapSchema } from "./custom/MapSchema";
+import type { SetSchema } from "./custom/SetSchema";
+
+export type Constructor<T = {}> = new (...args: any[]) => T;
 
 export interface Collection<K = any, V = any, IT = V> {
     [Symbol.iterator](): IterableIterator<IT>;
@@ -7,6 +13,52 @@ export interface Collection<K = any, V = any, IT = V> {
     entries(): IterableIterator<[K, V]>;
 }
 
+export type InferValueType<T extends DefinitionType> =
+    T extends "string" ? string
+    : T extends "number" ? number
+    : T extends "int8" ? number
+    : T extends "uint8" ? number
+    : T extends "int16" ? number
+    : T extends "uint16" ? number
+    : T extends "int32" ? number
+    : T extends "uint32" ? number
+    : T extends "int64" ? number
+    : T extends "uint64" ? number
+    : T extends "float32" ? number
+    : T extends "float64" ? number
+    : T extends "boolean" ? boolean
+
+    : T extends { type: infer ChildType extends Constructor } ? InstanceType<ChildType>
+    : T extends { type: infer ChildType extends PrimitiveType } ? ChildType
+
+    : T extends Array<infer ChildType extends Constructor> ? InstanceType<ChildType>[]
+    : T extends Array<infer ChildType extends RawPrimitiveType> ? ChildType[]
+
+    : T extends { array: infer ChildType extends Constructor } ? InstanceType<ChildType>[]
+    : T extends { array: infer ChildType extends PrimitiveType } ? ChildType[]
+
+    : T extends { map: infer ChildType extends Constructor } ? MapSchema<InstanceType<ChildType>>
+    : T extends { map: infer ChildType extends PrimitiveType } ? MapSchema<ChildType>
+
+    : T extends { set: infer ChildType extends Constructor } ? SetSchema<InstanceType<ChildType>>
+    : T extends { set: infer ChildType extends PrimitiveType } ? SetSchema<ChildType>
+
+    : T extends { collection: infer ChildType extends Constructor } ? CollectionSchema<InstanceType<ChildType>>
+    : T extends { collection: infer ChildType extends PrimitiveType } ? CollectionSchema<ChildType>
+
+    : T extends Constructor ? InstanceType<T>
+    : T extends PrimitiveType ? T
+
+    : never;
+
+export type InferSchemaInstanceType<T extends Definition> = {
+    [K in keyof T]: 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]>;

package/src/types/TypeContext.ts

@@ -0,0 +1,133 @@
+import { Metadata } from "../Metadata";
+import { Schema } from "../Schema";
+import { $viewFieldIndexes } from "./symbols";
+
+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.initialize(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);
+        });
+
+        // add parent classes
+        let parent: any = klass;
+        while (
+            (parent = Object.getPrototypeOf(parent)) &&
+            parent !== Schema && // stop at root (Schema)
+            parent !== Function.prototype // stop at root (non-Schema)
+        ) {
+            this.discoverTypes(parent);
+        }
+
+        const metadata: Metadata = (klass[Symbol.metadata] ??= {});
+
+        // if any schema/field has filters, mark "context" as having filters.
+        if (metadata[$viewFieldIndexes]) {
+            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);
+            }
+        }
+    }
+}