@ttsc/wasm 0.12.1 → 0.12.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/wasm",
-  "version": "0.12.1",
+  "version": "0.12.3",
   "description": "Build in-browser ttsc playgrounds. Compose ttsc + typescript-go with your own plugins via the Go host helper.",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",
@@ -38,7 +38,7 @@
   "homepage": "https://ttsc.dev",
   "devDependencies": {
     "@types/node": "^25.3.0",
-    "@typescript/native-preview": "7.0.0-dev.20260515.1",
+    "@typescript/native-preview": "7.0.0-dev.20260518.1",
     "rimraf": "^6.1.2"
   },
   "scripts": {

package/shim-vendor/shim/ast/go.mod

@@ -3,3 +3,12 @@ module github.com/microsoft/typescript-go/shim/ast
 go 1.26
 
 require github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157
+
+require (
+	github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
+	github.com/zeebo/xxh3 v1.1.0 // indirect
+	golang.org/x/sync v0.20.0 // indirect
+	golang.org/x/sys v0.43.0 // indirect
+	golang.org/x/text v0.36.0 // indirect
+)

package/shim-vendor/shim/ast/go.sum

@@ -0,0 +1,20 @@
+github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 h1:vymEbVwYFP/L05h5TKQxvkXoKxNvTpjxYKdF1Nlwuao=
+github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433/go.mod h1:tphK2c80bpPhMOI4v6bIc2xWywPfbqi1Z06+RcrMkDg=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
+github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157 h1:llOMPhKDiQ+UEJiAaQuuWaJOTg5V7tNNTEf9JPWoYSY=
+github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157/go.mod h1:m8YA0PMC7ti0GW0RI05D6fEcjQeu98XVS+FWF+VDW2k=
+github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
+github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
+github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
+github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
+golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
+golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
+golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
+gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
+gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=

package/shim-vendor/shim/ast/safe_text.go

@@ -0,0 +1,86 @@
+// gen_shims:hand-maintained
+//
+// Total-function replacement for upstream `(*Node).Text()`.
+//
+// Upstream panics for any Kind missing from its switch — most notably
+// KindQualifiedName, which surfaces in JSDoc parameter names (`@param
+// obj.field`) and dotted entity references. NodeText handles
+// QualifiedName by recursing on the left subtree and joining with the
+// right identifier, and falls back to the source-text slice for any
+// other Kind so downstream code can treat the helper as a total
+// function over *Node instead of guarding each call site.
+
+package ast
+
+import (
+  "strings"
+
+  innerast "github.com/microsoft/typescript-go/internal/ast"
+)
+
+// NodeText returns the identifier-like text of a node. It mirrors
+// upstream `(*Node).Text()` where upstream has an arm, adds a
+// QualifiedName arm that joins `left.right`, and falls back to the
+// node's source slice for any other Kind. Returns "" for nil.
+func NodeText(n *Node) string {
+  if n == nil {
+    return ""
+  }
+  switch n.Kind {
+  case KindIdentifier,
+    innerast.KindPrivateIdentifier,
+    KindStringLiteral,
+    KindNumericLiteral,
+    KindBigIntLiteral,
+    KindNoSubstitutionTemplateLiteral,
+    KindTemplateHead,
+    KindTemplateMiddle,
+    KindTemplateTail,
+    innerast.KindRegularExpressionLiteral,
+    innerast.KindJsxNamespacedName,
+    innerast.KindJSDocText,
+    innerast.KindJSDocLink,
+    innerast.KindJSDocLinkCode,
+    innerast.KindJSDocLinkPlain,
+    innerast.KindMetaProperty:
+    return n.Text()
+  case KindQualifiedName:
+    qn := n.AsQualifiedName()
+    if qn == nil {
+      return ""
+    }
+    left := NodeText(qn.Left)
+    right := ""
+    if qn.Right != nil {
+      right = qn.Right.Text()
+    }
+    switch {
+    case left == "" && right == "":
+      return ""
+    case left == "":
+      return right
+    case right == "":
+      return left
+    default:
+      return left + "." + right
+    }
+  }
+  return nodeSourceText(n)
+}
+
+// nodeSourceText returns the verbatim source slice covered by the node's
+// position range, trimmed of surrounding whitespace. Same byte range
+// scanner.GetTextOfNode would read; safe for any Kind because it does
+// not inspect per-Kind data fields.
+func nodeSourceText(n *innerast.Node) string {
+  file := innerast.GetSourceFileOfNode(n)
+  if file == nil {
+    return ""
+  }
+  text := file.Text()
+  pos, end := n.Pos(), n.End()
+  if pos < 0 || end > len(text) || pos >= end {
+    return ""
+  }
+  return strings.TrimSpace(text[pos:end])
+}

package/shim-vendor/shim/ast/test/node_text_joins_multi_hop_qualified_name_test.go

@@ -0,0 +1,32 @@
+package ast_test
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestNodeTextJoinsMultiHopQualifiedName verifies NodeText joins a
+// multi-hop QualifiedName as "A.B.C".
+//
+// Locks the recursion in the QualifiedName arm. QualifiedName.Left is an
+// *EntityName (Identifier OR QualifiedName), so a non-recursive
+// implementation would silently drop everything but the final two
+// segments — breaking dotted references like
+// `IShoppingCoupon.IDirection.Inner` that show up in real-world JSDoc
+// and type-argument positions.
+//
+// 1. Construct A.B then ((A.B).C) via NewQualifiedName.
+// 2. Call NodeText on the outer node.
+// 3. Assert the result is "A.B.C".
+func TestNodeTextJoinsMultiHopQualifiedName(t *testing.T) {
+  factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+  a := factory.NewIdentifier("A")
+  b := factory.NewIdentifier("B")
+  c := factory.NewIdentifier("C")
+  ab := factory.NewQualifiedName(a, b)
+  abc := factory.NewQualifiedName(ab, c)
+  if got := shimast.NodeText(abc); got != "A.B.C" {
+    t.Fatalf("NodeText(A.B.C) = %q, want %q", got, "A.B.C")
+  }
+}

package/shim-vendor/shim/ast/test/node_text_joins_one_hop_qualified_name_test.go

@@ -0,0 +1,31 @@
+package ast_test
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestNodeTextJoinsOneHopQualifiedName verifies NodeText joins a one-hop
+// QualifiedName as "left.right".
+//
+// Locks the QualifiedName arm that upstream lacks: upstream's
+// (*Node).Text() panics with `Unhandled case in Node.Text:
+// *ast.QualifiedName` because the switch has no arm for the Kind. typia's
+// metadata_js_doc_parameter_name calls Text() on a JSDoc tag's Name()
+// which is a QualifiedName for `@param obj.field description`, so the
+// panic surfaces inside the nestia/typia build pipeline. NodeText must
+// turn a `Foo.Bar` qualified name into the dotted string.
+//
+// 1. Construct Foo.Bar via NewQualifiedName(Foo, Bar).
+// 2. Call NodeText on the qualified node.
+// 3. Assert the result is "Foo.Bar".
+func TestNodeTextJoinsOneHopQualifiedName(t *testing.T) {
+  factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+  left := factory.NewIdentifier("Foo")
+  right := factory.NewIdentifier("Bar")
+  qn := factory.NewQualifiedName(left, right)
+  if got := shimast.NodeText(qn); got != "Foo.Bar" {
+    t.Fatalf("NodeText(Foo.Bar) = %q, want %q", got, "Foo.Bar")
+  }
+}

package/shim-vendor/shim/ast/test/node_text_returns_empty_for_nil_test.go

@@ -0,0 +1,23 @@
+package ast_test
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestNodeTextReturnsEmptyForNil verifies NodeText returns "" for a nil node.
+//
+// Locks the nil-guard at the top of NodeText. The helper is a total function
+// over *Node — typia's JSDoc parameter-name extractor calls it without
+// checking — so a nil-deref here would be a behaviour change for every
+// caller. The empty-string contract is the only signal that lets callers
+// skip "no parameter name" entries cleanly.
+//
+// 1. Call NodeText(nil).
+// 2. Assert the result is "".
+func TestNodeTextReturnsEmptyForNil(t *testing.T) {
+  if got := shimast.NodeText(nil); got != "" {
+    t.Fatalf("NodeText(nil) = %q, want %q", got, "")
+  }
+}

package/shim-vendor/shim/ast/test/node_text_returns_identifier_text_test.go

@@ -0,0 +1,27 @@
+package ast_test
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestNodeTextReturnsIdentifierText verifies NodeText returns the
+// identifier text when the node Kind already has an upstream Text() arm.
+//
+// Covers the delegated branch: for Kinds upstream supports (Identifier,
+// StringLiteral, template parts, …), NodeText must forward to the
+// upstream method verbatim. Falling back to the source slice would
+// return "" for synthesised nodes that have no source range, breaking
+// every factory-built tree we hand to the typia metadata factory.
+//
+// 1. Construct a synthesised Identifier via NewIdentifier("Foo").
+// 2. Call NodeText on it.
+// 3. Assert the result is "Foo".
+func TestNodeTextReturnsIdentifierText(t *testing.T) {
+  factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+  id := factory.NewIdentifier("Foo")
+  if got := shimast.NodeText(id); got != "Foo" {
+    t.Fatalf("NodeText(Identifier) = %q, want %q", got, "Foo")
+  }
+}

package/shim-vendor/shim/ast/test/node_text_skips_empty_qualified_left_test.go

@@ -0,0 +1,30 @@
+package ast_test
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestNodeTextSkipsEmptyQualifiedLeft verifies NodeText does not emit a
+// stray leading "." when the left segment of a QualifiedName resolves
+// to the empty string.
+//
+// Parser recovery (and synthesised trees) can produce a QualifiedName
+// whose Left identifier carries empty text. A naive `left + "." + right`
+// concatenation would yield `.Inner`, which downstream code (the typia
+// metadata factory uses this as a map key) would treat as a distinct
+// parameter name. The arm has to drop the empty segment instead.
+//
+// 1. Build a QualifiedName whose Left is an Identifier created with "".
+// 2. Call NodeText on the qualified node.
+// 3. Assert the result is the right-hand text with no leading dot.
+func TestNodeTextSkipsEmptyQualifiedLeft(t *testing.T) {
+  factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+  left := factory.NewIdentifier("")
+  right := factory.NewIdentifier("Inner")
+  qn := factory.NewQualifiedName(left, right)
+  if got := shimast.NodeText(qn); got != "Inner" {
+    t.Fatalf("NodeText(<empty>.Inner) = %q, want %q", got, "Inner")
+  }
+}