@colyseus/schema 4.0.20 → 5.0.1

package/build/codegen/cli.cjs

@@ -213,7 +213,53 @@ function getInheritanceTree(klass, allClasses, includeSelf = true) {
 let currentStructure;
 let currentProperty;
 let globalContext;
+const BUILDER_COLLECTION_KINDS = new Set(["array", "map", "set", "collection"]);
+/**
+ * For a t.*().chain().calls() expression, walk down to the base `t.X(...)`
+ * call and return its method name and first argument. Returns null if the
+ * node does not look like a builder chain.
+ */
+function extractBuilderBase(node) {
+    let current = node;
+    while (true) {
+        const expr = current.expression;
+        if (!ts__namespace.isPropertyAccessExpression(expr)) {
+            return null;
+        }
+        if (ts__namespace.isCallExpression(expr.expression)) {
+            // Chained modifier, e.g. .default() / .view() — walk deeper.
+            current = expr.expression;
+            continue;
+        }
+        return {
+            methodName: expr.name.text,
+            firstArg: current.arguments[0],
+        };
+    }
+}
 function defineProperty(property, initializer) {
+    // Builder-style: t.number(), t.array(Item), t.map(Item).view(), etc.
+    if (ts__namespace.isCallExpression(initializer)) {
+        const base = extractBuilderBase(initializer);
+        if (base) {
+            if (BUILDER_COLLECTION_KINDS.has(base.methodName)) {
+                property.type = base.methodName;
+                if (base.firstArg) {
+                    property.childType = base.firstArg.text ?? base.firstArg.getText();
+                }
+            }
+            else if (base.methodName === "ref") {
+                property.type = "ref";
+                if (base.firstArg) {
+                    property.childType = base.firstArg.text ?? base.firstArg.getText();
+                }
+            }
+            else {
+                property.type = base.methodName;
+            }
+            return;
+        }
+    }
     if (ts__namespace.isIdentifier(initializer)) {
         property.type = "ref";
         property.childType = initializer.text;
@@ -377,30 +423,6 @@ function inspectNode(node, context, decoratorName) {
                     defineProperty(property, prop.initializer);
                 }
             }
-            else if (node.getText() === "defineTypes" &&
-                (node.parent.kind === ts__namespace.SyntaxKind.CallExpression ||
-                    node.parent.kind === ts__namespace.SyntaxKind.PropertyAccessExpression)) {
-                /**
-                 * JavaScript source file (`.js`)
-                 * Using `defineTypes()`
-                 */
-                const callExpression = (node.parent.kind === ts__namespace.SyntaxKind.PropertyAccessExpression)
-                    ? node.parent.parent
-                    : node.parent;
-                if (callExpression.kind !== ts__namespace.SyntaxKind.CallExpression) {
-                    break;
-                }
-                const className = callExpression.arguments[0].getText();
-                currentStructure.name = className;
-                const types = callExpression.arguments[1];
-                for (let i = 0; i < types.properties.length; i++) {
-                    const prop = types.properties[i];
-                    const property = currentProperty || new Property();
-                    property.name = prop.name.escapedText;
-                    currentStructure.addProperty(property);
-                    defineProperty(property, prop.initializer);
-                }
-            }
             if (node.parent.kind === ts__namespace.SyntaxKind.ClassDeclaration) {
                 currentStructure.name = node.getText();
             }
@@ -408,45 +430,63 @@ function inspectNode(node, context, decoratorName) {
             break;
         case ts__namespace.SyntaxKind.CallExpression:
             /**
-             * Defining schema via `schema.schema({ ... })`
-             * - schema.schema({})
-             * - schema({})
-             * - ClassName.extends({})
+             * Defining schema via:
+             * - schema({ ... })
+             * - schema({ ... }, 'Name')
+             * - schema.schema({ ... }, 'Name')
+             * - ParentClass.extend({ ... }, 'Name')
              */
-            if (((node.expression?.getText() === "schema.schema" ||
-                node.expression?.getText() === "schema") ||
-                (node.expression?.getText().indexOf(".extends") !== -1)) &&
-                node.arguments[0].kind === ts__namespace.SyntaxKind.ObjectLiteralExpression) {
+            {
                 const callExpression = node;
-                let className = callExpression.arguments[1]?.getText();
+                const callee = callExpression.expression?.getText?.();
+                if (!callee)
+                    break;
+                const isSchemaCall = callee === "schema" || callee === "schema.schema";
+                const isExtendCall = callee.indexOf(".extend") !== -1 && !callee.endsWith(".extends");
+                if (!isSchemaCall && !isExtendCall)
+                    break;
+                // Signature: (fields, name?)
+                const fieldsArg = callExpression.arguments[0];
+                const nameArg = callExpression.arguments[1];
+                if (!fieldsArg || fieldsArg.kind !== ts__namespace.SyntaxKind.ObjectLiteralExpression) {
+                    break;
+                }
+                let className;
+                if (nameArg) {
+                    if (nameArg.kind === ts__namespace.SyntaxKind.StringLiteral) {
+                        className = nameArg.text;
+                    }
+                    else {
+                        className = nameArg.getText();
+                    }
+                }
                 if (!className && callExpression.parent.kind === ts__namespace.SyntaxKind.VariableDeclaration) {
                     className = callExpression.parent.name?.getText();
                 }
-                // skip if no className is provided
-                if (!className) {
+                if (!className)
                     break;
-                }
                 if (currentStructure?.name !== className) {
                     currentStructure = new Class();
                     context.addStructure(currentStructure);
                 }
-                if (node.expression?.getText().indexOf(".extends") !== -1) {
-                    // if it's using `.extends({})`
+                if (isExtendCall) {
                     const extendsClass = node.expression?.expression?.escapedText;
-                    // skip if no extendsClass is provided
-                    if (!extendsClass) {
+                    if (!extendsClass)
                         break;
-                    }
                     currentStructure.extends = extendsClass;
                 }
                 else {
-                    // if it's using `schema({})`
-                    currentStructure.extends = "Schema"; // force extends to Schema
+                    currentStructure.extends = "Schema";
                 }
                 currentStructure.name = className;
-                const types = callExpression.arguments[0];
+                const types = fieldsArg;
                 for (let i = 0; i < types.properties.length; i++) {
                     const prop = types.properties[i];
+                    // Skip methods declared inside the fields object.
+                    if (prop.kind === ts__namespace.SyntaxKind.MethodDeclaration)
+                        continue;
+                    if (!prop.initializer)
+                        continue;
                     const property = currentProperty || new Property();
                     property.name = prop.name.escapedText;
                     currentStructure.addProperty(property);
@@ -643,33 +683,10 @@ ${generateClassBody$8(klass, indent)}
 ${namespace ? "}" : ""}
 `;
 }
-/**
- * Check if all enum members resolve to non-negative integers,
- * allowing emission as a native C# `enum` (which only supports integral types).
- */
-function canUseNativeEnum(_enum) {
-    return _enum.properties.every((prop) => {
-        if (!prop.type)
-            return true;
-        const n = Number(prop.type);
-        return Number.isInteger(n) && n >= 0;
-    });
-}
 /**
  * Generate just the enum body (without imports/namespace) for bundling
  */
 function generateEnumBody$1(_enum, indent = "") {
-    if (canUseNativeEnum(_enum)) {
-        const members = _enum.properties
-            .map((prop, i) => {
-            const value = prop.type ? Number(prop.type) : i;
-            return `${indent}\t${prop.name} = ${value},`;
-        })
-            .join("\n");
-        return `${indent}public enum ${_enum.name} : int {
-${members}
-${indent}}`;
-    }
     return `${indent}public struct ${_enum.name} {
 
 ${_enum.properties