@gi-tcg/gts-transpiler 0.3.2 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gi-tcg/gts-transpiler",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "repository": "https://github.com/piovium/gts.git",
   "license": "Apache-2.0",
   "type": "module",
@@ -16,20 +16,22 @@
     "dist"
   ],
   "dependencies": {
-    "@jridgewell/sourcemap-codec": "^1.5.5",
     "@sveltejs/acorn-typescript": "^1.0.8",
     "acorn": "^8.15.0",
+    "dedent": "^1.7.2",
+    "espolar": "^0.5.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"
+    "build": "tsdown --platform neutral",
+    "test": "vitest"
   }
 }

package/src/parse/gts_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

@@ -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

@@ -2,15 +2,15 @@ import { tokTypes, type Parser } from "acorn";
 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/gts.ts

@@ -10,7 +10,6 @@ import type {
   ModuleDeclaration,
   Node,
   ObjectExpression,
-  ObjectPattern,
   Pattern,
   Program,
   Statement,
@@ -35,14 +34,12 @@ export interface TranspileState {
   readonly fnArgId: Identifier;
   readonly shortcutFunctionParameters: Pattern[];
   readonly rootVmId: Identifier;
-  readonly queryFnId: Identifier;
   readonly queryParameters: Pattern[];
+  readonly QueryLit: Literal;
+  readonly QueryAllLit: Literal;
 
   readonly runtimeImportSource: string;
   readonly providerImportSource: string;
-  readonly queryArg: ObjectPattern;
-  
-  hasQueryExpressions: boolean;
 
   externalizedBindings: ExternalizedBinding[];
   /** Internal counters / state for emitting per-define nodes & bindings */
@@ -66,6 +63,7 @@ export const commonGtsVisitor: Visitors<Node, TranspileState> = {
           shorthand: false,
           value: state.ActionLit,
           loc: node.loc,
+          range: node.range,
         },
         {
           type: "Property",
@@ -108,6 +106,7 @@ export const commonGtsVisitor: Visitors<Node, TranspileState> = {
         },
       ],
       loc: node.loc,
+      range: node.range,
     };
   },
   GTSShortcutFunctionExpression(
@@ -120,6 +119,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,15 +130,21 @@ export const commonGtsVisitor: Visitors<Node, TranspileState> = {
       optional: false,
       property: visit(node.property) as Identifier,
       loc: node.loc,
+      range: node.range,
     };
   },
   GTSQueryExpression(node, { state, visit }) {
-    state.hasQueryExpressions = true;
     return {
       ...node,
       type: "CallExpression",
       optional: false,
-      callee: state.queryFnId,
+      callee: {
+        type: "MemberExpression",
+        object: state.fnArgId,
+        property: node.star ? state.QueryAllLit : state.QueryLit,
+        computed: true,
+        optional: false,
+      },
       arguments: [
         {
           type: "ArrowFunctionExpression",
@@ -146,47 +152,14 @@ export const commonGtsVisitor: Visitors<Node, TranspileState> = {
           params: state.queryParameters,
           expression: true,
           loc: node.argument.loc,
-        },
-        {
-          type: "ObjectExpression",
-          properties: [
-            {
-              type: "Property",
-              key: { type: "Identifier", name: "star" },
-              computed: false,
-              kind: "init",
-              method: false,
-              shorthand: false,
-              value: {
-                type: "Literal",
-                value: !!node.star,
-              },
-            },
-            {
-              type: "Property",
-              key: { type: "Identifier", name: "context" },
-              computed: false,
-              kind: "init",
-              method: false,
-              shorthand: false,
-              value: state.fnArgId,
-            }
-          ],
+          range: node.argument.range,
         },
       ],
-      // loc: node.loc,
     };
   },
 };
 
 const gtsVisitor: Visitors<Node, TranspileState> = {
-  // _(node, { next }) {
-  //   console.log(node.type, !!node.leadingComments)
-  //   if (node.leadingComments) {
-  //     console.log(node.leadingComments);
-  //   }
-  //   return next();
-  // },
   Program(node, { state, visit }) {
     const body: Program["body"] = [];
     for (const stmt of node.body) {
@@ -197,22 +170,6 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
     body.unshift(...state.bindingStatements);
     state.bindingStatements = [];
 
-    if (state.hasQueryExpressions) {
-      body.unshift({
-        type: "ImportDeclaration",
-        specifiers: [
-          {
-            type: "ImportDefaultSpecifier",
-            local: state.queryFnId,
-          },
-        ],
-        source: {
-          type: "Literal",
-          value: `${state.providerImportSource}/query`,
-        },
-        attributes: [],
-      });
-    }
     body.unshift(
       {
         type: "ImportDeclaration",
@@ -279,6 +236,7 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
         },
       ],
       loc: node.loc,
+      range: node.range,
     });
 
     state.bindingStatements.push({
@@ -297,6 +255,7 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
         },
       ],
       loc: node.loc,
+      range: node.range,
     });
 
     for (let i = 0; i < newBindings.length; i++) {
@@ -338,6 +297,7 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
         arguments: [state.rootVmId, nodeVarId],
       },
       loc: node.loc,
+      range: node.range,
     };
   },
   GTSNamedAttributeDefinition(node, { visit, state }) {
@@ -363,6 +323,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 +375,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 +389,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 +412,7 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
         }
       }),
       loc: node.loc,
+      range: node.range,
     };
   },
   GTSNamedAttributeBlock(node, { visit }): ObjectExpression {
@@ -471,6 +437,7 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
         },
       ],
       loc: node.loc,
+      range: node.range,
     };
   },
   ...commonGtsVisitor,
@@ -541,26 +508,14 @@ export const initialTranspileState = (
     fnArgId,
     shortcutFunctionParameters,
     rootVmId: { type: "Identifier", name: "__gts_rootVm" },
-    queryFnId: { type: "Identifier", name: "__gts_query" },
     queryParameters,
+    QueryLit: { type: "Literal", value: "~query" },
+    QueryAllLit: { type: "Literal", value: "~queryAll" },
 
     runtimeImportSource: option.runtimeImportSource ?? "@gi-tcg/gts-runtime",
     providerImportSource: option.providerImportSource ?? "@gi-tcg/core/gts",
-    queryArg: {
-      type: "ObjectPattern",
-      properties: (option.queryBindings ?? []).map((name) => ({
-        type: "Property",
-        key: { type: "Identifier", name },
-        computed: false,
-        kind: "init",
-        method: false,
-        shorthand: true,
-        value: { type: "Identifier", name },
-      })),
-    },
 
     externalizedBindings: [],
-    hasQueryExpressions: false,
     defineIdCounter: 0,
 
     bindingStatements: [],

package/src/transform/index.ts

@@ -1,6 +1,6 @@
 import type { Program } from "estree";
 import { eraseTs } from "./erase_ts.ts";
-import { print } from "esrap";
+import { print, type Visitors } from "esrap";
 import jsPrinter from "esrap/languages/ts";
 import type { SourceMap } from "magic-string";
 import { gtsToTs, type TranspileOption } from "./gts.ts";
@@ -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,

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/content_start.ts

@@ -0,0 +1,69 @@
+/**
+ * Get the character offset after hashbang and file-scope leading comments.
+ * This is for simulating the behavior of TSServer insert auto-imports if no
+ * imports are present.
+ * @param source 
+ * @returns 
+ */
+export function getContentStartOffset(source: string): number {
+  let result = 0;
+  /** Current visiting character */
+  let pos = 0;
+  if (source.startsWith("#!")) {
+    const nl = source.indexOf("\n", pos);
+    if (nl === -1) {
+      return source.length;
+    }
+    pos = nl + 1;
+  }
+  const skipWhitespaces = () => {
+    let newlineCount = 0;
+    for (; pos < source.length; pos++) {
+      const ch = source[pos];
+      if (ch === " " || ch === "\t" || ch === "\r") {
+        continue;
+      }
+      if (ch === "\n") {
+        newlineCount++;
+        continue;
+      }
+      break;
+    }
+    return newlineCount;
+  }
+  skipWhitespaces();
+  while (pos < source.length) {
+    let newlineCount = 0;
+    // Eat a comment
+    if (source[pos] === "/" && pos + 1 < source.length) {
+      if (source[pos + 1] === "/") {
+        const nl = source.indexOf("\n", pos);
+        pos = nl === -1 ? source.length : nl + 1;
+        newlineCount++;
+      } else if (source[pos + 1] === "*") {
+        pos += 2;
+        while (pos < source.length) {
+          if (
+            source[pos] === "*" &&
+            pos + 1 < source.length &&
+            source[pos + 1] === "/"
+          ) {
+            pos += 2;
+            break;
+          }
+          pos++;
+        }
+      }
+      result = pos;
+      newlineCount += skipWhitespaces();
+      // If there are already 2 newlines in whitespace, the leading comments are ended
+      if (newlineCount >= 2) {
+        break;
+      }
+    } else {
+      // Not a comment, stop here
+      break;
+    }
+  }
+  return result;
+}