@colyseus/schema 3.0.0-alpha.37 → 3.0.0-alpha.39

package/src/index.ts

@@ -41,7 +41,7 @@ export {
 
 // Annotations, Metadata and TypeContext
 export { Metadata } from "./Metadata";
-export { type, deprecated, defineTypes, view, } from "./annotations";
+export { type, deprecated, defineTypes, view, schema, type SchemaWithExtends, } from "./annotations";
 export { TypeContext } from "./types/TypeContext";
 
 // Annotation types

package/src/types/HelperTypes.ts

@@ -1,5 +1,11 @@
-import { ArraySchema } from "./custom/ArraySchema";
-import { MapSchema } from "./custom/MapSchema";
+import type { Definition, DefinitionType, PrimitiveType, RawPrimitiveType } from "../annotations";
+import type { Schema } from "../Schema";
+import type { ArraySchema } from "./custom/ArraySchema";
+import type { CollectionSchema } from "./custom/CollectionSchema";
+import type { MapSchema } from "./custom/MapSchema";
+import type { SetSchema } from "./custom/SetSchema";
+
+export type Constructor<T = {}> = new (...args: any[]) => T;
 
 export interface Collection<K = any, V = any, IT = V> {
     [Symbol.iterator](): IterableIterator<IT>;
@@ -7,6 +13,52 @@ export interface Collection<K = any, V = any, IT = V> {
     entries(): IterableIterator<[K, V]>;
 }
 
+export type InferValueType<T extends DefinitionType> =
+    T extends "string" ? string
+    : T extends "number" ? number
+    : T extends "int8" ? number
+    : T extends "uint8" ? number
+    : T extends "int16" ? number
+    : T extends "uint16" ? number
+    : T extends "int32" ? number
+    : T extends "uint32" ? number
+    : T extends "int64" ? number
+    : T extends "uint64" ? number
+    : T extends "float32" ? number
+    : T extends "float64" ? number
+    : T extends "boolean" ? boolean
+
+    : T extends { type: infer ChildType extends Constructor } ? InstanceType<ChildType>
+    : T extends { type: infer ChildType extends PrimitiveType } ? ChildType
+
+    : T extends Array<infer ChildType extends Constructor> ? InstanceType<ChildType>[]
+    : T extends Array<infer ChildType extends RawPrimitiveType> ? ChildType[]
+
+    : T extends { array: infer ChildType extends Constructor } ? InstanceType<ChildType>[]
+    : T extends { array: infer ChildType extends PrimitiveType } ? ChildType[]
+
+    : T extends { map: infer ChildType extends Constructor } ? MapSchema<InstanceType<ChildType>>
+    : T extends { map: infer ChildType extends PrimitiveType } ? MapSchema<ChildType>
+
+    : T extends { set: infer ChildType extends Constructor } ? SetSchema<InstanceType<ChildType>>
+    : T extends { set: infer ChildType extends PrimitiveType } ? SetSchema<ChildType>
+
+    : T extends { collection: infer ChildType extends Constructor } ? CollectionSchema<InstanceType<ChildType>>
+    : T extends { collection: infer ChildType extends PrimitiveType } ? CollectionSchema<ChildType>
+
+    : T extends Constructor ? InstanceType<T>
+    : T extends PrimitiveType ? T
+
+    : never;
+
+export type InferSchemaInstanceType<T extends Definition> = {
+    [K in keyof T]: InferValueType<T[K]>
+} & Schema;
+
+export type DefinedSchemaType<T extends Definition, P extends typeof Schema> = {
+    new (): InferSchemaInstanceType<T> & InstanceType<P>;
+} & typeof Schema;
+
 export type NonFunctionProps<T> = Omit<T, {
     [K in keyof T]: T[K] extends Function ? K : never;
 }[keyof T]>;

package/src/types/TypeContext.ts

@@ -53,7 +53,7 @@ export class TypeContext {
         // Workaround to allow using an empty Schema (with no `@type()` fields)
         //
         if (schema[Symbol.metadata] === undefined) {
-            Metadata.init(schema);
+            Metadata.initialize(schema);
         }
 
         this.schemas.set(schema, typeid);
@@ -74,6 +74,16 @@ export class TypeContext {
             this.discoverTypes(child, parentIndex, parentFieldViewTag);
         });
 
+        // add parent classes
+        let parent: any = klass;
+        while (
+            (parent = Object.getPrototypeOf(parent)) &&
+            parent !== Schema && // stop at root (Schema)
+            parent !== Function.prototype // stop at root (non-Schema)
+        ) {
+            this.discoverTypes(parent);
+        }
+
         const metadata: Metadata = (klass[Symbol.metadata] ??= {});
 
         // if any schema/field has filters, mark "context" as having filters.