@gi-tcg/gts-transpiler 0.6.3 → 0.6.5

package/dist/index.js

@@ -240,6 +240,11 @@ function gtsPlugin(options = {}) {
 				this.enterScope(acornScope.SCOPE_FUNCTION | acornScope.SCOPE_ARROW);
 				const oldShortcutContext = this.isShortcutContext;
 				this.isShortcutContext = true;
+				if (this.type === tokTypes.relational && this.value === "<") {
+					this.next();
+					node.returnType = this.tsInType(this.tsParseType.bind(this));
+					this.expect(tokTypes.relational);
+				}
 				if (this.type === tokTypes.parenL) {
 					this.next();
 					node.expression = true;
@@ -480,12 +485,13 @@ function getCommentHandlers(source, comments, index = 0) {
 }
 //#endregion
 //#region src/error.ts
-var GtsTranspilerError = class extends Error {
+var GtsTranspilerError = class GtsTranspilerError extends Error {
 	position;
 	constructor(message, position) {
 		super(message);
 		this.name = "GtsTranspilerError";
 		this.position = position;
+		if ("captureStackTrace" in Error) Error.captureStackTrace(this, GtsTranspilerError);
 	}
 };
 //#endregion
@@ -806,6 +812,10 @@ const commonGtsVisitor = {
 			params: [state.fnArgId],
 			body: visit(node.body),
 			expression: node.expression,
+			...node.returnType && { returnType: {
+				type: "TSTypeAnnotation",
+				typeAnnotation: node.returnType
+			} },
 			loc: node.loc,
 			range: node.range
 		};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gi-tcg/gts-transpiler",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "repository": {
     "type": "git",
     "url": "https://github.com/piovium/gts.git"
@@ -26,10 +26,10 @@
     "esrap": "2.2.1",
     "magic-string": "^0.30.21",
     "path-browserify-esm": "^1.0.6",
-    "zimmerframe": "^1.1.4"
+    "zimmerframe": "^1.1.4",
+    "@types/estree": "^1.0.9"
   },
   "devDependencies": {
-    "@types/estree": "^1.0.9",
     "@types/node": "^24.3.0",
     "@volar/language-core": "^2.4.27"
   },

package/src/error.ts

@@ -6,5 +6,8 @@ export class GtsTranspilerError extends Error {
     super(message);
     this.name = "GtsTranspilerError";
     this.position = position;
+    if ("captureStackTrace" in Error) {
+      (Error.captureStackTrace as any)(this, GtsTranspilerError);
+    }
   }
 }

package/src/index.ts

@@ -12,6 +12,7 @@ import {
 import type { TranspileOption } from "./transform/gts.ts";
 import type { VolarMappingResult } from "./transform/volar/index.ts";
 export { GtsTranspilerError } from "./error.ts";
+export type { AST } from "./types.ts";
 
 export function transpile(
   source: string,

package/src/parse/gts_plugin.ts

@@ -267,6 +267,11 @@ export function gtsPlugin(options: GtsPluginOption = {}) {
         this.enterScope(acornScope.SCOPE_FUNCTION | acornScope.SCOPE_ARROW);
         const oldShortcutContext = this.isShortcutContext;
         this.isShortcutContext = true;
+        if (this.type === tokTypes.relational && this.value === "<") {
+          this.next(); // consume '<'
+          node.returnType = this.tsInType(this.tsParseType.bind(this));
+          this.expect(tokTypes.relational);
+        }
         if (this.type === tokTypes.parenL) {
           this.next(); // consume '('
           node.expression = true;
@@ -315,7 +320,6 @@ export function gtsPlugin(options: GtsPluginOption = {}) {
         }
         return super.parseExprAtom(refDestructuringErrors, forInit, forNew);
       }
-
     };
   };
 }

package/src/transform/gts.ts

@@ -108,6 +108,12 @@ export const commonGtsVisitor: Visitors<Node, TranspileState> = {
       params: [state.fnArgId],
       body: visit(node.body) as Expression | BlockStatement,
       expression: node.expression,
+      ...(node.returnType && {
+        returnType: {
+          type: "TSTypeAnnotation",
+          typeAnnotation: node.returnType,
+        },
+      }),
       loc: node.loc,
       range: node.range,
     };

package/src/types.ts

@@ -29,13 +29,21 @@ declare module "estree" {
   interface NewExpression {
     lParenRange?: [number, number];
   }
+  interface ArrowFunctionExpression {
+    returnType?: TSTypeAnnotation;
+  }
+
+  export interface TSTypeAnnotation extends BaseNode {
+    type: "TSTypeAnnotation";
+    typeAnnotation: any;
+  }
 
-  interface GTSDefineStatement extends BaseStatement {
+  export interface GTSDefineStatement extends BaseStatement {
     type: "GTSDefineStatement";
     body: GTSNamedAttributeDefinition;
   }
 
-  interface GTSNamedAttributeDefinition extends BaseNode {
+  export interface GTSNamedAttributeDefinition extends BaseNode {
     type: "GTSNamedAttributeDefinition";
     name: Identifier | Literal;
     body: GTSAttributeBody;
@@ -43,37 +51,38 @@ declare module "estree" {
     bindingName?: Identifier;
   }
 
-  interface GTSAttributeBody extends BaseNode {
+  export interface GTSAttributeBody extends BaseNode {
     type: "GTSAttributeBody";
     positionalAttributes: GTSPositionalAttributeList;
     namedAttributes?: GTSNamedAttributeBlock;
   }
 
-  interface GTSPositionalAttributeList extends BaseNode {
+  export interface GTSPositionalAttributeList extends BaseNode {
     type: "GTSPositionalAttributeList";
     attributes: Expression[];
   }
 
-  interface GTSNamedAttributeBlock extends BaseNode {
+  export interface GTSNamedAttributeBlock extends BaseNode {
     type: "GTSNamedAttributeBlock";
     attributes: GTSNamedAttributeDefinition[];
     directAction?: GTSDirectFunction;
   }
 
-  interface GTSDirectFunction extends BaseNode {
+  export interface GTSDirectFunction extends BaseNode {
     type: "GTSDirectFunction";
     body: Statement[];
   }
 
-  interface GTSShortcutArgumentExpression extends BaseExpression {
+  export interface GTSShortcutArgumentExpression extends BaseExpression {
     type: "GTSShortcutArgumentExpression";
     property: Identifier;
   }
 
-  interface GTSShortcutFunctionExpression extends BaseExpression {
+  export interface GTSShortcutFunctionExpression extends BaseExpression {
     type: "GTSShortcutFunctionExpression";
     body: BlockStatement | Expression;
     expression: boolean;
+    returnType?: TSTypeAnnotation;
   }
 
 }
@@ -1500,6 +1509,14 @@ export declare namespace Parse {
     };
     // parse(input: string, options: Options): AST.Program;
 
+    /**
+   * Runs `cb` in a type context.
+   * This should be called one token *before* the first type token,
+   * so that the call to `next()` is run in type context.
+   */
+    tsInType<T>(cb: () => T): T
+    tsParseType(): any;
+
     getElementName(node?: AST.Node): string | null;
 
     /**