@colyseus/schema 3.0.61 → 3.0.63

package/src/codegen/cli.ts

@@ -1,7 +1,7 @@
 import argv from "./argv";
 import { generate } from "./api";
 
-const supportedTargets = {
+const supportedTargets: Record<string, string> = {
     csharp: 'generate for C#/Unity',
     cpp: 'generate for C++',
     haxe: 'generate for Haxe',

package/src/codegen/languages/cpp.ts

@@ -1,7 +1,7 @@
 import { Class, Property, File, getCommentHeader, getInheritanceTree, Context } from "../types";
 import { GenerateOptions } from "../api";
 
-const typeMaps = {
+const typeMaps: { [key: string]: string } = {
     "string": "string",
     "number": "varint_t",
     "boolean": "bool",
@@ -17,7 +17,7 @@ const typeMaps = {
     "float64": "float64_t",
 }
 
-const typeInitializer = {
+const typeInitializer: { [key: string]: string } = {
     "string": '""',
     "number": "0",
     "boolean": "false",
@@ -37,11 +37,12 @@ const typeInitializer = {
  * C++ Code Generator
  */
 
-const capitalize = (s) => {
+const capitalize = (s: string) => {
     if (typeof s !== 'string') return ''
     return s.charAt(0).toUpperCase() + s.slice(1);
 }
-const distinct = (value, index, self) => self.indexOf(value) === index;
+const distinct = (value: string, index: number, self: string[]) =>
+    self.indexOf(value) === index;
 
 export function generate (context: Context, options: GenerateOptions): File[] {
     return context.classes.map(klass => ({

package/src/codegen/languages/csharp.ts

@@ -9,7 +9,7 @@ import {
 import { GenerateOptions } from "../api";
 import { Context } from "../types";
 
-const typeMaps = {
+const typeMaps: { [key: string]: string } = {
     "string": "string",
     "number": "float",
     "boolean": "bool",
@@ -28,7 +28,7 @@ const typeMaps = {
 /**
  * C# Code Generator
  */
-const capitalize = (s) => {
+const capitalize = (s: string) => {
     if (typeof s !== 'string') return ''
     return s.charAt(0).toUpperCase() + s.slice(1);
 }

package/src/codegen/languages/haxe.ts

@@ -1,7 +1,7 @@
 import { Class, Property, File, getCommentHeader, Context } from "../types";
 import { GenerateOptions } from "../api";
 
-const typeMaps = {
+const typeMaps: { [key: string]: string } = {
     "string": "String",
     "number": "Dynamic",
     "boolean": "Bool",
@@ -17,7 +17,7 @@ const typeMaps = {
     "float64": "Float",
 }
 
-const typeInitializer = {
+const typeInitializer: { [key: string]: string } = {
     "string": '""',
     "number": "0",
     "boolean": "false",

package/src/codegen/languages/java.ts

@@ -1,7 +1,7 @@
 import { Class, Property, File, getCommentHeader, Context } from "../types";
 import { GenerateOptions } from "../api";
 
-const typeMaps = {
+const typeMaps: { [key: string]: string } = {
     "string": "String",
     "number": "float",
     "boolean": "boolean",
@@ -17,7 +17,7 @@ const typeMaps = {
     "float64": "double",
 }
 
-const typeInitializer = {
+const typeInitializer: { [key: string]: string } = {
     "string": '""',
     "number": "0",
     "boolean": "false",

package/src/codegen/languages/js.ts

@@ -1,7 +1,7 @@
 import { Class, Property, File, getCommentHeader, getInheritanceTree, Context } from "../types";
 import { GenerateOptions } from "../api";
 
-const typeMaps = {
+const typeMaps: { [key: string]: string } = {
     "string": "string",
     "number": "number",
     "boolean": "boolean",
@@ -17,7 +17,8 @@ const typeMaps = {
     "float64": "number",
 }
 
-const distinct = (value, index, self) => self.indexOf(value) === index;
+const distinct = (value: string, index: number, self: string[]) =>
+    self.indexOf(value) === index;
 
 export function generate (context: Context, options: GenerateOptions): File[] {
     return context.classes.map(klass => ({

package/src/codegen/languages/lua.ts

@@ -7,7 +7,7 @@ import { GenerateOptions } from "../api";
     - Support importing Schema dependencies
 */
 
-const typeMaps = {
+const typeMaps: { [key: string]: string } = {
     "string": "string",
     "number": "number",
     "boolean": "boolean",
@@ -23,7 +23,8 @@ const typeMaps = {
     "float64": "number",
 }
 
-const distinct = (value, index, self) => self.indexOf(value) === index;
+const distinct = (value: string, index: number, self: string[]) =>
+    self.indexOf(value) === index;
 
 export function generate (context: Context, options: GenerateOptions): File[] {
     return context.classes.map(klass => ({

package/src/codegen/languages/ts.ts

@@ -1,7 +1,7 @@
 import { Class, Property, File, getCommentHeader, getInheritanceTree, Context, Interface } from "../types";
 import { GenerateOptions } from "../api";
 
-const typeMaps = {
+const typeMaps: { [key: string]: string } = {
     "string": "string",
     "number": "number",
     "boolean": "boolean",
@@ -17,7 +17,8 @@ const typeMaps = {
     "float64": "number",
 }
 
-const distinct = (value, index, self) => self.indexOf(value) === index;
+const distinct = (value: string, index: number, self: string[]) =>
+    self.indexOf(value) === index;
 
 export function generate (context: Context, options: GenerateOptions): File[] {
     return [

package/src/codegen/parser.ts

@@ -162,6 +162,18 @@ function inspectNode(node: ts.Node, context: Context, decoratorName: string) {
                     ? node.parent.parent as ts.CallExpression
                     : node.parent as ts.CallExpression;
 
+                /**
+                 * Skip if @codegen-ignore comment is found before the call expression
+                 * TODO: currently, if @codegen-ignore is on the file, it will skip all the setFields calls.
+                 */
+                const sourceFile = node.getSourceFile();
+                const fullText = sourceFile.getFullText();
+                const nodeStart = callExpression.getFullStart();
+                const textBeforeNode = fullText.substring(0, nodeStart);
+                if (textBeforeNode.includes('@codegen-ignore')) {
+                    break;
+                }
+
                 if (callExpression.kind !== ts.SyntaxKind.CallExpression) {
                     break;
                 }

package/src/codegen/types.ts

@@ -89,7 +89,7 @@ export interface IStructure {
     context: Context;
     name: string;
     properties: Property[];
-    addProperty(property: Property);
+    addProperty(property: Property): void;
 }
 
 export class Interface implements IStructure {
@@ -97,7 +97,7 @@ export class Interface implements IStructure {
     name: string;
     properties: Property[] = [];
 
-    addProperty(property: Property) {
+    addProperty(property: Property): void {
         if (property.type.indexOf("[]") >= 0) {
             // is array!
             property.childType = property.type.match(/([^\[]+)/i)[1];

package/src/decoder/DecodeOperation.ts

@@ -33,10 +33,10 @@ export type DecodeOperation<T extends Schema = any> = (
     allChanges: DataChange[],
 ) => number | void;
 
-export function decodeValue(
+export function decodeValue<T extends Ref>(
     decoder: Decoder,
     operation: OPERATION,
-    ref: Ref,
+    ref: T,
     index: number,
     type: any,
     bytes: Buffer,
@@ -44,7 +44,7 @@ export function decodeValue(
     allChanges: DataChange[],
 ) {
     const $root = decoder.root;
-    const previousValue = ref[$getByIndex](index);
+    const previousValue = (ref as any)[$getByIndex](index) as T;
 
     let value: any;
 
@@ -58,7 +58,7 @@ export function decodeValue(
         // Delete operations
         //
         if (operation !== OPERATION.DELETE_AND_ADD) {
-            ref[$deleteByIndex](index);
+            (ref as any)[$deleteByIndex](index);
         }
 
         value = undefined;
@@ -93,7 +93,7 @@ export function decodeValue(
         //
         // primitive value (number, string, boolean, etc)
         //
-        value = decode[type as string](bytes, it);
+        value = (decode as any)[type](bytes, it);
 
     } else {
         const typeDef = getType(Object.keys(type)[0]);
@@ -113,7 +113,7 @@ export function decodeValue(
                 //
                 // enqueue onRemove if structure has been replaced.
                 //
-                const entries: IterableIterator<[any, any]> = previousValue.entries();
+                const entries: IterableIterator<[any, any]> = (previousValue as any).entries();
                 let iter: IteratorResult<[any, any]>;
                 while ((iter = entries.next()) && !iter.done) {
                     const [key, value] = iter.value;
@@ -146,15 +146,15 @@ export function decodeValue(
     return { value, previousValue };
 }
 
-export const decodeSchemaOperation: DecodeOperation = function (
+export const decodeSchemaOperation: DecodeOperation = function <T extends Schema>(
     decoder: Decoder<any>,
     bytes: Buffer,
     it: Iterator,
-    ref: Ref,
+    ref: T,
     allChanges: DataChange[],
 ) {
     const first_byte = bytes[it.offset++];
-    const metadata: Metadata = ref.constructor[Symbol.metadata];
+    const metadata: Metadata = (ref.constructor as typeof Schema)[Symbol.metadata];
 
     // "compressed" index + operation
     const operation = (first_byte >> 6) << 6
@@ -179,7 +179,7 @@ export const decodeSchemaOperation: DecodeOperation = function (
     );
 
     if (value !== null && value !== undefined) {
-        ref[field.name] = value;
+        ref[field.name as keyof T] = value;
     }
 
     // add change
@@ -218,20 +218,20 @@ export const decodeKeyValueOperation: DecodeOperation = function (
     }
 
     const index = decode.number(bytes, it);
-    const type = ref[$childType];
+    const type = (ref as any)[$childType];
 
     let dynamicIndex: number | string;
 
     if ((operation & OPERATION.ADD) === OPERATION.ADD) { // ADD or DELETE_AND_ADD
-        if (typeof(ref['set']) === "function") {
+        if (typeof((ref as any)['set']) === "function") {
             dynamicIndex = decode.string(bytes, it); // MapSchema
-            ref['setIndex'](index, dynamicIndex);
+            (ref as any)['setIndex'](index, dynamicIndex);
         } else {
             dynamicIndex = index; // ArraySchema
         }
     } else {
         // get dynamic index from "ref"
-        dynamicIndex = ref['getIndex'](index);
+        dynamicIndex = (ref as any)['getIndex'](index);
     }
 
     const { value, previousValue } = decodeValue(
@@ -246,20 +246,20 @@ export const decodeKeyValueOperation: DecodeOperation = function (
     );
 
     if (value !== null && value !== undefined) {
-        if (typeof(ref['set']) === "function") {
+        if (typeof((ref as any)['set']) === "function") {
             // MapSchema
-            (ref as MapSchema)['$items'].set(dynamicIndex as string, value);
+            (ref as any)['$items'].set(dynamicIndex as string, value);
 
-        } else if (typeof(ref['$setAt']) === "function") {
+        } else if (typeof((ref as any)['$setAt']) === "function") {
             // ArraySchema
-            (ref as ArraySchema)['$setAt'](index, value, operation);
+            (ref as any)['$setAt'](index, value, operation);
 
-        } else if (typeof(ref['add']) === "function") {
+        } else if (typeof((ref as any)['add']) === "function") {
             // CollectionSchema && SetSchema
-            const index = (ref as CollectionSchema).add(value);
+            const index = (ref as any).add(value);
 
             if (typeof(index) === "number") {
-                ref['setIndex'](index, index);
+                (ref as any)['setIndex'](index, index);
             }
         }
     }

package/src/decoder/Decoder.ts

@@ -58,7 +58,7 @@ export class Decoder<T extends Schema = any> {
             if (bytes[it.offset] == SWITCH_TO_STRUCTURE) {
                 it.offset++;
 
-                ref[$onDecodeEnd]?.()
+                (ref as any)[$onDecodeEnd]?.()
 
                 const nextRefId = decode.number(bytes, it);
                 const nextRef = $root.refs.get(nextRefId);
@@ -91,7 +91,7 @@ export class Decoder<T extends Schema = any> {
         }
 
         // FIXME: DRY with SWITCH_TO_STRUCTURE block.
-        ref[$onDecodeEnd]?.()
+        (ref as any)[$onDecodeEnd]?.()
 
         // trigger changes
         this.triggerChanges?.(allChanges);
@@ -136,7 +136,7 @@ export class Decoder<T extends Schema = any> {
     }
 
     removeChildRefs(ref: Collection, allChanges: DataChange[]) {
-        const needRemoveRef = typeof (ref[$childType]) !== "string";
+        const needRemoveRef = typeof ((ref as any)[$childType]) !== "string";
         const refId = this.root.refIds.get(ref as Ref);
 
         ref.forEach((value: any, key: any) => {

package/src/decoder/ReferenceTracker.ts

@@ -2,9 +2,11 @@ import { Metadata } from "../Metadata";
 import { $childType } from "../types/symbols";
 import { Ref } from "../encoder/ChangeTree";
 import { spliceOne } from "../types/utils";
-import type { MapSchema } from "../types/custom/MapSchema";
 import { OPERATION } from "../encoding/spec";
 
+import type { MapSchema } from "../types/custom/MapSchema";
+import type { Schema } from "../Schema";
+
 class DecodingWarning extends Error {
     constructor(message: string) {
         super(message);
@@ -98,18 +100,18 @@ export class ReferenceTracker {
             //
             // Ensure child schema instances have their references removed as well.
             //
-            if (ref.constructor[Symbol.metadata] !== undefined) {
-                const metadata: Metadata = ref.constructor[Symbol.metadata];
+            if ((ref.constructor as typeof Schema)[Symbol.metadata] !== undefined) {
+                const metadata: Metadata = (ref.constructor as typeof Schema)[Symbol.metadata];
                 for (const index in metadata) {
                     const field = metadata[index as any as number].name;
-                    const childRefId = typeof(ref[field]) === "object" && this.refIds.get(ref[field]);
+                    const childRefId = typeof(ref[field as keyof Ref]) === "object" && this.refIds.get((ref as any)[field]);
                     if (childRefId && !this.deletedRefs.has(childRefId)) {
                         this.removeRef(childRefId);
                     }
                 }
 
             } else {
-                if (typeof (ref[$childType]) === "function") {
+                if (typeof ((ref as any)[$childType]) === "function") {
                     Array.from((ref as MapSchema).values())
                         .forEach((child) => {
                             const childRefId = this.refIds.get(child);

package/src/decoder/strategy/StateCallbacks.ts

@@ -19,7 +19,7 @@ import type { CollectionSchema } from "../../types/custom/CollectionSchema";
 
 /**
  * TODO: define a schema interface, which even having duplicate definitions, it could be used to get the callback proxy.
- * 
+ *
  * ```ts
  *     export type SchemaCallbackProxy<RoomState> = (<T extends Schema>(instance: T) => CallbackProxy<T>);
  * ```
@@ -228,7 +228,7 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
         let metadata: Metadata = context.instance?.constructor[Symbol.metadata] || metadataOrType;
         let isCollection = (
             (context.instance && typeof (context.instance['forEach']) === "function") ||
-            (metadataOrType && typeof (metadataOrType[Symbol.metadata]) === "undefined")
+            (metadataOrType && typeof ((metadataOrType as typeof Schema)[Symbol.metadata]) === "undefined")
         );
 
         if (metadata && !isCollection) {
@@ -327,7 +327,7 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
 
                     } else {
                         // accessing the function
-                        return target[prop];
+                        return target[prop as keyof typeof target];
                     }
                 },
                 has(target, prop: string) { return metadata[prop] !== undefined; },
@@ -346,7 +346,7 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
                     (ref as CollectionSchema).forEach((v, k) => callback(v, k));
                 }
 
-                return $root.addCallback($root.refIds.get(ref), OPERATION.ADD, (value, key) => {
+                return $root.addCallback($root.refIds.get(ref), OPERATION.ADD, (value: any, key: any) => {
                     onAddCalls.set(callback, true);
                     currentOnAddCallback = callback;
                     callback(value, key);
@@ -364,7 +364,7 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
             };
 
             return new Proxy({
-                onAdd: function(callback: (value, key) => void, immediate: boolean = true) {
+                onAdd: function(callback: (value: any, key: any) => void, immediate: boolean = true) {
                     //
                     // https://github.com/colyseus/schema/issues/147
                     // If parent instance has "onAdd" registered, avoid triggering immediate callback.
@@ -384,7 +384,7 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
                         return () => detachCallback();
                     }
                 },
-                onRemove: function(callback: (value, key) => void) {
+                onRemove: function(callback: (value: any, key: any) => void) {
                     if (context.instance) {
                         return onRemove(context.instance, callback);
 
@@ -399,7 +399,7 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
                         return () => detachCallback();
                     }
                 },
-                onChange: function(callback: (value, key) => void) {
+                onChange: function(callback: (value: any, key: any) => void) {
                     if (context.instance) {
                         return onChange(context.instance, callback);
 
@@ -416,12 +416,12 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
                 },
             }, {
                 get(target, prop: string) {
-                    if (!target[prop]) {
+                    if (!target[prop as keyof typeof target]) {
                         throw new Error(`Can't access '${prop}' through callback proxy. access the instance directly.`);
                     }
-                    return target[prop];
+                    return target[prop as keyof typeof target];
                 },
-                has(target, prop) { return target[prop] !== undefined; },
+                has(target, prop) { return target[prop as keyof typeof target] !== undefined; },
                 set(_, _1, _2) { throw new Error("not allowed"); },
                 deleteProperty(_, _1) { throw new Error("not allowed"); },
             });

package/src/encoder/ChangeTree.ts

@@ -1,6 +1,6 @@
 import { OPERATION } from "../encoding/spec";
 import { Schema } from "../Schema";
-import { $changes, $childType, $decoder, $onEncodeEnd, $encoder, $getByIndex, $refTypeFieldIndexes, $viewFieldIndexes } from "../types/symbols";
+import { $changes, $childType, $decoder, $onEncodeEnd, $encoder, $getByIndex, $refTypeFieldIndexes, $viewFieldIndexes, type $deleteByIndex } from "../types/symbols";
 
 import type { MapSchema } from "../types/custom/MapSchema";
 import type { ArraySchema } from "../types/custom/ArraySchema";
@@ -21,6 +21,12 @@ declare global {
     }
 }
 
+export interface IRef {
+    [$changes]?: ChangeTree;
+    [$getByIndex]?: (index: number, isEncodeAll?: boolean) => any;
+    [$deleteByIndex]?: (index: number) => void;
+}
+
 export type Ref = Schema
     | ArraySchema
     | MapSchema
@@ -76,7 +82,7 @@ export function setOperationAtIndex(changeSet: ChangeSet, index: number) {
 }
 
 export function deleteOperationAtIndex(changeSet: ChangeSet, index: number | string) {
-    let operationsIndex = changeSet.indexes[index];
+    let operationsIndex = changeSet.indexes[index as any as number];
     if (operationsIndex === undefined) {
         //
         // if index is not found, we need to find the last operation
@@ -88,7 +94,7 @@ export function deleteOperationAtIndex(changeSet: ChangeSet, index: number | str
         index = Object.entries(changeSet.indexes).find(([_, value]) => value === operationsIndex)?.[0];
     }
     changeSet.operations[operationsIndex] = undefined;
-    delete changeSet.indexes[index];
+    delete changeSet.indexes[index as any as number];
 }
 
 export function debugChangeSet(label: string, changeSet: ChangeSet) {
@@ -155,7 +161,7 @@ export class ChangeTree<T extends Ref = any> {
 
     constructor(ref: T) {
         this.ref = ref;
-        this.metadata = ref.constructor[Symbol.metadata];
+        this.metadata = (ref.constructor as typeof Schema)[Symbol.metadata];
 
         //
         // Does this structure have "filters" declared?
@@ -227,8 +233,8 @@ export class ChangeTree<T extends Ref = any> {
         //
         // assign same parent on child structures
         //
-        if (this.ref[$childType]) {
-            if (typeof (this.ref[$childType]) !== "string") {
+        if ((this.ref as any)[$childType]) {
+            if (typeof ((this.ref as any)[$childType]) !== "string") {
                 // MapSchema / ArraySchema, etc.
                 for (const [key, value] of (this.ref as MapSchema).entries()) {
                     callback(value[$changes], this.indexes?.[key] ?? key);
@@ -238,7 +244,7 @@ export class ChangeTree<T extends Ref = any> {
         } else {
             for (const index of this.metadata?.[$refTypeFieldIndexes] ?? []) {
                 const field = this.metadata[index as any as number];
-                const value = this.ref[field.name];
+                const value = this.ref[field.name as keyof Ref];
                 if (!value) { continue; }
                 callback(value[$changes], index);
             }
@@ -303,8 +309,8 @@ export class ChangeTree<T extends Ref = any> {
             ? this.filteredChanges
             : this.changes;
 
-        const newIndexedOperations = {};
-        const newIndexes = {};
+        const newIndexedOperations: any = {};
+        const newIndexes: { [index: number]: number } = {};
         for (const index in this.indexedOperations) {
             newIndexedOperations[Number(index) + shiftIndex] = this.indexedOperations[index];
             newIndexes[Number(index) + shiftIndex] = changeSet.indexes[index];
@@ -331,7 +337,7 @@ export class ChangeTree<T extends Ref = any> {
     }
 
     private _shiftAllChangeIndexes(shiftIndex: number, startIndex: number = 0, changeSet: ChangeSet) {
-        const newIndexes = {};
+        const newIndexes: { [index: number]: number } = {};
         let newKey = 0;
         for (const key in changeSet.indexes) {
             newIndexes[newKey++] = changeSet.indexes[key];
@@ -369,7 +375,7 @@ export class ChangeTree<T extends Ref = any> {
             // - { map: "string" } => "string"
             // - { set: "string" } => "string"
             //
-            this.ref[$childType] || // ArraySchema | MapSchema | SetSchema | CollectionSchema
+            (this.ref as any)[$childType] || // ArraySchema | MapSchema | SetSchema | CollectionSchema
             this.metadata[index].type // Schema
         );
     }
@@ -385,7 +391,7 @@ export class ChangeTree<T extends Ref = any> {
         //
         // `isEncodeAll` param is only used by ArraySchema
         //
-        return this.ref[$getByIndex](index, isEncodeAll);
+        return (this.ref as any)[$getByIndex](index, isEncodeAll);
     }
 
     delete(index: number, operation?: OPERATION, allChangesIndex = index) {
@@ -444,7 +450,7 @@ export class ChangeTree<T extends Ref = any> {
         this[changeSetName] = createChangeSet();
 
         // ArraySchema and MapSchema have a custom "encode end" method
-        this.ref[$onEncodeEnd]?.();
+        (this.ref as any)[$onEncodeEnd]?.();
 
         // Not a new instance anymore
         this.isNew = false;
@@ -456,7 +462,7 @@ export class ChangeTree<T extends Ref = any> {
         //      Remove cached key to ensure ADD operations is unsed instead of
         //      REPLACE in case same key is used on next patches.
         //
-        this.ref[$onEncodeEnd]?.();
+        (this.ref as any)[$onEncodeEnd]?.();
 
         this.indexedOperations = {};
         this.changes = createChangeSet(this.changes.queueRootNode);
@@ -534,7 +540,7 @@ export class ChangeTree<T extends Ref = any> {
         //
         const refType = Metadata.isValidInstance(this.ref)
             ? this.ref.constructor
-            : this.ref[$childType];
+            : (this.ref as any)[$childType];
 
         let parentChangeTree: ChangeTree;
 

package/src/encoder/EncodeOperation.ts

@@ -32,7 +32,7 @@ export function encodeValue(
     it: Iterator,
 ) {
     if (typeof (type) === "string") {
-        encode[type]?.(bytes, value, it);
+        (encode as any)[type]?.(bytes, value, it);
 
     } else if (type[Symbol.metadata] !== undefined) {
         //
@@ -59,10 +59,10 @@ export function encodeValue(
  * Used for Schema instances.
  * @private
  */
-export const encodeSchemaOperation: EncodeOperation = function (
+export const encodeSchemaOperation: EncodeOperation = function <T extends Schema> (
     encoder: Encoder,
     bytes: Buffer,
-    changeTree: ChangeTree<Schema>,
+    changeTree: ChangeTree<T>,
     index: number,
     operation: OPERATION,
     it: Iterator,
@@ -86,7 +86,7 @@ export const encodeSchemaOperation: EncodeOperation = function (
         encoder,
         bytes,
         metadata[index].type,
-        ref[field.name],
+        ref[field.name as keyof T],
         operation,
         it
     );

package/src/encoder/Encoder.ts

@@ -167,30 +167,6 @@ export class Encoder<T extends Schema = any> {
         ]);
     }
 
-    debugChanges(field: "changes" | "allFilteredChanges" | "allChanges" | "filteredChanges") {
-        const rootChangeSet = (typeof (field) === "string")
-            ? this.root[field]
-            : field;
-
-        let current = rootChangeSet.next;
-        while (current) {
-            const changeTree = current.changeTree;
-            const changeSet = changeTree[field];
-
-            const metadata: Metadata = changeTree.ref.constructor[Symbol.metadata];
-            console.log("->", { ref: changeTree.ref.constructor.name, refId: changeTree.refId, changes: Object.keys(changeSet).length });
-            for (const index in changeSet) {
-                const op = changeSet[index];
-                console.log("  ->", {
-                    index,
-                    field: metadata?.[index],
-                    op: OPERATION[op],
-                });
-            }
-            current = current.next;
-        }
-    }
-
     encodeView(view: StateView, sharedOffset: number, it: Iterator, bytes = this.sharedBuffer) {
         const viewOffset = it.offset;