@gi-tcg/gts-transpiler 0.3.6 → 0.3.8

package/dist/index.d.ts

@@ -87,6 +87,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[];

package/dist/index.js

@@ -1549,6 +1549,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 +1637,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 +1707,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 +1729,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 +1743,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 +1897,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,
@@ -1954,7 +1988,8 @@ async function resolveGtsConfig(filePath, inlineConfig, options) {
 	const generator = resolveGtsConfigImpl(filePath, inlineConfig, options);
 	let result = generator.next();
 	while (!result.done) {
-		const content = await result.value;
+		const toRead = result.value;
+		const content = await Promise.resolve(toRead).catch(() => "");
 		result = generator.next(content);
 	}
 	return result.value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gi-tcg/gts-transpiler",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "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/config.ts

@@ -66,7 +66,9 @@ export async function resolveGtsConfig(
   let result = generator.next();
   while (!result.done) {
     const toRead = result.value;
-    const content = await toRead;
+    // return an invalid JSON if readFile fails, so that the generator
+    // can catch the error and try next one
+    const content = await Promise.resolve(toRead).catch(() => "");
     result = generator.next(content);
   }
   return result.value;

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;
-}