@colyseus/schema 5.0.23 → 5.0.25

package/build/types/HelperTypes.d.ts

@@ -89,16 +89,10 @@ export type CodecFor<T> = {
     [K in RawPrimitiveType]: [T] extends [InferValueType<K>] ? K : never;
 }[RawPrimitiveType];
 type IsOptionalBuilderKey<T, K extends keyof T> = T[K] extends FieldBuilder<unknown, boolean, infer O extends boolean> ? O : false;
-type OptionalBuilderKeys<T> = {
-    [K in keyof T]-?: IsOptionalBuilderKey<T, K> extends true ? K : never;
-}[keyof T];
-type RequiredBuilderKeys<T> = {
-    [K in keyof T]-?: IsOptionalBuilderKey<T, K> extends true ? never : K;
-}[keyof T];
 export type InferSchemaInstanceType<T> = {
-    [K in RequiredBuilderKeys<T>]: T[K] extends FieldBuilder<any> ? InferValueType<T[K]> : T[K] extends (...args: any[]) => any ? (T[K] extends new (...args: any[]) => any ? InferValueType<T[K]> : T[K]) : InferValueType<T[K]>;
+    -readonly [K in keyof T as IsOptionalBuilderKey<T, K> extends true ? never : K]-?: T[K] extends FieldBuilder<any> ? InferValueType<T[K]> : T[K] extends (...args: any[]) => any ? (T[K] extends new (...args: any[]) => any ? InferValueType<T[K]> : T[K]) : InferValueType<T[K]>;
 } & {
-    [K in OptionalBuilderKeys<T>]?: T[K] extends FieldBuilder<infer V> ? V : never;
+    -readonly [K in keyof T as IsOptionalBuilderKey<T, K> extends true ? K : never]?: T[K] extends FieldBuilder<infer V> ? V : never;
 } & Schema;
 type DataKey<T, K extends keyof T> = K extends keyof Schema ? never : T[K] extends Function ? never : K;
 export type NonFunctionPropNames<T> = {
@@ -110,16 +104,10 @@ export type NonFunctionNonPrimitivePropNames<T> = {
 type ToJSONValue<U> = U extends Schema ? ToJSON<U> : PrimitiveStringToType<U>;
 type ToJSONField<X> = X extends MapSchema<infer U> ? Record<string, ToJSONValue<U>> : X extends Map<string, infer U> ? Record<string, ToJSONValue<U>> : X extends ArraySchema<infer U> ? ToJSONValue<U>[] : X extends SetSchema<infer U> ? ToJSONValue<U>[] : X extends CollectionSchema<infer U> ? ToJSONValue<U>[] : X extends Schema ? ToJSON<X> : X;
 type IsOptionalKey<T, K extends keyof T> = undefined extends {} ? ({} extends Pick<T, K> ? true : false) : (undefined extends T[K] ? true : false);
-type ToJSONRequiredKeys<T> = {
-    [K in keyof T]-?: [DataKey<T, K>] extends [never] ? never : IsOptionalKey<T, K> extends true ? never : K;
-}[keyof T];
-type ToJSONOptionalKeys<T> = {
-    [K in keyof T]-?: [DataKey<T, K>] extends [never] ? never : IsOptionalKey<T, K> extends true ? K : never;
-}[keyof T];
 export type ToJSON<T> = {
-    [K in ToJSONRequiredKeys<T>]: ToJSONField<T[K]>;
+    -readonly [K in keyof T as IsOptionalKey<T, K> extends true ? never : DataKey<T, K>]-?: ToJSONField<T[K]>;
 } & {
-    [K in ToJSONOptionalKeys<T>]?: ToJSONField<Exclude<T[K], undefined>>;
+    -readonly [K in keyof T as IsOptionalKey<T, K> extends true ? DataKey<T, K> : never]?: ToJSONField<Exclude<T[K], undefined>>;
 };
 /**
  * The plain DATA shape of a Schema instance type `T`: its synchronized fields
@@ -148,9 +136,11 @@ export type IsNever<T> = [T] extends [never] ? true : false;
  * - Primitives can be assigned directly
  * - Schema instances can be assigned from plain objects or Schema instances
  * - Collections can be assigned from their JSON representations
+ *
+ * Keys filter through `DataKey` in the `as` clause — see THE RULE above.
  */
 export type AssignableProps<T> = {
-    [K in NonFunctionPropNames<T>]?: AssignableValue<T[K]>;
+    -readonly [K in keyof T as DataKey<T, K>]?: AssignableValue<T[K]>;
 };
 /**
  * Value-level assignment shape shared by `AssignableProps` and
@@ -165,20 +155,18 @@ export type RefHasDefault<C> = C extends {
 } ? (P extends readonly [] ? true : false) : true;
 type FieldValue<F> = F extends FieldBuilder<infer V, boolean, boolean> ? V : F extends new (...args: any[]) => infer I ? (I extends Schema ? I : never) : never;
 type KeyClass<T, K extends keyof T> = T[K] extends FieldBuilder<unknown, infer D extends boolean, infer O extends boolean> ? (D extends true ? "optional" : O extends true ? "optional" : "required") : T[K] extends new (...args: any[]) => Schema ? (RefHasDefault<T[K]> extends true ? "optional" : "required") : "none";
-export type BuilderRequiredKeys<T> = {
-    [K in keyof T]-?: KeyClass<T, K> extends "required" ? K : never;
-}[keyof T];
-export type BuilderOptionalKeys<T> = {
-    [K in keyof T]-?: KeyClass<T, K> extends "optional" ? K : never;
-}[keyof T];
 /**
  * Constructor/init-props type for a schema() fields map. Required fields
  * (primitives without `.default()` or `.optional()`, and Schema refs with
  * non-zero-arg `initialize()`) are `:`; everything else is `?:`.
+ *
+ * Split by `KeyClass` in the `as` clause — see THE RULE above. `-?` matters
+ * under `strictNullChecks: false`: an optional key in the fields map still
+ * classifies as "required" there, and would otherwise inherit the `?`.
  */
 export type BuilderInitProps<T> = {
-    [K in BuilderRequiredKeys<T>]: AssignableValue<FieldValue<T[K]>>;
+    -readonly [K in keyof T as KeyClass<T, K> extends "required" ? K : never]-?: AssignableValue<FieldValue<T[K]>>;
 } & {
-    [K in BuilderOptionalKeys<T>]?: AssignableValue<Exclude<FieldValue<T[K]>, undefined>>;
+    -readonly [K in keyof T as KeyClass<T, K> extends "optional" ? K : never]?: AssignableValue<Exclude<FieldValue<T[K]>, undefined>>;
 };
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colyseus/schema",
-  "version": "5.0.23",
+  "version": "5.0.25",
   "description": "Automatic state replication for multiplayer games. Mutate plain objects, and every client gets a live, typed mirror through delta encoding.",
   "type": "module",
   "bin": {

package/src/encoder/StateView.ts

@@ -619,7 +619,18 @@ export class StateView {
                 this.changes.set(changeTree.ref[$refId], changes);
             }
 
-            this.addTag(changeTree, tag);
+            // Grant the tag on the parent only when the field pointing at
+            // the child carries an overlapping tag — that field is the sole
+            // reason the parent needs it. Granting unconditionally handed
+            // the view every OTHER same-tag field on the parent, which then
+            // rode out on its next mutation (never at add() time, so it read
+            // as "the field only shows up after it changes").
+            const parentFieldTag = changeTree.encDescriptor.tags[parentIndex];
+            if (parentFieldTag !== undefined &&
+                parentFieldTag !== DEFAULT_VIEW_TAG &&
+                (parentFieldTag & tag) !== 0) {
+                this.addTag(changeTree, tag);
+            }
 
             // ArraySchema parents: key by the child's identity, not the wire
             // slot it holds right now — a same-tick unshift()/reverse()/move()

package/src/types/HelperTypes.ts

@@ -117,19 +117,20 @@ export type CodecFor<T> = {
 type IsOptionalBuilderKey<T, K extends keyof T> =
     T[K] extends FieldBuilder<unknown, boolean, infer O extends boolean> ? O : false;
 
-// Per key, like `DataKey` below — an `Exclude<keyof T, …>` split defers every
-// key once one field is typed by a bare type parameter.
-type OptionalBuilderKeys<T> = { [K in keyof T]-?: IsOptionalBuilderKey<T, K> extends true ? K : never }[keyof T];
-type RequiredBuilderKeys<T> = { [K in keyof T]-?: IsOptionalBuilderKey<T, K> extends true ? never : K }[keyof T];
-
+// THE RULE for every mapped type below that projects a user's declared fields:
+// split in the `as` clause, never over a precomputed key union. Only a
+// homomorphic mapping carries each key back to its declaration, and that link
+// is what go-to-definition and rename resolve through — losing it leaves rename
+// silently touching just the cursor (colyseus/colyseus#958). The `-readonly`
+// and `-?` that follow drop the modifiers such a mapping inherits from `T`.
 export type InferSchemaInstanceType<T> = {
-    [K in RequiredBuilderKeys<T>]: T[K] extends FieldBuilder<any>
+    -readonly [K in keyof T as IsOptionalBuilderKey<T, K> extends true ? never : K]-?: T[K] extends FieldBuilder<any>
         ? InferValueType<T[K]>
         : T[K] extends (...args: any[]) => any
             ? (T[K] extends new (...args: any[]) => any ? InferValueType<T[K]> : T[K])
             : InferValueType<T[K]>
 } & {
-    [K in OptionalBuilderKeys<T>]?: T[K] extends FieldBuilder<infer V>
+    -readonly [K in keyof T as IsOptionalBuilderKey<T, K> extends true ? K : never]?: T[K] extends FieldBuilder<infer V>
         ? V
         : never
 } & Schema;
@@ -170,15 +171,14 @@ type IsOptionalKey<T, K extends keyof T> = undefined extends {}
     ? ({} extends Pick<T, K> ? true : false)
     : (undefined extends T[K] ? true : false);
 
-// `DataKey` first: machinery and method keys drop before the optionality probe.
-type ToJSONRequiredKeys<T> = { [K in keyof T]-?: [DataKey<T, K>] extends [never] ? never : IsOptionalKey<T, K> extends true ? never : K }[keyof T];
-type ToJSONOptionalKeys<T> = { [K in keyof T]-?: [DataKey<T, K>] extends [never] ? never : IsOptionalKey<T, K> extends true ? K : never }[keyof T];
-
-// Keys are filtered before mapping: `ToJSONField` over the `this`-typed methods
-// exceeds TypeScript 7's instantiation depth.
+// Beyond THE RULE, the `as` clause is load-bearing here for a second reason: it
+// runs before the value type, so `ToJSONField` never reaches the machinery,
+// where it would recurse through `restore(json: ToJSON<this>)` past TypeScript
+// 7's instantiation limit. Probing `IsOptionalKey` first is deliberate too —
+// `DataKey` then runs in the taken branch only, once per key not once per half.
 export type ToJSON<T> =
-    & { [K in ToJSONRequiredKeys<T>]: ToJSONField<T[K]> }
-    & { [K in ToJSONOptionalKeys<T>]?: ToJSONField<Exclude<T[K], undefined>> };
+    & { -readonly [K in keyof T as IsOptionalKey<T, K> extends true ? never : DataKey<T, K>]-?: ToJSONField<T[K]> }
+    & { -readonly [K in keyof T as IsOptionalKey<T, K> extends true ? DataKey<T, K> : never]?: ToJSONField<Exclude<T[K], undefined>> };
 
 /**
  * The plain DATA shape of a Schema instance type `T`: its synchronized fields
@@ -210,9 +210,11 @@ export type IsNever<T> = [T] extends [never] ? true : false;
  * - Primitives can be assigned directly
  * - Schema instances can be assigned from plain objects or Schema instances
  * - Collections can be assigned from their JSON representations
+ *
+ * Keys filter through `DataKey` in the `as` clause — see THE RULE above.
  */
 export type AssignableProps<T> = {
-    [K in NonFunctionPropNames<T>]?: AssignableValue<T[K]>
+    -readonly [K in keyof T as DataKey<T, K>]?: AssignableValue<T[K]>
 };
 
 /**
@@ -267,19 +269,15 @@ type KeyClass<T, K extends keyof T> =
             ? (RefHasDefault<T[K]> extends true ? "optional" : "required")
             : "none";
 
-export type BuilderRequiredKeys<T> = {
-    [K in keyof T]-?: KeyClass<T, K> extends "required" ? K : never
-}[keyof T];
-
-export type BuilderOptionalKeys<T> = {
-    [K in keyof T]-?: KeyClass<T, K> extends "optional" ? K : never
-}[keyof T];
-
 /**
  * Constructor/init-props type for a schema() fields map. Required fields
  * (primitives without `.default()` or `.optional()`, and Schema refs with
  * non-zero-arg `initialize()`) are `:`; everything else is `?:`.
+ *
+ * Split by `KeyClass` in the `as` clause — see THE RULE above. `-?` matters
+ * under `strictNullChecks: false`: an optional key in the fields map still
+ * classifies as "required" there, and would otherwise inherit the `?`.
  */
 export type BuilderInitProps<T> =
-    & { [K in BuilderRequiredKeys<T>]: AssignableValue<FieldValue<T[K]>> }
-    & { [K in BuilderOptionalKeys<T>]?: AssignableValue<Exclude<FieldValue<T[K]>, undefined>> };
+    & { -readonly [K in keyof T as KeyClass<T, K> extends "required" ? K : never]-?: AssignableValue<FieldValue<T[K]>> }
+    & { -readonly [K in keyof T as KeyClass<T, K> extends "optional" ? K : never]?: AssignableValue<Exclude<FieldValue<T[K]>, undefined>> };