@colyseus/schema 5.0.24 → 5.0.25

package/build/types/HelperTypes.d.ts

@@ -136,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
@@ -153,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.24",
+  "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,11 +117,12 @@ export type CodecFor<T> = {
 type IsOptionalBuilderKey<T, K extends keyof T> =
     T[K] extends FieldBuilder<unknown, boolean, infer O extends boolean> ? O : false;
 
-// Split in the `as` clause, never over a precomputed key union: only a
-// homomorphic mapping carries each key back to its declaration in the
-// `schema({ … })` literal, which is what go-to-definition and rename resolve
-// through. `-readonly`, and `-?` on the required half, drop the modifiers a
-// homomorphic mapping inherits from the fields map.
+// 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> = {
     -readonly [K in keyof T as IsOptionalBuilderKey<T, K> extends true ? never : K]-?: T[K] extends FieldBuilder<any>
         ? InferValueType<T[K]>
@@ -170,12 +171,11 @@ type IsOptionalKey<T, K extends keyof T> = undefined extends {}
     ? ({} extends Pick<T, K> ? true : false)
     : (undefined extends T[K] ? true : false);
 
-// Both filters live in the `as` clause, for two independent reasons:
-// navigation, as above — and depth, because the clause 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: `DataKey` then runs in the taken
-// branch only, once per key rather than once per half.
+// 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> =
     & { -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>> };
@@ -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>> };