@gi-tcg/gts-transpiler 0.3.7 → 0.3.9

package/dist/index.d.ts

@@ -1,6 +1,40 @@
+import { Options, Parser } from "acorn";
 import { SourceMap } from "magic-string";
 
 //#region node_modules/@types/estree/index.d.ts
+// This definition file follows a somewhat unusual format. ESTree allows
+// runtime type checks based on the `type` parameter. In order to explain this
+// to typescript we want to use discriminated union types:
+// https://github.com/Microsoft/TypeScript/pull/9163
+//
+// For ESTree this is a bit tricky because the high level interfaces like
+// Node or Function are pulling double duty. We want to pass common fields down
+// to the interfaces that extend them (like Identifier or
+// ArrowFunctionExpression), but you can't extend a type union or enforce
+// common fields on them. So we've split the high level interfaces into two
+// types, a base type which passes down inherited fields, and a type union of
+// all types which extend the base type. Only the type union is exported, and
+// the union is how other types refer to the collection of inheriting types.
+//
+// This makes the definitions file here somewhat more difficult to maintain,
+// but it has the notable advantage of making ESTree much easier to use as
+// an end user.
+interface BaseNodeWithoutComments {
+  // Every leaf interface that extends BaseNode must specify a type property.
+  // The type property should be a string literal. For example, Identifier
+  // has: `type: "Identifier"`
+  type: string;
+  loc?: SourceLocation | null | undefined;
+  range?: [number, number] | undefined;
+}
+interface BaseNode extends BaseNodeWithoutComments {
+  leadingComments?: Comment[] | undefined;
+  trailingComments?: Comment[] | undefined;
+}
+interface Comment extends BaseNodeWithoutComments {
+  type: "Line" | "Block";
+  value: string;
+}
 interface SourceLocation {
   source?: string | null | undefined;
   start: Position;
@@ -12,6 +46,472 @@ interface Position {
   /** >= 0 */
   column: number;
 }
+interface Program extends BaseNode {
+  type: "Program";
+  sourceType: "script" | "module";
+  body: Array<Directive | Statement | ModuleDeclaration>;
+  comments?: Comment[] | undefined;
+}
+interface Directive extends BaseNode {
+  type: "ExpressionStatement";
+  expression: Literal;
+  directive: string;
+}
+interface BaseFunction extends BaseNode {
+  params: Pattern[];
+  generator?: boolean | undefined;
+  async?: boolean | undefined; // The body is either BlockStatement or Expression because arrow functions
+  // can have a body that's either. FunctionDeclarations and
+  // FunctionExpressions have only BlockStatement bodies.
+  body: BlockStatement | Expression;
+}
+type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
+interface BaseStatement extends BaseNode {}
+interface EmptyStatement extends BaseStatement {
+  type: "EmptyStatement";
+}
+interface BlockStatement extends BaseStatement {
+  type: "BlockStatement";
+  body: Statement[];
+  innerComments?: Comment[] | undefined;
+}
+interface StaticBlock extends Omit<BlockStatement, "type"> {
+  type: "StaticBlock";
+}
+interface ExpressionStatement extends BaseStatement {
+  type: "ExpressionStatement";
+  expression: Expression;
+}
+interface IfStatement extends BaseStatement {
+  type: "IfStatement";
+  test: Expression;
+  consequent: Statement;
+  alternate?: Statement | null | undefined;
+}
+interface LabeledStatement extends BaseStatement {
+  type: "LabeledStatement";
+  label: Identifier;
+  body: Statement;
+}
+interface BreakStatement extends BaseStatement {
+  type: "BreakStatement";
+  label?: Identifier | null | undefined;
+}
+interface ContinueStatement extends BaseStatement {
+  type: "ContinueStatement";
+  label?: Identifier | null | undefined;
+}
+interface WithStatement extends BaseStatement {
+  type: "WithStatement";
+  object: Expression;
+  body: Statement;
+}
+interface SwitchStatement extends BaseStatement {
+  type: "SwitchStatement";
+  discriminant: Expression;
+  cases: SwitchCase[];
+}
+interface ReturnStatement extends BaseStatement {
+  type: "ReturnStatement";
+  argument?: Expression | null | undefined;
+}
+interface ThrowStatement extends BaseStatement {
+  type: "ThrowStatement";
+  argument: Expression;
+}
+interface TryStatement extends BaseStatement {
+  type: "TryStatement";
+  block: BlockStatement;
+  handler?: CatchClause | null | undefined;
+  finalizer?: BlockStatement | null | undefined;
+}
+interface WhileStatement extends BaseStatement {
+  type: "WhileStatement";
+  test: Expression;
+  body: Statement;
+}
+interface DoWhileStatement extends BaseStatement {
+  type: "DoWhileStatement";
+  body: Statement;
+  test: Expression;
+}
+interface ForStatement extends BaseStatement {
+  type: "ForStatement";
+  init?: VariableDeclaration | Expression | null | undefined;
+  test?: Expression | null | undefined;
+  update?: Expression | null | undefined;
+  body: Statement;
+}
+interface BaseForXStatement extends BaseStatement {
+  left: VariableDeclaration | Pattern;
+  right: Expression;
+  body: Statement;
+}
+interface ForInStatement extends BaseForXStatement {
+  type: "ForInStatement";
+}
+interface DebuggerStatement extends BaseStatement {
+  type: "DebuggerStatement";
+}
+type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+interface BaseDeclaration extends BaseStatement {}
+interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
+  type: "FunctionDeclaration";
+  /** It is null when a function declaration is a part of the `export default function` statement */
+  id: Identifier | null;
+  body: BlockStatement;
+}
+interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
+  id: Identifier;
+}
+interface VariableDeclaration extends BaseDeclaration {
+  type: "VariableDeclaration";
+  declarations: VariableDeclarator[];
+  kind: "var" | "let" | "const" | "using" | "await using";
+}
+interface VariableDeclarator extends BaseNode {
+  type: "VariableDeclarator";
+  id: Pattern;
+  init?: Expression | null | undefined;
+}
+interface ExpressionMap {
+  ArrayExpression: ArrayExpression;
+  ArrowFunctionExpression: ArrowFunctionExpression;
+  AssignmentExpression: AssignmentExpression;
+  AwaitExpression: AwaitExpression;
+  BinaryExpression: BinaryExpression;
+  CallExpression: CallExpression;
+  ChainExpression: ChainExpression;
+  ClassExpression: ClassExpression;
+  ConditionalExpression: ConditionalExpression;
+  FunctionExpression: FunctionExpression;
+  Identifier: Identifier;
+  ImportExpression: ImportExpression;
+  Literal: Literal;
+  LogicalExpression: LogicalExpression;
+  MemberExpression: MemberExpression;
+  MetaProperty: MetaProperty;
+  NewExpression: NewExpression;
+  ObjectExpression: ObjectExpression;
+  SequenceExpression: SequenceExpression;
+  TaggedTemplateExpression: TaggedTemplateExpression;
+  TemplateLiteral: TemplateLiteral;
+  ThisExpression: ThisExpression;
+  UnaryExpression: UnaryExpression;
+  UpdateExpression: UpdateExpression;
+  YieldExpression: YieldExpression;
+}
+type Expression = ExpressionMap[keyof ExpressionMap];
+interface BaseExpression extends BaseNode {}
+type ChainElement = SimpleCallExpression | MemberExpression;
+interface ChainExpression extends BaseExpression {
+  type: "ChainExpression";
+  expression: ChainElement;
+}
+interface ThisExpression extends BaseExpression {
+  type: "ThisExpression";
+}
+interface ArrayExpression extends BaseExpression {
+  type: "ArrayExpression";
+  elements: Array<Expression | SpreadElement | null>;
+}
+interface ObjectExpression extends BaseExpression {
+  type: "ObjectExpression";
+  properties: Array<Property | SpreadElement>;
+}
+interface PrivateIdentifier extends BaseNode {
+  type: "PrivateIdentifier";
+  name: string;
+}
+interface Property extends BaseNode {
+  type: "Property";
+  key: Expression;
+  value: Expression | Pattern; // Could be an AssignmentProperty
+  kind: "init" | "get" | "set";
+  method: boolean;
+  shorthand: boolean;
+  computed: boolean;
+}
+interface PropertyDefinition extends BaseNode {
+  type: "PropertyDefinition";
+  key: Expression | PrivateIdentifier;
+  value?: Expression | null | undefined;
+  computed: boolean;
+  static: boolean;
+}
+interface FunctionExpression extends BaseFunction, BaseExpression {
+  id?: Identifier | null | undefined;
+  type: "FunctionExpression";
+  body: BlockStatement;
+}
+interface SequenceExpression extends BaseExpression {
+  type: "SequenceExpression";
+  expressions: Expression[];
+}
+interface UnaryExpression extends BaseExpression {
+  type: "UnaryExpression";
+  operator: UnaryOperator;
+  prefix: true;
+  argument: Expression;
+}
+interface BinaryExpression extends BaseExpression {
+  type: "BinaryExpression";
+  operator: BinaryOperator;
+  left: Expression | PrivateIdentifier;
+  right: Expression;
+}
+interface AssignmentExpression extends BaseExpression {
+  type: "AssignmentExpression";
+  operator: AssignmentOperator;
+  left: Pattern | MemberExpression;
+  right: Expression;
+}
+interface UpdateExpression extends BaseExpression {
+  type: "UpdateExpression";
+  operator: UpdateOperator;
+  argument: Expression;
+  prefix: boolean;
+}
+interface LogicalExpression extends BaseExpression {
+  type: "LogicalExpression";
+  operator: LogicalOperator;
+  left: Expression;
+  right: Expression;
+}
+interface ConditionalExpression extends BaseExpression {
+  type: "ConditionalExpression";
+  test: Expression;
+  alternate: Expression;
+  consequent: Expression;
+}
+interface BaseCallExpression extends BaseExpression {
+  callee: Expression | Super;
+  arguments: Array<Expression | SpreadElement>;
+}
+type CallExpression = SimpleCallExpression | NewExpression;
+interface SimpleCallExpression extends BaseCallExpression {
+  type: "CallExpression";
+  optional: boolean;
+}
+interface NewExpression extends BaseCallExpression {
+  type: "NewExpression";
+}
+interface MemberExpression extends BaseExpression, BasePattern {
+  type: "MemberExpression";
+  object: Expression | Super;
+  property: Expression | PrivateIdentifier;
+  computed: boolean;
+  optional: boolean;
+}
+type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
+interface BasePattern extends BaseNode {}
+interface SwitchCase extends BaseNode {
+  type: "SwitchCase";
+  test?: Expression | null | undefined;
+  consequent: Statement[];
+}
+interface CatchClause extends BaseNode {
+  type: "CatchClause";
+  param: Pattern | null;
+  body: BlockStatement;
+}
+interface Identifier extends BaseNode, BaseExpression, BasePattern {
+  type: "Identifier";
+  name: string;
+}
+type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+interface SimpleLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value: string | boolean | number | null;
+  raw?: string | undefined;
+}
+interface RegExpLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value?: RegExp | null | undefined;
+  regex: {
+    pattern: string;
+    flags: string;
+  };
+  raw?: string | undefined;
+}
+interface BigIntLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value?: bigint | null | undefined;
+  bigint: string;
+  raw?: string | undefined;
+}
+type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
+type LogicalOperator = "||" | "&&" | "??";
+type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
+type UpdateOperator = "++" | "--";
+interface ForOfStatement extends BaseForXStatement {
+  type: "ForOfStatement";
+  await: boolean;
+}
+interface Super extends BaseNode {
+  type: "Super";
+}
+interface SpreadElement extends BaseNode {
+  type: "SpreadElement";
+  argument: Expression;
+}
+interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+  type: "ArrowFunctionExpression";
+  expression: boolean;
+  body: BlockStatement | Expression;
+}
+interface YieldExpression extends BaseExpression {
+  type: "YieldExpression";
+  argument?: Expression | null | undefined;
+  delegate: boolean;
+}
+interface TemplateLiteral extends BaseExpression {
+  type: "TemplateLiteral";
+  quasis: TemplateElement[];
+  expressions: Expression[];
+}
+interface TaggedTemplateExpression extends BaseExpression {
+  type: "TaggedTemplateExpression";
+  tag: Expression;
+  quasi: TemplateLiteral;
+}
+interface TemplateElement extends BaseNode {
+  type: "TemplateElement";
+  tail: boolean;
+  value: {
+    /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */cooked?: string | null | undefined;
+    raw: string;
+  };
+}
+interface AssignmentProperty extends Property {
+  value: Pattern;
+  kind: "init";
+  method: boolean; // false
+}
+interface ObjectPattern extends BasePattern {
+  type: "ObjectPattern";
+  properties: Array<AssignmentProperty | RestElement>;
+}
+interface ArrayPattern extends BasePattern {
+  type: "ArrayPattern";
+  elements: Array<Pattern | null>;
+}
+interface RestElement extends BasePattern {
+  type: "RestElement";
+  argument: Pattern;
+}
+interface AssignmentPattern extends BasePattern {
+  type: "AssignmentPattern";
+  left: Pattern;
+  right: Expression;
+}
+interface BaseClass extends BaseNode {
+  superClass?: Expression | null | undefined;
+  body: ClassBody;
+}
+interface ClassBody extends BaseNode {
+  type: "ClassBody";
+  body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
+}
+interface MethodDefinition extends BaseNode {
+  type: "MethodDefinition";
+  key: Expression | PrivateIdentifier;
+  value: FunctionExpression;
+  kind: "constructor" | "method" | "get" | "set";
+  computed: boolean;
+  static: boolean;
+}
+interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
+  type: "ClassDeclaration";
+  /** It is null when a class declaration is a part of the `export default class` statement */
+  id: Identifier | null;
+}
+interface ClassDeclaration extends MaybeNamedClassDeclaration {
+  id: Identifier;
+}
+interface ClassExpression extends BaseClass, BaseExpression {
+  type: "ClassExpression";
+  id?: Identifier | null | undefined;
+}
+interface MetaProperty extends BaseExpression {
+  type: "MetaProperty";
+  meta: Identifier;
+  property: Identifier;
+}
+type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration;
+interface BaseModuleDeclaration extends BaseNode {}
+interface BaseModuleSpecifier extends BaseNode {
+  local: Identifier;
+}
+interface ImportDeclaration extends BaseModuleDeclaration {
+  type: "ImportDeclaration";
+  specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+  attributes: ImportAttribute[];
+  source: Literal;
+}
+interface ImportSpecifier extends BaseModuleSpecifier {
+  type: "ImportSpecifier";
+  imported: Identifier | Literal;
+}
+interface ImportAttribute extends BaseNode {
+  type: "ImportAttribute";
+  key: Identifier | Literal;
+  value: Literal;
+}
+interface ImportExpression extends BaseExpression {
+  type: "ImportExpression";
+  source: Expression;
+  options?: Expression | null | undefined;
+}
+interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+  type: "ImportDefaultSpecifier";
+}
+interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+  type: "ImportNamespaceSpecifier";
+}
+interface ExportNamedDeclaration extends BaseModuleDeclaration {
+  type: "ExportNamedDeclaration";
+  declaration?: Declaration | null | undefined;
+  specifiers: ExportSpecifier[];
+  attributes: ImportAttribute[];
+  source?: Literal | null | undefined;
+}
+interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
+  type: "ExportSpecifier";
+  local: Identifier | Literal;
+  exported: Identifier | Literal;
+}
+interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+  type: "ExportDefaultDeclaration";
+  declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
+}
+interface ExportAllDeclaration extends BaseModuleDeclaration {
+  type: "ExportAllDeclaration";
+  exported: Identifier | Literal | null;
+  attributes: ImportAttribute[];
+  source: Literal;
+}
+interface AwaitExpression extends BaseExpression {
+  type: "AwaitExpression";
+  argument: Expression;
+}
+//#endregion
+//#region src/parse/gts_plugin.d.ts
+interface GtsPluginOption {
+  allowEmptyShortcutMember?: boolean;
+  allowEmptyPositionalAttribute?: boolean;
+}
+//#endregion
+//#region src/parse/index.d.ts
+interface ParseOptions extends GtsPluginOption {
+  onComment: Options["onComment"];
+}
+declare function parse(input: string, options?: ParseOptions): Program;
+interface ParseLooseOptions extends GtsPluginOption {
+  recordCallLParens?: boolean;
+}
+declare function parseLoose(input: string, options?: ParseLooseOptions): Program;
 //#endregion
 //#region src/transform/gts.d.ts
 interface TranspileOption {
@@ -87,6 +587,13 @@ interface CodeInformation {
 }
 //#endregion
 //#region src/transform/volar/mappings.d.ts
+declare module "@volar/language-core" {
+  interface CodeInformation {
+    gtsAttribute?: boolean;
+    literalFromId?: boolean;
+    directActionStub?: boolean;
+  }
+}
 interface VolarMappingResult {
   code: string;
   mappings: CodeMapping[];
@@ -125,4 +632,4 @@ declare function resolveGtsConfigSync(filePath: string, inlineConfig: GtsConfig,
 declare function transpile(source: string, filename: string, option: TranspileOption): TranspileResult;
 declare function transpileForVolar(source: string, filename: string, option: TranspileOption): VolarMappingResult;
 //#endregion
-export { type GtsConfig, GtsTranspilerError, type TranspileOption, type TranspileResult, type VolarMappingResult, resolveGtsConfig, resolveGtsConfigSync, transpile, transpileForVolar };
+export { type GtsConfig, type ParseLooseOptions as GtsParseLooseOptions, type ParseOptions as GtsParseOptions, GtsTranspilerError, type TranspileOption, type TranspileResult, type VolarMappingResult, parse, parseLoose, resolveGtsConfig, resolveGtsConfigSync, transpile, transpileForVolar };

package/dist/index.js

@@ -527,7 +527,8 @@ function parse(input, options) {
 			ecmaVersion: "latest",
 			sourceType: "module",
 			locations: true,
-			ranges: true
+			ranges: true,
+			onComment: options?.onComment
 		});
 	} catch (e) {
 		if (e instanceof SyntaxError && "loc" in e) {
@@ -1549,6 +1550,7 @@ const gtsToTypingsWalker = {
 	},
 	GTSNamedAttributeDefinition(node, { visit, state }) {
 		const { name, body, bindingName } = node;
+		state.attributeNameNodes.add(name);
 		const attrName = JSON.stringify(name.type === "Literal" ? String(name.value) : name.name);
 		const { lhsId } = enterAttr(state, attrName);
 		const positionals = body.positionalAttributes.attributes.map((attr) => {
@@ -1636,14 +1638,28 @@ const gtsToTypingsWalker = {
 	GTSNamedAttributeBlock(node, { state, visit }) {
 		for (const attr of node.attributes) visit(attr);
 		if (node.directAction) {
+			const stubStatement = {
+				type: "ExpressionStatement",
+				expression: {
+					type: "Literal",
+					value: 0
+				}
+			};
+			state.typingPendingStatements.push(stubStatement);
 			const attrName = JSON.stringify(state.ActionLit.value);
 			const { lhsId } = enterAttr(state, attrName);
 			const actionNotExistsReplacementStr = `${lhsId.name}[${attrName}]`;
-			if (node.directAction.range) state.extraMappings.push({
-				sourceOffset: node.directAction.range[0],
-				length: node.directAction.range[1] - node.directAction.range[0],
-				generatedNeedle: actionNotExistsReplacementStr
-			});
+			if (node.directAction.range) {
+				state.extraMappings.push({
+					sourceOffset: node.directAction.range[0],
+					length: node.directAction.range[1] - node.directAction.range[0],
+					generatedNeedle: actionNotExistsReplacementStr
+				});
+				state.directActionStubRange.set(stubStatement.expression, {
+					start: node.directAction.range[0],
+					end: node.directAction.range[1]
+				});
+			}
 			const fn = {
 				type: "ArrowFunctionExpression",
 				params: state.shortcutFunctionParameters,
@@ -1692,6 +1708,18 @@ const DEFAULT_VOLAR_MAPPING_DATA = {
 	structure: true,
 	verification: true
 };
+const ATTRIBUTE_NAME_MAPPING_DATA = {
+	...DEFAULT_VOLAR_MAPPING_DATA,
+	gtsAttribute: true
+};
+const LITERAL_FROM_ID_MAPPING_DATA = {
+	...DEFAULT_VOLAR_MAPPING_DATA,
+	literalFromId: true
+};
+const DIRECT_ACTION_STUB_MAPPING_DATA = {
+	...DEFAULT_VOLAR_MAPPING_DATA,
+	directActionStub: true
+};
 const VERIFICATION_ONLY_MAPPING_DATA = { verification: true };
 Object.freeze(DEFAULT_VOLAR_MAPPING_DATA);
 Object.freeze(VERIFICATION_ONLY_MAPPING_DATA);
@@ -1702,6 +1730,7 @@ function getPrintOptions(source, state) {
 		source,
 		isUntouched: (node) => {
 			if (node.type === "Identifier" && node.isDummy) return false;
+			if (state.attributeNameNodes.has(node)) return false;
 			return state.sourceNodes.has(node);
 		},
 		getLeadingComments: (node) => node.leadingComments,
@@ -1715,16 +1744,20 @@ function getPrintOptions(source, state) {
 					let firstNonWhiteSpaceIndex = context.source.slice(identifier.range[1]).search(/\S/);
 					const rangeEnd = firstNonWhiteSpaceIndex === -1 ? context.source.length : identifier.range[1] + firstNonWhiteSpaceIndex;
 					context.writeMapped(text, identifier.range[0], rangeEnd);
-				} else return defaultPrinters.Identifier(node, context);
+				} else if (identifier.range && state.attributeNameNodes.has(identifier)) context.writeMapped(identifier.name, identifier.range[0], identifier.range[1], ATTRIBUTE_NAME_MAPPING_DATA);
+				else defaultPrinters.Identifier(node, context);
 			},
 			Literal(node, context) {
 				const generatedStart = context.generatedOffset;
+				let directActionStubRange;
 				if (state.literalFromIdentifier.has(node) && node.range) {
 					const text = JSON.stringify(node.value);
 					context.write("\"");
-					context.writeMapped(text.slice(1, -1), node.range[0], node.range[1]);
+					context.writeMapped(text.slice(1, -1), node.range[0], node.range[1], LITERAL_FROM_ID_MAPPING_DATA);
 					context.write("\"");
-				} else defaultPrinters.Literal(node, context);
+				} else if (state.attributeNameNodes.has(node) && node.range) context.writeMapped(node.raw ?? JSON.stringify(node.value), node.range[0], node.range[1], ATTRIBUTE_NAME_MAPPING_DATA);
+				else if (directActionStubRange = state.directActionStubRange.get(node)) context.writeMapped(node.raw ?? JSON.stringify(node.value), directActionStubRange.start, directActionStubRange.start + 1, DIRECT_ACTION_STUB_MAPPING_DATA);
+				else defaultPrinters.Literal(node, context);
 				if (state.diagnosticsOnTopNodes.has(node)) {
 					const generatedEnd = context.generatedOffset;
 					context.createExtraMapping({
@@ -1865,7 +1898,9 @@ function transformForVolar(ast, option, sourceInfo) {
 		finalMetaTypeIdStack: [],
 		attrsOfCurrentVm: [],
 		sourceNodes: /* @__PURE__ */ new WeakSet(),
+		attributeNameNodes: /* @__PURE__ */ new WeakSet(),
 		namedAttributeCalleeLParenRange: /* @__PURE__ */ new WeakMap(),
+		directActionStubRange: /* @__PURE__ */ new WeakMap(),
 		literalFromIdentifier: /* @__PURE__ */ new WeakSet(),
 		lastArgNodes: /* @__PURE__ */ new WeakSet(),
 		lastImportDeclarationIfGen: null,
@@ -2010,4 +2045,4 @@ function transpileForVolar(source, filename, option) {
 	});
 }
 //#endregion
-export { GtsTranspilerError, resolveGtsConfig, resolveGtsConfigSync, transpile, transpileForVolar };
+export { GtsTranspilerError, parse, parseLoose, resolveGtsConfig, resolveGtsConfigSync, transpile, transpileForVolar };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gi-tcg/gts-transpiler",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "repository": {
     "type": "git",
     "url": "https://github.com/piovium/gts.git"
@@ -22,7 +22,7 @@
     "@sveltejs/acorn-typescript": "^1.0.8",
     "acorn": "^8.15.0",
     "dedent": "^1.7.2",
-    "espolar": "^0.5.2",
+    "espolar": "^0.6.0",
     "esrap": "2.2.1",
     "magic-string": "^0.30.21",
     "path-browserify-esm": "^1.0.6",

package/src/index.ts

@@ -1,4 +1,9 @@
-import { parse, parseLoose } from "./parse/index.ts";
+import {
+  parse,
+  parseLoose,
+  type ParseLooseOptions,
+  type ParseOptions,
+} from "./parse/index.ts";
 import {
   transform,
   transformForVolar,
@@ -34,7 +39,14 @@ export function transpileForVolar(
   });
 }
 
-export type { TranspileOption, TranspileResult, VolarMappingResult };
+export { parse, parseLoose };
+export type {
+  ParseOptions as GtsParseOptions,
+  ParseLooseOptions as GtsParseLooseOptions,
+  TranspileOption,
+  TranspileResult,
+  VolarMappingResult,
+};
 export {
   resolveGtsConfig,
   resolveGtsConfigSync,

package/src/parse/index.ts

@@ -1,4 +1,4 @@
-import { Parser } from "acorn";
+import { Parser, type Options } from "acorn";
 import type { Position, Program } from "estree";
 import { tsPlugin } from "@sveltejs/acorn-typescript";
 import { gtsPlugin, type GtsPluginOption } from "./gts_plugin.ts";
@@ -9,7 +9,11 @@ import { recordCallLParenPlugin } from "./record_call_lparen_plugin.ts";
 
 const TsParser = Parser.extend(tsPlugin());
 
-export function parse(input: string, options?: GtsPluginOption): Program {
+export interface ParseOptions extends GtsPluginOption {
+  onComment: Options["onComment"];
+}
+
+export function parse(input: string, options?: ParseOptions): Program {
   try {
     const GtsParser = TsParser.extend(gtsPlugin(options));
     return GtsParser.parse(input, {
@@ -17,6 +21,7 @@ export function parse(input: string, options?: GtsPluginOption): Program {
       sourceType: "module",
       locations: true,
       ranges: true,
+      onComment: options?.onComment,
     }) as Program;
   } catch (e) {
     if (e instanceof SyntaxError && "loc" in e) {

package/src/transform/volar/index.ts

@@ -41,7 +41,9 @@ export function transformForVolar(
     attrsOfCurrentVm: [],
 
     sourceNodes: new WeakSet(),
+    attributeNameNodes: new WeakSet(),
     namedAttributeCalleeLParenRange: new WeakMap(),
+    directActionStubRange: new WeakMap(),
     literalFromIdentifier: new WeakSet(),
     lastArgNodes: new WeakSet(),
     lastImportDeclarationIfGen: null,

package/src/transform/volar/mappings.ts

@@ -1,5 +1,13 @@
 import type { CodeInformation, CodeMapping } from "@volar/language-core";
 
+declare module "@volar/language-core" {
+  export interface CodeInformation {
+    gtsAttribute?: boolean;
+    literalFromId?: boolean;
+    directActionStub?: boolean;
+  }
+}
+
 export interface VolarMappingResult {
   code: string;
   mappings: CodeMapping[];
@@ -13,6 +21,18 @@ export const DEFAULT_VOLAR_MAPPING_DATA: CodeInformation = {
   structure: true,
   verification: true,
 };
+export const ATTRIBUTE_NAME_MAPPING_DATA: CodeInformation = {
+  ...DEFAULT_VOLAR_MAPPING_DATA,
+  gtsAttribute: true,
+}
+export const LITERAL_FROM_ID_MAPPING_DATA: CodeInformation = {
+  ...DEFAULT_VOLAR_MAPPING_DATA,
+  literalFromId: true,
+}
+export const DIRECT_ACTION_STUB_MAPPING_DATA: CodeInformation = {
+  ...DEFAULT_VOLAR_MAPPING_DATA,
+  directActionStub: true,
+}
 export const VERIFICATION_ONLY_MAPPING_DATA: CodeInformation = {
   verification: true,
 };

package/src/transform/volar/printer.ts

@@ -1,5 +1,6 @@
 import type {
   Identifier,
+  Literal,
   NewExpression,
   Node,
   SimpleCallExpression,
@@ -8,10 +9,14 @@ import {
   type PrintOptions,
   type AST as EspolarAST,
   defaultPrinters,
+  type SourceRange,
 } from "espolar";
 import type { CodeInformation } from "@volar/language-core";
 import {
+  ATTRIBUTE_NAME_MAPPING_DATA,
   DEFAULT_VOLAR_MAPPING_DATA,
+  DIRECT_ACTION_STUB_MAPPING_DATA,
+  LITERAL_FROM_ID_MAPPING_DATA,
   VERIFICATION_ONLY_MAPPING_DATA,
 } from "./mappings.ts";
 import type { TypingTranspileState } from "./walker.ts";
@@ -26,19 +31,25 @@ export function getPrintOptions(
       if (node.type === "Identifier" && (node as Identifier).isDummy) {
         return false;
       }
+      if (state.attributeNameNodes.has(node as Identifier | Literal)) {
+        return false;
+      }
       return state.sourceNodes.has(node as Node);
     },
     getLeadingComments: (node) => (node as Node).leadingComments,
     getTrailingComments: (node) => (node as Node).trailingComments,
     getMappingData: () => DEFAULT_VOLAR_MAPPING_DATA,
     printers: {
-      // Make the print of dummy identifier print nothing.
-      // Exception: if GTS attribute list's last argument is dummy, e.g.
-      //     foo bar, ;
-      //             ^~ here
-      // Then the printed JS will be `foo(bar, )` which WILL NOT be syntax error in ES6.
-      // So we mark the lastArg manually and print an additional comma
-      // for this dummy identifier, i.e. `foo(bar,,)` and TypeScript will recognize the error.
+      // 1) Make the print of dummy identifier print nothing.
+      //    Exception: if GTS attribute list's last argument is dummy, e.g.
+      //        foo bar, ;
+      //                ^~ here
+      //    Then the printed JS will be `foo(bar, )` which WILL NOT be syntax error in ES6.
+      //    So we mark the lastArg manually and print an additional comma
+      //    for this dummy identifier, i.e. `foo(bar,,)` and TypeScript will recognize the error.
+      // 2) Add mapping data "gtsAttribute" to GTS attribute name identifiers and literals.
+      //    This will be recognized as "*.gtsAttribute" semantic token in language service plugin
+      //    and remapped to "emphasis" in the language client that rendered as italic.
       Identifier(node, context) {
         const identifier = node as Identifier;
         if (identifier.isDummy && identifier.range) {
@@ -52,17 +63,52 @@ export function getPrintOptions(
               ? context.source.length
               : identifier.range[1] + firstNonWhiteSpaceIndex;
           context.writeMapped(text, identifier.range[0], rangeEnd);
+        } else if (
+          identifier.range &&
+          state.attributeNameNodes.has(identifier)
+        ) {
+          context.writeMapped(
+            identifier.name,
+            identifier.range[0],
+            identifier.range[1],
+            ATTRIBUTE_NAME_MAPPING_DATA,
+          );
         } else {
-          return defaultPrinters.Identifier(node, context);
+          defaultPrinters.Identifier(node, context);
         }
       },
       Literal(node, context) {
         const generatedStart = context.generatedOffset;
+        let directActionStubRange: SourceRange | undefined;
         if (state.literalFromIdentifier.has(node) && node.range) {
+          // For string literals generated from identifiers, add mappings from only the content of literal
+          // to the identifier, so the highlight, auto-complete, etc. will work correctly.
           const text = JSON.stringify(node.value);
           context.write('"');
-          context.writeMapped(text.slice(1, -1), node.range[0], node.range[1]);
+          context.writeMapped(
+            text.slice(1, -1),
+            node.range[0],
+            node.range[1],
+            LITERAL_FROM_ID_MAPPING_DATA,
+          );
           context.write('"');
+        } else if (state.attributeNameNodes.has(node) && node.range) {
+          context.writeMapped(
+            node.raw ?? JSON.stringify((node as EspolarAST.Literal).value),
+            node.range[0],
+            node.range[1],
+            ATTRIBUTE_NAME_MAPPING_DATA,
+          );
+        } else if ((directActionStubRange = state.directActionStubRange.get(node))) {
+          // For direct action stubs, add mappings from this expression statement line to the
+          // start of original direct action start position. Add `directActionStub` data
+          // for recognizing them in language service plugin.
+          context.writeMapped(
+            node.raw ?? JSON.stringify((node as EspolarAST.Literal).value),
+            directActionStubRange.start,
+            directActionStubRange.start + 1,
+            DIRECT_ACTION_STUB_MAPPING_DATA,
+          )
         } else {
           defaultPrinters.Literal(node, context);
         }

package/src/transform/volar/walker.ts

@@ -54,11 +54,19 @@ export interface TypingTranspileState extends TranspileState {
   replacementTag: Identifier;
   /** untouched source nodes */
   sourceNodes: WeakSet<Node>;
+  /** GTS' attribute name nodes */
+  attributeNameNodes: WeakSet<Identifier | Literal>;
   /**
-   * The callee of typing source of GTS' attribute names. Map the character
+   * For each callee of typing source of GTS' attribute names, map the character
    * after the name (typically whitespace) as the lParen of CallExpression
    */
   namedAttributeCalleeLParenRange: WeakMap<Node, SourceRange>;
+  /**
+   * For each GTSDirectFunction, map a generated stub statement to the range of
+   * GTSDirectFunction itself. This extra mapping is used to insert CodeLens that
+   * mark the start position of direct action body.
+   */
+  directActionStubRange: WeakMap<Node, SourceRange>;
   /**
    * String literal nodes that are derived from identifiers.
    * - sourceStart += 1
@@ -325,12 +333,14 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
         state.diagnosticsOnTopNodes.add(specifier);
       }
     }
-    const lastImportDecl = importDecls.pop() ?? {
-      type: "ImportDeclaration",
-      specifiers: [],
-      source: { type: "Literal", value: "" },
-      attributes: [],
-    } satisfies ImportDeclaration;
+    const lastImportDecl =
+      importDecls.pop() ??
+      ({
+        type: "ImportDeclaration",
+        specifiers: [],
+        source: { type: "Literal", value: "" },
+        attributes: [],
+      } satisfies ImportDeclaration);
     body.unshift(
       ...importDecls,
       // Add an unrelated statement between system generated imports to make them unsorted,
@@ -342,7 +352,7 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
         expression: {
           type: "Literal",
           value: 0,
-        }
+        },
       },
       lastImportDecl,
       createReplacementHolder(state, {
@@ -362,6 +372,7 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
   },
   GTSNamedAttributeDefinition(node, { visit, state }) {
     const { name, body, bindingName } = node;
+    state.attributeNameNodes.add(name);
     const attrName = JSON.stringify(
       name.type === "Literal" ? String(name.value) : name.name,
     );
@@ -462,6 +473,11 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
       visit(attr);
     }
     if (node.directAction) {
+      const stubStatement: ExpressionStatement = {
+        type: "ExpressionStatement",
+        expression: { type: "Literal", value: 0 },
+      };
+      state.typingPendingStatements.push(stubStatement);
       const attrName = JSON.stringify(state.ActionLit.value);
       const { lhsId } = enterAttr(state, attrName);
       const actionNotExistsReplacementStr = `${lhsId.name}[${attrName}]`;
@@ -471,6 +487,10 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
           length: node.directAction.range[1] - node.directAction.range[0],
           generatedNeedle: actionNotExistsReplacementStr,
         });
+        state.directActionStubRange.set(stubStatement.expression, {
+          start: node.directAction.range[0],
+          end: node.directAction.range[1],
+        });
       }
       const fn: ArrowFunctionExpression = {
         type: "ArrowFunctionExpression",

package/src/transform/volar/collect_tokens.ts

@@ -1,90 +0,0 @@
-import type { Node, Program, SourceLocation } from "estree";
-import { walk } from "zimmerframe";
-
-export interface LeafToken {
-  loc: SourceLocation;
-  isDummy?: boolean;
-  /**
-   * Override source length (instead of loc.end - loc.start)
-   */
-  sourceLength?: number;
-  /**
-   * Adjust the start position of source code
-   */
-  sourceStartOffset?: number;
-  /**
-   * Adjust the start position of generated code
-   */
-  generatedStartOffset?: number;
-  /**
-   * Make the source length longer
-   */
-  sourceLengthOffset?: number;
-  /**
-   * The original length of generated code, used for mapping diagnostics
-   */
-  generatedLength?: number;
-}
-
-export function collectLeafTokens(source: string, ast: Program): LeafToken[] {
-  interface CollectTokenState {
-    tokens: LeafToken[];
-    /** Whether the node is from source and purely TypeScript */
-    pureSource: boolean;
-    /** Whether the node is visited once (for detecting leaf node) */
-    visited: boolean;
-  }
-  const state: CollectTokenState = {
-    tokens: [],
-    pureSource: true,
-    visited: false,
-  };
-  walk(ast as Node, state, {
-    _(node, { state, next }) {
-      state.visited = true;
-      let currNodePureSource = !!node.loc && !node.type.startsWith("GTS");
-      const subState = { tokens: [], pureSource: true, visited: false };
-      next(subState);
-      currNodePureSource &&= subState.pureSource;
-      state.pureSource &&= currNodePureSource;
-      // record original source for purely branch node
-      if (subState.visited && node.range && currNodePureSource) {
-        const [start, end] = node.range;
-        node.pureSource = source.slice(start, end);
-      }
-      if (currNodePureSource) {
-        const token: LeafToken = {
-          loc: node.loc!,
-        };
-        if ("isDummy" in node && node.isDummy) {
-          token.isDummy = true;
-          token.sourceLength = 0;
-          // add 1 for squiggle on next character
-          token.generatedLength = 1;
-        }
-        state.tokens.push(token);
-      } else {
-        state.tokens.push(...subState.tokens);
-      }
-    },
-    NewExpression(node, { state, next }) {
-      const lParenLoc = node.lParenLoc;
-      if (lParenLoc) {
-        state.tokens.push({
-          loc: lParenLoc,
-        });
-      }
-      next();
-    },
-    CallExpression(node, { state, next }) {
-      const lParenLoc = node.lParenLoc;
-      if (lParenLoc) {
-        state.tokens.push({
-          loc: lParenLoc,
-        });
-      }
-      next();
-    },
-  });
-  return state.tokens;
-}