@colyseus/schema 5.0.19 → 5.0.20

package/README.md

@@ -2,17 +2,18 @@
   <img src="logo.png?raw=true" width="50%" />
   <br>
   <p>
-    An incremental binary state serializer with delta encoding for games.<br>
+    <b>Automatic state replication for multiplayer games.</b><br>
     Made for <a href="https://github.com/colyseus/colyseus">Colyseus</a>, yet can be used standalone.
   </p>
 </div>
 
 # Features
 
-- **Incremental State Synchronization**: Send only the properties that have changed.
+- **Plain Objects, Synced**: Assign a property, `push` to an array, or `set` on a map. Change tracking, encoding and decoding happen for you.
+- **Delta Encoding**: Only the properties that changed are sent, in a compact binary format.
 - **Trigger Callbacks at Decoding**: [Bring your own](https://docs.colyseus.io/state/callbacks/custom) callback system at decoding, or use the built-in one.
 - **Instance Reference Tracking**: Share references of the same instance across the state.
-- **State Views**: Filter properties that should be sent only to specific clients.
+- **State Views**: Per-client visibility. Decide which properties and instances each client receives.
 - **Reflection**: Encode/Decode schema definitions.
 - **Schema Generation**: Generate client-side schema files for strictly typed languages.
 - **Type Safety**: Strictly typed schema definitions.

package/build/annotations.d.ts

@@ -139,8 +139,9 @@ type HasExplicitInit<T> = T extends {
  * (shorthand for `t.ref(Class)`), or a method (attached to the prototype).
  */
 export type FieldsAndMethods = Record<string, FieldBuilder<any, boolean, boolean> | (new (...args: any[]) => Schema) | Function>;
+type SchemaInstance<T, P extends typeof Schema> = InferSchemaInstanceType<T> & InstanceType<P>;
 export interface SchemaWithExtends<T, P extends typeof Schema> {
-    extend: <T2 extends FieldsAndMethods = FieldsAndMethods>(fields: T2 & ThisType<InferSchemaInstanceType<T & T2>>, name?: string) => SchemaWithExtendsConstructor<T & T2, ExtractInitProps<T & T2>, P>;
+    extend: <T2 extends FieldsAndMethods = FieldsAndMethods>(fields: T2 & ThisType<SchemaInstance<T & T2, P>>, name?: string) => SchemaWithExtendsConstructor<T & T2, ExtractInitProps<T & T2>, P>;
 }
 /**
  * Get the type of the schema defined via `schema('Name', {...})` method.
@@ -156,11 +157,11 @@ export type SchemaType<T extends {
     '~type': any;
 }> = T['~type'];
 export interface SchemaWithExtendsConstructor<T, InitProps, P extends typeof Schema> extends SchemaWithExtends<T, P> {
-    '~type': InferSchemaInstanceType<T>;
+    '~type': SchemaInstance<T, P>;
     new (...args: [
         InitProps
-    ] extends [never] ? [] : InitProps extends readonly any[] ? InitProps : HasExplicitInit<T> extends true ? [InitProps] : IsInitPropsRequired<T> extends true ? ([] | [InitProps]) : [InitProps?]): InferSchemaInstanceType<T> & InstanceType<P>;
-    prototype: InferSchemaInstanceType<T> & InstanceType<P> & {
+    ] extends [never] ? [] : InitProps extends readonly any[] ? InitProps : HasExplicitInit<T> extends true ? [InitProps] : IsInitPropsRequired<T> extends true ? ([] | [InitProps]) : [InitProps?]): SchemaInstance<T, P>;
+    prototype: SchemaInstance<T, P> & {
         initialize(...args: [InitProps] extends [never] ? [] : InitProps extends readonly any[] ? InitProps : [InitProps]): void;
     };
 }
@@ -180,5 +181,5 @@ export interface SchemaWithExtendsConstructor<T, InitProps, P extends typeof Sch
  *   weapon: t.string(),
  * }, 'Warrior');
  */
-export declare function schema<T extends FieldsAndMethods, P extends typeof Schema = typeof Schema>(fieldsAndMethods: T & ThisType<InferSchemaInstanceType<T>>, name?: string, inherits?: P): SchemaWithExtendsConstructor<T, ExtractInitProps<T>, P>;
+export declare function schema<T extends FieldsAndMethods, P extends typeof Schema = typeof Schema>(fieldsAndMethods: T & ThisType<SchemaInstance<T, P>>, name?: string, inherits?: P): SchemaWithExtendsConstructor<T, ExtractInitProps<T>, P>;
 export {};

package/build/decoder/strategy/Callbacks.d.ts

@@ -1,10 +1,9 @@
-import { Collection, NonFunctionPropNames } from "../../types/HelperTypes.js";
+import { NonFunctionPropNames, CollectionLike } from "../../types/HelperTypes.js";
 import type { IRef, Ref } from "../../encoder/ChangeTree.js";
 import { Decoder } from "../Decoder.js";
 import { DataChange } from "../DecodeOperation.js";
 import { OPERATION } from "../../encoding/spec.js";
 import { Schema } from "../../Schema.js";
-import { $refId } from "../../types/symbols.js";
 import { MapSchema } from "../../types/custom/MapSchema.js";
 import { ArraySchema } from "../../types/custom/ArraySchema.js";
 import { type SchemaCallbackProxy } from "./getDecoderStateCallbacks.js";
@@ -12,12 +11,12 @@ type PropertyChangeCallback<K> = (currentValue: K, previousValue: K) => void;
 type KeyValueCallback<K, V> = (key: K, value: V) => void;
 type ValueKeyCallback<V, K> = (value: V, key: K) => void;
 type InstanceChangeCallback = () => void;
-type PublicPropNames<T> = Exclude<NonFunctionPropNames<T>, typeof $refId> & string;
-type CollectionPropNames<T> = Exclude<{
-    [K in keyof T]: T[K] extends Collection<any, any> ? K : never;
-}[keyof T] & string, typeof $refId>;
-type CollectionValueType<T, K extends keyof T> = T[K] extends MapSchema<infer V, any> ? V : T[K] extends ArraySchema<infer V> ? V : T[K] extends Collection<any, infer V, any> ? V : never;
-type CollectionKeyType<T, K extends keyof T> = T[K] extends MapSchema<any, infer Key> ? Key : T[K] extends ArraySchema<any> ? number : T[K] extends Collection<infer Key, any, any> ? Key : never;
+type PublicPropNames<T> = NonFunctionPropNames<T> & string;
+type CollectionPropNames<T> = {
+    [K in keyof T]: T[K] extends CollectionLike<any, any> ? K : never;
+}[keyof T] & string;
+type CollectionValueType<T, K extends keyof T> = T[K] extends MapSchema<infer V, any> ? V : T[K] extends ArraySchema<infer V> ? V : T[K] extends CollectionLike<any, infer V, any> ? V : never;
+type CollectionKeyType<T, K extends keyof T> = T[K] extends MapSchema<any, infer Key> ? Key : T[K] extends ArraySchema<any> ? number : T[K] extends CollectionLike<infer Key, any, any> ? Key : never;
 export declare class StateCallbackStrategy<TState extends IRef> {
     protected decoder: Decoder<TState>;
     protected uniqueRefIds: Set<number>;

package/build/decoder/strategy/getDecoderStateCallbacks.d.ts

@@ -1,4 +1,4 @@
-import { Collection, NonFunctionNonPrimitivePropNames, NonFunctionPropNames } from "../../types/HelperTypes.js";
+import { NonFunctionNonPrimitivePropNames, NonFunctionPropNames, CollectionLike } from "../../types/HelperTypes.js";
 import { Decoder } from "../Decoder.js";
 import { Schema } from "../../Schema.js";
 /**
@@ -10,7 +10,7 @@ import { Schema } from "../../Schema.js";
  */
 export type SchemaCallbackProxy<RoomState> = (<T>(instance: T) => CallbackProxy<T>);
 export type GetCallbackProxy = SchemaCallbackProxy<any>;
-export type CallbackProxy<T> = unknown extends T ? SchemaCallback<T> & CollectionCallback<any, any> : T extends Collection<infer K, infer V, infer _> ? CollectionCallback<K, V> : SchemaCallback<T>;
+export type CallbackProxy<T> = unknown extends T ? SchemaCallback<T> & CollectionCallback<any, any> : T extends CollectionLike<infer K, infer V, infer _> ? CollectionCallback<K, V> : SchemaCallback<T>;
 export type SchemaCallback<T> = {
     /**
      * Trigger callback when value of a property changes.