@colyseus/schema 5.0.13 → 5.0.14

package/build/types/HelperTypes.d.ts

@@ -70,7 +70,7 @@ export type InferValueType<T> = T extends FieldBuilder<infer V> ? V : T extends
     stream: infer ChildType;
 } ? StreamSchema<ChildType> : T extends Constructor ? InstanceType<T> : T extends Record<string | number, string | number> ? T[keyof T] : T extends PrimitiveType ? T : never;
 type OptionalBuilderKeys<T> = {
-    [K in keyof T]: T[K] extends FieldBuilder<infer V> ? (undefined extends V ? K : never) : never;
+    [K in keyof T]: T[K] extends FieldBuilder<unknown, boolean, infer O extends boolean> ? (O extends true ? K : never) : never;
 }[keyof T];
 type RequiredBuilderKeys<T> = Exclude<keyof T, OptionalBuilderKeys<T>>;
 export type InferSchemaInstanceType<T> = {
@@ -89,12 +89,10 @@ export type NonFunctionNonPrimitivePropNames<T> = {
 }[keyof 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 ToJSONRequiredKeys<T> = {
-    [K in keyof T]-?: undefined extends T[K] ? never : K;
-}[keyof T];
 type ToJSONOptionalKeys<T> = {
-    [K in keyof T]-?: undefined extends T[K] ? K : never;
+    [K in keyof T]-?: undefined extends {} ? ({} extends Pick<T, K> ? K : never) : (undefined extends T[K] ? K : never);
 }[keyof T];
+type ToJSONRequiredKeys<T> = Exclude<keyof T, ToJSONOptionalKeys<T>>;
 export type ToJSON<T> = NonFunctionProps<{
     [K in ToJSONRequiredKeys<T>]: ToJSONField<T[K]>;
 } & {

package/build/types/builder.d.ts

@@ -45,10 +45,11 @@ export type BuilderOf<T> = FieldBuilder<T>;
  *    Schema ref whose `initialize` takes zero args.
  *  - `IsOptional` is a compile-time brand for `.optional()`. Both
  *    `HasDefault` and `IsOptional` make the field omittable in
- *    `BuilderInitProps<T>`. A separate brand (rather than reading
- *    `undefined extends V`) sidesteps a TypeScript quirk where
- *    class-generic-inferred `V` resolves `undefined extends V` as `true`
- *    even for non-undefined types.
+ *    `BuilderInitProps<T>`; `IsOptional` alone marks the instance property
+ *    `?:`. A separate brand (rather than reading `undefined extends V`)
+ *    keeps both correct for consumers compiling with
+ *    `strictNullChecks: false`, where `undefined extends V` is true for
+ *    every V.
  *
  * schema() reads the internal configuration via `toDefinition()` and wires
  * up metadata through the existing pipeline.
@@ -199,8 +200,8 @@ export declare function isBuilder(value: any): value is FieldBuilder<any>;
  * Two call signatures, NOT a defaulted generic `<T extends TBase = TBase>`: the
  * bare form must return a CONCRETE `FieldBuilder<TBase>` so `schema({ x:
  * t.number() })` still infers `x: number`. A defaulted free type parameter gets
- * captured as `any` during `schema()`'s self-referential field inference (and
- * `undefined extends any` then flips every field optional).
+ * captured as `any` during `schema()`'s self-referential field inference,
+ * degrading every field's value type to `any`.
  *
  * NOTE: the refinement is a TYPE-LEVEL assertion, not a runtime guarantee — the
  * wire still carries the codec's full range and the DECODER writes whatever

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colyseus/schema",
-  "version": "5.0.13",
+  "version": "5.0.14",
   "description": "Binary state serializer with delta encoding for games",
   "type": "module",
   "bin": {
@@ -18,7 +18,7 @@
     "watch": "tsc -p tsconfig.build.json -w",
     "typecheck:build": "tsc -p tsconfig.build.json --noEmit",
     "test": "npm run test:types && tsx --tsconfig tsconfig.test.json ./node_modules/mocha/bin/mocha.js \"test/*.test.ts\" \"test/**/*.test.ts\"",
-    "test:types": "tsc -p tsconfig.build.json && tsc -p tsconfig.types.json",
+    "test:types": "tsc -p tsconfig.build.json && tsc -p tsconfig.types.json && tsc -p tsconfig.types-nostrict.json",
     "test:exports": "node test/verify-exports.mjs",
     "typecheck": "tsc -p tsconfig.test.json",
     "coverage": "c8 npm run test",

package/src/types/HelperTypes.ts

@@ -87,10 +87,12 @@ export type InferValueType<T> =
 
     : never;
 
-// Keys whose FieldBuilder generic admits `undefined` (i.e. `.optional()` was chained).
+// Keys whose builder carries the `.optional()` brand. Reads the brand rather
+// than `undefined extends V`: the latter is true for EVERY V when the consumer
+// compiles with `strictNullChecks: false`, flipping all fields optional.
 type OptionalBuilderKeys<T> = {
-    [K in keyof T]: T[K] extends FieldBuilder<infer V>
-        ? (undefined extends V ? K : never)
+    [K in keyof T]: T[K] extends FieldBuilder<unknown, boolean, infer O extends boolean>
+        ? (O extends true ? K : never)
         : never
 }[keyof T];
 
@@ -136,14 +138,16 @@ type ToJSONField<X> =
     : X extends Schema ? ToJSON<X>
     : X;
 
-// Keys whose value type admits `undefined` — runtime `toJSON()` omits those,
-// so they surface as `?:` on the JSON shape.
-type ToJSONRequiredKeys<T> = {
-    [K in keyof T]-?: undefined extends T[K] ? never : K
-}[keyof T];
+// Keys whose value admits `undefined` — runtime `toJSON()` omits those, so
+// they surface as `?:` on the JSON shape. Under `strictNullChecks: false`
+// (`undefined extends {}` detects it) `undefined extends T[K]` is true for
+// every key, so only the `?` modifier can signal optionality there.
 type ToJSONOptionalKeys<T> = {
-    [K in keyof T]-?: undefined extends T[K] ? K : never
+    [K in keyof T]-?: undefined extends {}
+        ? ({} extends Pick<T, K> ? K : never)
+        : (undefined extends T[K] ? K : never)
 }[keyof T];
+type ToJSONRequiredKeys<T> = Exclude<keyof T, ToJSONOptionalKeys<T>>;
 
 export type ToJSON<T> = NonFunctionProps<
     & { [K in ToJSONRequiredKeys<T>]: ToJSONField<T[K]> }
@@ -226,10 +230,9 @@ type FieldValue<F> =
 
 // Classify each key of a fields map as "required" / "optional" / "none"
 // (methods). Both `HasDefault = true` and the explicit `.optional()` brand
-// `IsOptional = true` mark the field omittable at construction. The brand
-// sidesteps a TypeScript quirk where `undefined extends V` returned `true`
-// for non-undefined V when V was inferred from a class with T in
-// contravariant + covariant positions.
+// `IsOptional = true` mark the field omittable at construction. Reading the
+// brands (never `undefined extends V`) keeps this correct for consumers on
+// `strictNullChecks: false`, where `undefined extends V` is true for every V.
 type KeyClass<T, K extends keyof T> =
     T[K] extends FieldBuilder<unknown, infer D extends boolean, infer O extends boolean>
         ? (D extends true

package/src/types/builder.ts

@@ -51,10 +51,11 @@ export type BuilderOf<T> = FieldBuilder<T>;
  *    Schema ref whose `initialize` takes zero args.
  *  - `IsOptional` is a compile-time brand for `.optional()`. Both
  *    `HasDefault` and `IsOptional` make the field omittable in
- *    `BuilderInitProps<T>`. A separate brand (rather than reading
- *    `undefined extends V`) sidesteps a TypeScript quirk where
- *    class-generic-inferred `V` resolves `undefined extends V` as `true`
- *    even for non-undefined types.
+ *    `BuilderInitProps<T>`; `IsOptional` alone marks the instance property
+ *    `?:`. A separate brand (rather than reading `undefined extends V`)
+ *    keeps both correct for consumers compiling with
+ *    `strictNullChecks: false`, where `undefined extends V` is true for
+ *    every V.
  *
  * schema() reads the internal configuration via `toDefinition()` and wires
  * up metadata through the existing pipeline.
@@ -289,8 +290,8 @@ export function isBuilder(value: any): value is FieldBuilder<any> {
  * Two call signatures, NOT a defaulted generic `<T extends TBase = TBase>`: the
  * bare form must return a CONCRETE `FieldBuilder<TBase>` so `schema({ x:
  * t.number() })` still infers `x: number`. A defaulted free type parameter gets
- * captured as `any` during `schema()`'s self-referential field inference (and
- * `undefined extends any` then flips every field optional).
+ * captured as `any` during `schema()`'s self-referential field inference,
+ * degrading every field's value type to `any`.
  *
  * NOTE: the refinement is a TYPE-LEVEL assertion, not a runtime guarantee — the
  * wire still carries the codec's full range and the DECODER writes whatever