@gi-tcg/gts-transpiler 0.3.1 → 0.3.3

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@gi-tcg/gts-transpiler",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "repository": "https://github.com/piovium/gts.git",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "bun": "./src/index.ts",
+      "development": "./src/index.ts",
       "default": "./dist/index.js"
     }
   },
@@ -15,19 +15,23 @@
     "src",
     "dist"
   ],
-  "scripts": {},
   "dependencies": {
-    "@jridgewell/sourcemap-codec": "^1.5.5",
     "@sveltejs/acorn-typescript": "^1.0.8",
-    "acorn": "8.15.0",
+    "acorn": "^8.15.0",
+    "dedent": "^1.7.2",
+    "espolar": "^0.2.1",
     "esrap": "2.2.1",
     "magic-string": "^0.30.21",
     "path-browserify-esm": "^1.0.6",
     "zimmerframe": "^1.1.4"
   },
   "devDependencies": {
+    "@types/estree": "^1.0.9",
     "@types/node": "^24.3.0",
-    "@types/estree": "^1.0.8",
     "@volar/language-core": "^2.4.27"
+  },
+  "scripts": {
+    "build": "tsdown --platform neutral",
+    "test": "vitest"
   }
-}
+}

package/src/config.ts

@@ -1,4 +1,4 @@
-import type { TranspileOption } from "./transform/gts";
+import type { TranspileOption } from "./transform/gts.ts";
 import path from "path-browserify-esm";
 
 export interface GtsConfig extends TranspileOption {}

package/src/error.ts

@@ -1,11 +1,10 @@
 import type { SourceLocation } from "estree";
 
 export class GtsTranspilerError extends Error {
-  constructor(
-    message: string,
-    public readonly position: SourceLocation | null,
-  ) {
+  public readonly position: SourceLocation | null;
+  constructor(message: string, position: SourceLocation | null) {
     super(message);
     this.name = "GtsTranspilerError";
+    this.position = position;
   }
 }

package/src/index.ts

@@ -1,12 +1,12 @@
-import { parse, parseLoose } from "./parse";
+import { parse, parseLoose } from "./parse/index.ts";
 import {
   transform,
   transformForVolar,
   type TranspileResult,
-} from "./transform";
-import type { TranspileOption } from "./transform/gts";
-import type { VolarMappingResult } from "./transform/volar";
-export { GtsTranspilerError } from "./error";
+} from "./transform/index.ts";
+import type { TranspileOption } from "./transform/gts.ts";
+import type { VolarMappingResult } from "./transform/volar/index.ts";
+export { GtsTranspilerError } from "./error.ts";
 
 export function transpile(
   source: string,
@@ -39,4 +39,4 @@ export {
   resolveGtsConfig,
   resolveGtsConfigSync,
   type GtsConfig,
-} from "./config";
+} from "./config.ts";

package/src/parse/gts_plugin.ts

@@ -1,7 +1,7 @@
 import { tokTypes, type Parser as ParserClass } from "acorn";
-import type { Parse, AST } from "../types";
-import { specialIdentifiers } from "../keywords";
-import { DUMMY_PLACEHOLDER } from "./loose_plugin";
+import type { Parse, AST } from "../types.ts";
+import { specialIdentifiers } from "../keywords.ts";
+import { DUMMY_PLACEHOLDER } from "./loose_plugin.ts";
 
 /*
 
@@ -251,7 +251,7 @@ export function gtsPlugin(options: GtsPluginOption = {}) {
             this.isContextual("as"))
         ) {
           // Allow omitting the attribute expression for language tooling
-          const dummy = this.startNode() as AST.Identifier;
+          const dummy = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc) as AST.Identifier;
           dummy.name = DUMMY_PLACEHOLDER;
           dummy.isDummy = true;
           return this.finishNode(dummy, "Identifier");
@@ -297,7 +297,7 @@ export function gtsPlugin(options: GtsPluginOption = {}) {
             this.type !== tokTypes.name
           ) {
             // Allow omitting the identifier after ':' for language tooling
-            const dummy = this.startNode() as AST.Identifier;
+            const dummy = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc) as AST.Identifier;
             dummy.name = DUMMY_PLACEHOLDER;
             dummy.isDummy = true;
             node.property = this.finishNode(dummy, "Identifier");

package/src/parse/index.ts

@@ -1,11 +1,11 @@
 import { Parser } from "acorn";
 import type { Position, Program } from "estree";
 import { tsPlugin } from "@sveltejs/acorn-typescript";
-import { gtsPlugin, type GtsPluginOption } from "./gts_plugin.js";
-import { loosePlugin } from "./loose_plugin.js";
+import { gtsPlugin, type GtsPluginOption } from "./gts_plugin.ts";
+import { loosePlugin } from "./loose_plugin.ts";
 import { getCommentHandlers } from "./comment.js";
-import { GtsTranspilerError } from "../error.js";
-import { recordCallLParenPlugin } from "./record_call_lparen_plugin.js";
+import { GtsTranspilerError } from "../error.ts";
+import { recordCallLParenPlugin } from "./record_call_lparen_plugin.ts";
 
 const TsParser = Parser.extend(tsPlugin());
 
@@ -16,6 +16,7 @@ export function parse(input: string, options?: GtsPluginOption): Program {
       ecmaVersion: "latest",
       sourceType: "module",
       locations: true,
+      ranges: true,
     }) as Program;
   } catch (e) {
     if (e instanceof SyntaxError && "loc" in e) {
@@ -54,6 +55,7 @@ export function parseLoose(
       ecmaVersion: "latest",
       sourceType: "module",
       locations: true,
+      ranges: true,
       onComment,
     }) as Program;
     addComments(ast);

package/src/parse/loose_plugin.ts

@@ -29,7 +29,7 @@ export function loosePlugin() {
       });
 
       createDummyIdentifier() {
-        const dummy = this.startNode() as AST.Identifier;
+        const dummy = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc) as AST.Identifier;
         dummy.name = DUMMY_PLACEHOLDER;
         dummy.isDummy = true;
         return this.finishNode(dummy, "Identifier");

package/src/parse/record_call_lparen_plugin.ts

@@ -1,16 +1,16 @@
 import { tokTypes, type Parser } from "acorn";
-import type { AST, Parse } from "../types.js";
+import type { AST, Parse } from "../types.ts";
 
 /**
- * A plugin that records the location of the left parenthesis in CallExpression and 
+ * A plugin that records the location of the left parenthesis in CallExpression and
  * NewExpression.
- * 
- * This is useful for Language tooling, that we can maps the '(' token from its location, 
- * to provide  * a signature help for user when they press `(` after a function name.
  *
- * The recorded location will be stored in `lParenLoc` property of the 
+ * This is useful for Language tooling, that we can maps the '(' token from its location,
+ * to provide a signature help for user when they press `(` after a function name.
+ *
+ * The recorded location will be stored in `lParenLoc` property of the
  * CallExpression/NewExpression node.
- * @returns
+ * @returns the plugin function
  */
 export function recordCallLParenPlugin() {
   return function recordCallLParenPluginTransformer(
@@ -26,12 +26,9 @@ export function recordCallLParenPlugin() {
         optionalChained?: boolean,
         forInit?: boolean | "await",
       ): AST.Expression {
-        let recordedLParenLoc: AST.SourceLocation | null = null;
+        let recordedLParenLoc: [number, number] | null = null;
         if (!noCalls && this.type === tokTypes.parenL) {
-          recordedLParenLoc = {
-            start: this.startLoc,
-            end: this.endLoc,
-          };
+          recordedLParenLoc = [this.start, this.end];
         }
         const result = super.parseSubscript(
           base,
@@ -43,18 +40,15 @@ export function recordCallLParenPlugin() {
           forInit,
         );
         if (recordedLParenLoc && result.type === "CallExpression") {
-          result.lParenLoc = recordedLParenLoc;
+          result.lParenRange = recordedLParenLoc;
         }
         return result;
       }
 
-      private _capturedLParenLocFromNew: AST.SourceLocation | null = null;
+      private _capturedLParenRangeFromNew: [number, number] | null = null;
       private readonly _patchedEat = (type: any) => {
         if (type === tokTypes.parenL) {
-          this._capturedLParenLocFromNew = {
-            start: this.startLoc,
-            end: this.endLoc,
-          };
+          this._capturedLParenRangeFromNew = [this.start, this.end];
         }
         return this.eat(type);
       };
@@ -74,9 +68,12 @@ export function recordCallLParenPlugin() {
 
       override parseNew() {
         const result = super.parseNew.apply(this.#proxiedThis);
-        if (this._capturedLParenLocFromNew && result.type === "NewExpression") {
-          result.lParenLoc = this._capturedLParenLocFromNew;
-          this._capturedLParenLocFromNew = null;
+        if (
+          this._capturedLParenRangeFromNew &&
+          result.type === "NewExpression"
+        ) {
+          result.lParenRange = this._capturedLParenRangeFromNew;
+          this._capturedLParenRangeFromNew = null;
         }
         return result;
       }

package/src/transform/erase_ts.ts

@@ -7,7 +7,7 @@ import type {
   Node,
   EmptyStatement,
 } from "estree";
-import { GtsTranspilerError } from "../error";
+import { GtsTranspilerError } from "../error.ts";
 
 const empty: EmptyStatement = {
   type: "EmptyStatement",
@@ -201,4 +201,4 @@ const eraseTsVisitor: Visitors<any, null> = {
 
 export const eraseTs = <T>(ast: T): T => {
   return walk(ast, null, eraseTsVisitor);
-}
+}

package/src/transform/gts.ts

@@ -16,11 +16,11 @@ import type {
   Statement,
 } from "estree";
 import { walk, type Visitors } from "zimmerframe";
-import { GtsTranspilerError } from "../error";
+import { GtsTranspilerError } from "../error.ts";
 import {
   DEFAULT_QUERY_BINDINGS,
   DEFAULT_SHORTCUT_FUNCTION_PRELUDES,
-} from "./constants";
+} from "./constants.ts";
 
 export interface ExternalizedBinding {
   bindingName: Identifier;
@@ -66,6 +66,7 @@ export const commonGtsVisitor: Visitors<Node, TranspileState> = {
           shorthand: false,
           value: state.ActionLit,
           loc: node.loc,
+          range: node.range,
         },
         {
           type: "Property",
@@ -108,6 +109,7 @@ export const commonGtsVisitor: Visitors<Node, TranspileState> = {
         },
       ],
       loc: node.loc,
+      range: node.range,
     };
   },
   GTSShortcutFunctionExpression(
@@ -120,6 +122,7 @@ export const commonGtsVisitor: Visitors<Node, TranspileState> = {
       body: visit(node.body) as Expression | BlockStatement,
       expression: node.expression,
       loc: node.loc,
+      range: node.range,
     };
   },
   GTSShortcutArgumentExpression(node, { state, visit }): MemberExpression {
@@ -130,6 +133,7 @@ export const commonGtsVisitor: Visitors<Node, TranspileState> = {
       optional: false,
       property: visit(node.property) as Identifier,
       loc: node.loc,
+      range: node.range,
     };
   },
   GTSQueryExpression(node, { state, visit }) {
@@ -146,6 +150,7 @@ export const commonGtsVisitor: Visitors<Node, TranspileState> = {
           params: state.queryParameters,
           expression: true,
           loc: node.argument.loc,
+          range: node.argument.range,
         },
         {
           type: "ObjectExpression",
@@ -174,7 +179,6 @@ export const commonGtsVisitor: Visitors<Node, TranspileState> = {
           ],
         },
       ],
-      // loc: node.loc,
     };
   },
 };
@@ -279,6 +283,7 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
         },
       ],
       loc: node.loc,
+      range: node.range,
     });
 
     state.bindingStatements.push({
@@ -297,6 +302,7 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
         },
       ],
       loc: node.loc,
+      range: node.range,
     });
 
     for (let i = 0; i < newBindings.length; i++) {
@@ -338,6 +344,7 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
         arguments: [state.rootVmId, nodeVarId],
       },
       loc: node.loc,
+      range: node.range,
     };
   },
   GTSNamedAttributeDefinition(node, { visit, state }) {
@@ -363,6 +370,7 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
       shorthand: false,
       value: nameValue,
       loc: node.loc,
+      range: node.range,
     });
     const body = { ...namedBody, properties };
     if (node.bindingName) {
@@ -414,8 +422,10 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
             body: positionals,
             expression: true,
             loc: positionals.loc,
+            range: positionals.range,
           },
           loc: positionals.loc,
+          range: positionals.range,
         },
         {
           type: "Property",
@@ -426,9 +436,11 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
           shorthand: false,
           value: named,
           loc: named.loc,
+          range: named.range,
         },
       ],
       loc: node.loc,
+      range: node.range,
     };
     return partialBody;
   },
@@ -447,6 +459,7 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
         }
       }),
       loc: node.loc,
+      range: node.range,
     };
   },
   GTSNamedAttributeBlock(node, { visit }): ObjectExpression {
@@ -471,6 +484,7 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
         },
       ],
       loc: node.loc,
+      range: node.range,
     };
   },
   ...commonGtsVisitor,

package/src/transform/index.ts

@@ -1,9 +1,9 @@
 import type { Program } from "estree";
-import { eraseTs } from "./erase_ts";
-import { print } from "esrap";
+import { eraseTs } from "./erase_ts.ts";
+import { print, type Visitors } from "esrap";
 import jsPrinter from "esrap/languages/ts";
 import type { SourceMap } from "magic-string";
-import { gtsToTs, type TranspileOption } from "./gts";
+import { gtsToTs, type TranspileOption } from "./gts.ts";
 
 export interface TranspileResult {
   code: string;
@@ -18,11 +18,11 @@ export interface SourceInfo {
 export function transform(
   ast: Program,
   option: TranspileOption = {},
-  sourceInfo: SourceInfo = {}
+  sourceInfo: SourceInfo = {},
 ): TranspileResult {
   const ts = gtsToTs(ast, option);
   const js = eraseTs(ts);
-  const { code, map } = print(js, jsPrinter(), {
+  const { code, map } = print(js, jsPrinter() as Visitors, {
     indent: "  ",
     sourceMapContent: sourceInfo.content,
     sourceMapSource: sourceInfo.filename,
@@ -33,4 +33,4 @@ export function transform(
   };
 }
 
-export { transformForVolar } from "./volar";
+export { transformForVolar } from "./volar/index.ts";

package/src/transform/volar/collect_tokens.ts

@@ -1,33 +1,6 @@
-import type { Node, SourceLocation } from "estree";
+import type { Node, Program, SourceLocation } from "estree";
 import { walk } from "zimmerframe";
 
-function isLeafNode(node: any): boolean {
-  for (const key in node) {
-    const val = node[key];
-
-    // Ignore non-child properties (metadata)
-    if (key === "loc" || key === "start" || key === "end" || key === "range") {
-      continue;
-    }
-
-    // Check if the property is a Node
-    // (An object with a 'type' property is generally an AST node)
-    if (val && typeof val === "object" && typeof val.type === "string") {
-      return false; // Found a valid child node
-    }
-
-    // Check if the property is an Array of Nodes (e.g., body: [...])
-    if (
-      Array.isArray(val) &&
-      val.length > 0 &&
-      typeof val[0].type === "string"
-    ) {
-      return false; // Found an array of child nodes
-    }
-  }
-  return true;
-}
-
 export interface LeafToken {
   loc: SourceLocation;
   isDummy?: boolean;
@@ -53,15 +26,35 @@ export interface LeafToken {
   generatedLength?: number;
 }
 
-export function collectLeafTokens(ast: any): LeafToken[] {
-  const state = {
-    tokens: [] as LeafToken[],
+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 }) {
-      if (isLeafNode(node) && node.loc) {
+      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,
+          loc: node.loc!,
         };
         if ("isDummy" in node && node.isDummy) {
           token.isDummy = true;
@@ -70,8 +63,9 @@ export function collectLeafTokens(ast: any): LeafToken[] {
           token.generatedLength = 1;
         }
         state.tokens.push(token);
+      } else {
+        state.tokens.push(...subState.tokens);
       }
-      next();
     },
     NewExpression(node, { state, next }) {
       const lParenLoc = node.lParenLoc;

package/src/transform/volar/index.ts

@@ -1,37 +1,28 @@
-import type { AST } from "../../types";
+import type { AST } from "../../types.ts";
 import { walk } from "zimmerframe";
-import type { SourceInfo, TranspileResult } from "..";
-import { print } from "esrap";
+import type { SourceInfo, TranspileResult } from "../index.ts";
+import { print } from "espolar";
 import {
   initialTranspileState,
   type TranspileOption,
   type TranspileState,
-} from "../gts";
-import { gtsToTypingsWalker, type TypingTranspileState } from "./walker";
-import { applyReplacements } from "./replacements";
+} from "../gts.ts";
+import { gtsToTypingsWalker, type TypingTranspileState } from "./walker.ts";
+import { applyReplacements } from "./replacements.ts";
 import type { Program } from "estree";
-import { convertToVolarMappings, type VolarMappingResult } from "./mappings";
-import { collectLeafTokens, type LeafToken } from "./collect_tokens";
-import { patchedPrinter } from "./printer";
+import { VERIFICATION_ONLY_MAPPING_DATA, type VolarMappingResult } from "./mappings.ts";
+import { getPrintOptions } from "./printer.ts";
 
-interface TypingTranspileOption extends TranspileOption {
-  leafTokens: LeafToken[];
-  /**
-   * "row:col" -> "replacement string"
-   */
-  extraMappings: Map<string, string>;
-}
-
-function gtsToTypings(
-  ast: AST.Program,
-  option: TypingTranspileOption,
-): TranspileResult {
+export function transformForVolar(
+  ast: Program,
+  option: TranspileOption,
+  sourceInfo: Required<SourceInfo>,
+): VolarMappingResult {
   const state: TypingTranspileState = {
     ...(initialTranspileState(option) as Pick<
       TypingTranspileState,
       keyof TranspileState
     >),
-    leafTokens: option.leafTokens,
     idCounter: 0,
     typingPendingStatements: [],
     rootVmId: { type: "Identifier", name: "__gts_root_vm" },
@@ -44,41 +35,50 @@ function gtsToTypings(
     metaTypeIdStack: [],
     finalMetaTypeIdStack: [],
     attrsOfCurrentVm: [],
-    extraMappings: option.extraMappings,
+
+    sourceNodes: new WeakSet(),
+    namedAttributeCalleeLParenRange: new WeakMap(),
+    literalFromIdentifier: new WeakSet(),
+    lastArgNodes: new WeakSet(),
+    diagnosticsOnTopNodes: new WeakSet(),
+    extraMappings: [],
   };
-  const newAst = walk(ast as AST.Node, state, gtsToTypingsWalker);
-  const { code, map } = print(newAst, patchedPrinter, {
-    indent: "  ",
+  // mark sourceNodes before the transformation
+  walk(ast as AST.Node, state, {
+    _(node, { state, next }) {
+      if (node.range) {
+        state.sourceNodes.add(node);
+      }
+      next();
+    },
   });
-  return {
-    code: applyReplacements(state, code),
-    sourceMap: map,
-  };
-}
-
-export function transformForVolar(
-  ast: Program,
-  option: TranspileOption,
-  sourceInfo: Required<SourceInfo>,
-): VolarMappingResult {
-  const tokens = collectLeafTokens(ast);
-  const extraMappings = new Map<string, string>();
-  const { code, sourceMap } = gtsToTypings(ast, {
-    ...option,
-    leafTokens: tokens,
-    extraMappings,
+  const newAst = walk(ast as AST.Node, state, gtsToTypingsWalker);
+  // mark lastArgNodes
+  walk(newAst as AST.Node, state, {
+    CallExpression(node, { state }) {
+      const lastArg = node.arguments.at(-1);
+      if (lastArg) {
+        state.lastArgNodes.add(lastArg);
+      }
+    }
   });
-  const volarMappings = convertToVolarMappings(
-    code,
-    sourceInfo.content,
-    sourceMap,
-    tokens,
-    extraMappings,
-  );
+  const printOptions = getPrintOptions(sourceInfo.content, state);
+  let { code, mappings } = print(newAst, printOptions);
+  code = applyReplacements(state, code, mappings);
+  for (const extraMapping of state.extraMappings) {
+    const genOffset = code.indexOf(extraMapping.generatedNeedle);
+    mappings.push({
+      sourceOffsets: [extraMapping.sourceOffset],
+      lengths: [extraMapping.length],
+      generatedOffsets: [genOffset],
+      generatedLengths: [extraMapping.generatedNeedle.length],
+      data: VERIFICATION_ONLY_MAPPING_DATA,
+    });
+  }
   return {
     code,
-    mappings: volarMappings,
+    mappings,
   };
 }
 
-export type { VolarMappingResult } from "./mappings";
+export type { VolarMappingResult } from "./mappings.ts";