@zyno-io/ts-server-foundation 26.714.5 → 26.714.320

package/dist/src/type-compiler/go/text_parse.go

@@ -54,6 +54,7 @@ func literalArg(raw string) string {
 }
 
 func splitTop(input string, sep string) []string {
+	input = stripTypeComments(input)
 	parts := []string{}
 	start, depthAngle, depthBrace, depthParen, depthBracket, quote := 0, 0, 0, 0, 0, byte(0)
 	for i := 0; i < len(input); i++ {
@@ -287,8 +288,70 @@ func isTypeContinuationNewline(body string, start int, newline int) bool {
 }
 
 func stripTypeComments(body string) string {
-	replacer := regexp.MustCompile(`(?s)/\*.*?\*/|//[^\r\n]*`)
-	return replacer.ReplaceAllString(body, "")
+	if !strings.Contains(body, "/") {
+		return body
+	}
+	var out strings.Builder
+	out.Grow(len(body))
+	for i := 0; i < len(body); i++ {
+		current := body[i]
+		next := byte(0)
+		if i+1 < len(body) {
+			next = body[i+1]
+		}
+		if current == '\'' || current == '"' {
+			quote := current
+			out.WriteByte(current)
+			for i++; i < len(body); i++ {
+				out.WriteByte(body[i])
+				if body[i] == '\\' && i+1 < len(body) {
+					i++
+					out.WriteByte(body[i])
+					continue
+				}
+				if body[i] == quote {
+					break
+				}
+			}
+			continue
+		}
+		if current == '`' {
+			end := skipTemplateLiteral(body, i)
+			out.WriteString(body[i : end+1])
+			i = end
+			continue
+		}
+		if current == '/' && next == '/' {
+			out.WriteString("  ")
+			i += 2
+			for ; i < len(body) && body[i] != '\n' && body[i] != '\r'; i++ {
+				out.WriteByte(' ')
+			}
+			if i < len(body) {
+				out.WriteByte(body[i])
+			}
+			continue
+		}
+		if current == '/' && next == '*' {
+			out.WriteString("  ")
+			i += 2
+			for ; i < len(body); i++ {
+				if body[i] == '*' && i+1 < len(body) && body[i+1] == '/' {
+					out.WriteString("  ")
+					i++
+					break
+				}
+				if body[i] == '\n' || body[i] == '\r' {
+					out.WriteByte(body[i])
+				} else {
+					out.WriteByte(' ')
+				}
+			}
+			continue
+		}
+		out.WriteByte(current)
+	}
+	return out.String()
 }
 
 func parseField(field string) (string, string, bool, bool) {

package/dist/src/type-compiler/go/type_expr.go

@@ -10,12 +10,8 @@ func typeExpr(info *fileInfo, reg *registry, raw string) string {
 	return typeExprCtx(info, reg, raw, &typeContext{seen: map[string]bool{}})
 }
 
-func internalTypeExprAt(info *fileInfo, reg *registry, raw string, pos int) string {
-	return typeExprCtx(info, reg, raw, &typeContext{seen: map[string]bool{}, pos: pos})
-}
-
 func typeExprCtx(info *fileInfo, reg *registry, raw string, ctx *typeContext) string {
-	raw = strings.TrimSpace(raw)
+	raw = strings.TrimSpace(stripTypeComments(raw))
 	raw = trimParens(raw)
 	raw = strings.TrimSpace(strings.TrimPrefix(raw, "readonly "))
 	if raw == "" || raw == "unknown" {
@@ -415,7 +411,7 @@ func renderUtilityProperty(info *fileInfo, reg *registry, prop utilityProperty,
 	if prop.owner != nil {
 		owner = prop.owner
 	}
-	t := typeExprCtx(owner, reg, prop.typeText, ctx)
+	t := internalTypeExprForNodeCtx(owner, reg, prop.typeText, prop.typeNode, ctx)
 	if prop.optional {
 		t = "{kind: 12, types: [" + t + ", {kind: 4}]}"
 	}
@@ -436,7 +432,7 @@ func renderPreferredUtilityProperty(info *fileInfo, reg *registry, prop utilityP
 	}
 	var t string
 	if sourceTypeNeedsInternalPropertyMetadata(owner, reg, prop.typeText, &typeContext{seen: map[string]bool{}, pos: pos}, map[string]bool{}) {
-		t = typeExprCtx(owner, reg, prop.typeText, &typeContext{seen: map[string]bool{}, pos: pos})
+		t = internalTypeExprForNode(owner, reg, prop.typeText, prop.typeNode, pos)
 	} else {
 		t = typeExprForNodePreferred(owner, reg, prop.typeText, prop.typeNode, pos, true)
 	}
@@ -634,7 +630,7 @@ func utilitySourceProperties(info *fileInfo, reg *registry, source string, ctx *
 	if class, owner, ok := resolveClassRefAt(info, reg, source, ctx.pos); ok {
 		props := make([]utilityProperty, 0, len(class.properties))
 		for _, prop := range class.properties {
-			props = append(props, utilityProperty{name: prop.name, typeText: prop.typeText, optional: prop.optional, owner: owner})
+			props = append(props, utilityProperty{name: prop.name, typeText: prop.typeText, typeNode: prop.typeNode, optional: prop.optional, owner: owner})
 		}
 		return props, owner, true
 	}
@@ -1097,7 +1093,7 @@ func aliasTypeExprCtx(owner *fileInfo, reg *registry, alias aliasInfo, name stri
 	if strings.TrimSpace(alias.metadataText) != "" {
 		return withTypeName(alias.metadataText, name)
 	}
-	return withTypeName(typeExprCtx(owner, reg, alias.body, ctx), name)
+	return withTypeName(internalTypeExprForNodeCtx(owner, reg, alias.body, alias.typeNode, ctx), name)
 }
 
 func ensureAliasMetadata(owner *fileInfo, reg *registry, name string, alias aliasInfo) aliasInfo {

package/dist/src/type-compiler/go/typia_expr.go

@@ -18,6 +18,7 @@ func typeExprForNode(info *fileInfo, reg *registry, raw string, node *shimast.No
 }
 
 func typeExprForNodePreferred(info *fileInfo, reg *registry, raw string, node *shimast.Node, pos int, preferTypia bool) string {
+	raw = strings.TrimSpace(stripTypeComments(raw))
 	if preferTypia {
 		if expr, ok := preferredWrapperTypeExprForNode(info, reg, raw, node, pos); ok {
 			return expr
@@ -25,16 +26,16 @@ func typeExprForNodePreferred(info *fileInfo, reg *registry, raw string, node *s
 		if expr, ok := preferredCachedAliasTypeExpr(info, reg, raw, pos); ok {
 			return expr
 		}
-		if expr, ok := preferredNullishAliasTypeExpr(info, reg, raw, pos); ok {
+		if expr, ok := preferredNullishAliasTypeExpr(info, reg, raw, node, pos); ok {
 			return expr
 		}
-		if expr, ok := preferredDateRootTypeExpr(info, reg, raw, pos); ok {
+		if expr, ok := preferredDateRootTypeExpr(info, reg, raw, node, pos); ok {
 			return expr
 		}
 		if expr, ok := preferredExternalImportedTypeExpr(info, raw); ok {
 			return expr
 		}
-		if expr, ok := preferredExternalImportedCompositeTypeExpr(info, reg, raw, pos); ok {
+		if expr, ok := preferredExternalImportedCompositeTypeExpr(info, reg, raw, node, pos); ok {
 			return expr
 		}
 		if expr, ok := preferredNamedInterfaceTypeExpr(info, reg, raw, pos); ok {
@@ -47,14 +48,78 @@ func typeExprForNodePreferred(info *fileInfo, reg *registry, raw string, node *s
 		}
 	}
 	if shouldUseTextTypeExpr(raw) {
-		return internalTypeExprAt(info, reg, raw, pos)
+		return internalTypeExprForNode(info, reg, raw, node, pos)
 	}
 	if shouldUseTypiaType(info, reg, raw) && canPreferTypiaType(info, reg, raw) {
 		if expr, ok := typiaTypeExprForNode(info, reg, raw, node, pos); ok {
 			return typiaSourceNamedExpr(info, reg, expr, raw)
 		}
 	}
-	return internalTypeExprAt(info, reg, raw, pos)
+	return internalTypeExprForNode(info, reg, raw, node, pos)
+}
+
+func internalTypeExprForNode(info *fileInfo, reg *registry, raw string, node *shimast.Node, pos int) string {
+	return internalTypeExprForNodeCtx(info, reg, raw, node, &typeContext{seen: map[string]bool{}, pos: pos})
+}
+
+func internalTypeExprForNodeCtx(info *fileInfo, reg *registry, raw string, node *shimast.Node, ctx *typeContext) string {
+	if ctx == nil {
+		ctx = &typeContext{seen: map[string]bool{}}
+	}
+	if node == nil {
+		return typeExprCtx(info, reg, raw, ctx)
+	}
+	if node.Kind == shimast.KindParenthesizedType {
+		inner := node.AsParenthesizedTypeNode().Type
+		if innerRaw, ok := sourceTypeNodeText(info, inner); ok {
+			return internalTypeExprForNodeCtx(info, reg, innerRaw, inner, ctx)
+		}
+		return typeExprCtx(info, reg, raw, ctx)
+	}
+
+	var kind int
+	var nodes []*shimast.Node
+	switch node.Kind {
+	case shimast.KindUnionType:
+		kind = 12
+		if types := node.AsUnionTypeNode().Types; types != nil {
+			nodes = types.Nodes
+		}
+	case shimast.KindIntersectionType:
+		kind = 13
+		if types := node.AsIntersectionTypeNode().Types; types != nil {
+			nodes = types.Nodes
+		}
+	default:
+		return typeExprCtx(info, reg, raw, ctx)
+	}
+	if len(nodes) < 2 {
+		return typeExprCtx(info, reg, raw, ctx)
+	}
+
+	types := make([]string, 0, len(nodes))
+	for _, child := range nodes {
+		childRaw, ok := sourceTypeNodeText(info, child)
+		if !ok {
+			return typeExprCtx(info, reg, raw, ctx)
+		}
+		types = append(types, internalTypeExprForNodeCtx(info, reg, childRaw, child, ctx))
+	}
+	return "{kind: " + strconv.Itoa(kind) + ", types: [" + strings.Join(types, ", ") + "]}"
+}
+
+func sourceTypeNodeText(info *fileInfo, node *shimast.Node) (string, bool) {
+	if node == nil {
+		return "", false
+	}
+	file := shimast.GetSourceFileOfNode(node)
+	if file == nil && info != nil {
+		file = info.file
+	}
+	if file == nil {
+		return "", false
+	}
+	return nodeText(file, node), true
 }
 
 func preferredCachedAliasTypeExpr(info *fileInfo, reg *registry, raw string, pos int) (string, bool) {
@@ -77,22 +142,46 @@ func preferredCachedAliasTypeExpr(info *fileInfo, reg *registry, raw string, pos
 	return aliasTypeExprCtx(owner, reg, alias, raw, &typeContext{seen: map[string]bool{}, pos: pos}), true
 }
 
-func preferredNullishAliasTypeExpr(info *fileInfo, reg *registry, raw string, pos int) (string, bool) {
+func preferredNullishAliasTypeExpr(info *fileInfo, reg *registry, raw string, node *shimast.Node, pos int) (string, bool) {
 	types := []string{}
-	aliasCount, ok := collectNullishAliasTypeExprs(info, reg, raw, pos, &types)
+	aliasCount, ok := collectNullishAliasTypeExprs(info, reg, raw, node, pos, &types)
 	if !ok || aliasCount != 1 || len(types) <= 1 {
 		return "", false
 	}
 	return "{kind: 12, types: [" + strings.Join(types, ", ") + "]}", true
 }
 
-func collectNullishAliasTypeExprs(info *fileInfo, reg *registry, raw string, pos int, types *[]string) (int, bool) {
+func collectNullishAliasTypeExprs(info *fileInfo, reg *registry, raw string, node *shimast.Node, pos int, types *[]string) (int, bool) {
 	raw = strings.TrimSpace(trimParens(raw))
+	if node != nil && node.Kind == shimast.KindParenthesizedType {
+		inner := node.AsParenthesizedTypeNode().Type
+		if innerRaw, ok := sourceTypeNodeText(info, inner); ok {
+			return collectNullishAliasTypeExprs(info, reg, innerRaw, inner, pos, types)
+		}
+	}
+	if node != nil && node.Kind == shimast.KindUnionType {
+		union := node.AsUnionTypeNode()
+		if union.Types != nil && len(union.Types.Nodes) > 1 {
+			aliasCount := 0
+			for _, child := range union.Types.Nodes {
+				childRaw, ok := sourceTypeNodeText(info, child)
+				if !ok {
+					return 0, false
+				}
+				count, ok := collectNullishAliasTypeExprs(info, reg, childRaw, child, pos, types)
+				if !ok {
+					return 0, false
+				}
+				aliasCount += count
+			}
+			return aliasCount, true
+		}
+	}
 	parts := nonEmptyParts(splitTop(raw, "|"))
 	if len(parts) > 1 {
 		aliasCount := 0
 		for _, part := range parts {
-			count, ok := collectNullishAliasTypeExprs(info, reg, part, pos, types)
+			count, ok := collectNullishAliasTypeExprs(info, reg, part, nil, pos, types)
 			if !ok {
 				return 0, false
 			}
@@ -117,11 +206,11 @@ func collectNullishAliasTypeExprs(info *fileInfo, reg *registry, raw string, pos
 	}
 }
 
-func preferredDateRootTypeExpr(info *fileInfo, reg *registry, raw string, pos int) (string, bool) {
+func preferredDateRootTypeExpr(info *fileInfo, reg *registry, raw string, node *shimast.Node, pos int) (string, bool) {
 	if !sourceTypeIsDateRootType(info, reg, raw, &typeContext{seen: map[string]bool{}, pos: pos}, map[string]bool{}) {
 		return "", false
 	}
-	return internalTypeExprAt(info, reg, raw, pos), true
+	return internalTypeExprForNode(info, reg, raw, node, pos), true
 }
 
 func preferredExternalImportedTypeExpr(info *fileInfo, raw string) (string, bool) {
@@ -136,25 +225,25 @@ func preferredExternalImportedTypeExpr(info *fileInfo, raw string) (string, bool
 	return externalImportedTypeExpr(ref, raw), true
 }
 
-func preferredExternalImportedCompositeTypeExpr(info *fileInfo, reg *registry, raw string, pos int) (string, bool) {
+func preferredExternalImportedCompositeTypeExpr(info *fileInfo, reg *registry, raw string, node *shimast.Node, pos int) (string, bool) {
 	raw = strings.TrimSpace(trimParens(raw))
 	if raw == "" || isIdentifierName(raw) {
 		return "", false
 	}
 	if parts := nonEmptyParts(splitTop(raw, "|")); len(parts) > 1 {
 		if typeContainsExternalImportReferenceInParts(info, reg, parts, map[string]bool{}) {
-			return internalTypeExprAt(info, reg, raw, pos), true
+			return internalTypeExprForNode(info, reg, raw, node, pos), true
 		}
 	}
 	if parts := nonEmptyParts(splitTop(raw, "&")); len(parts) > 1 {
 		if typeContainsExternalImportReferenceInParts(info, reg, parts, map[string]bool{}) {
-			return internalTypeExprAt(info, reg, raw, pos), true
+			return internalTypeExprForNode(info, reg, raw, node, pos), true
 		}
 	}
 	if strings.HasPrefix(raw, "[") && strings.HasSuffix(raw, "]") {
 		parts := nonEmptyParts(splitTop(strings.TrimSpace(raw[1:len(raw)-1]), ","))
 		if typeContainsExternalImportReferenceInParts(info, reg, parts, map[string]bool{}) {
-			return internalTypeExprAt(info, reg, raw, pos), true
+			return internalTypeExprForNode(info, reg, raw, node, pos), true
 		}
 	}
 	return "", false

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zyno-io/ts-server-foundation",
-    "version": "26.714.5",
+    "version": "26.714.320",
     "description": "TypeScript server foundation with reflected type metadata",
     "license": "MIT",
     "bin": {