d2lsp: implement autocomplete functions

d2ast/keywords.go

@@ -8,7 +8,6 @@ var ReservedKeywords map[string]struct{}
 // Non Style/Holder keywords.
 var SimpleReservedKeywords = map[string]struct{}{
 	"label":          {},
-	"desc":           {},
 	"shape":          {},
 	"icon":           {},
 	"constraint":     {},

d2lsp/completion.go

@@ -0,0 +1,500 @@
+// Completion implements lsp autocomplete features
+// Currently handles:
+// - Complete dot and inside maps for reserved keyword holders (style, labels, etc)
+// - Complete discrete values for keywords like shape
+// - Complete suggestions for formats for keywords like opacity
+package d2lsp
+
+import (
+	"strings"
+	"unicode"
+
+	"oss.terrastruct.com/d2/d2ast"
+	"oss.terrastruct.com/d2/d2parser"
+	"oss.terrastruct.com/d2/d2target"
+)
+
+type CompletionKind int
+
+const (
+	KeywordCompletion CompletionKind = iota
+	StyleCompletion
+	ShapeCompletion
+)
+
+type CompletionItem struct {
+	Label      string
+	Kind       CompletionKind
+	Detail     string
+	InsertText string
+}
+
+func GetCompletionItems(text string, line, column int) ([]CompletionItem, error) {
+	ast, err := d2parser.Parse("", strings.NewReader(text), nil)
+	if err != nil {
+		ast, _ = d2parser.Parse("", strings.NewReader(getTextUntilPosition(text, line, column)), nil)
+	}
+
+	keyword := getKeywordContext(text, ast, line, column)
+	switch keyword {
+	case "style", "style.":
+		return getStyleCompletions(), nil
+	case "shape", "shape:":
+		return getShapeCompletions(), nil
+	case "shadow", "3d", "multiple", "animated", "bold", "italic", "underline", "filled", "double-border",
+		"shadow:", "3d:", "multiple:", "animated:", "bold:", "italic:", "underline:", "filled:", "double-border:":
+		return getBooleanCompletions(), nil
+	case "fill-pattern", "fill-pattern:":
+		return getFillPatternCompletions(), nil
+	case "text-transform", "text-transform:":
+		return getTextTransformCompletions(), nil
+	case "opacity", "stroke-width", "stroke-dash", "border-radius", "font-size",
+		"stroke", "fill", "font-color":
+		return getValueCompletions(keyword), nil
+	case "opacity:", "stroke-width:", "stroke-dash:", "border-radius:", "font-size:",
+		"stroke:", "fill:", "font-color:":
+		return getValueCompletions(keyword[:len(keyword)-1]), nil
+	case "width", "height", "top", "left":
+		return getValueCompletions(keyword), nil
+	case "width:", "height:", "top:", "left:":
+		return getValueCompletions(keyword[:len(keyword)-1]), nil
+	case "source-arrowhead", "target-arrowhead":
+		return getArrowheadCompletions(), nil
+	case "source-arrowhead.shape:", "target-arrowhead.shape:":
+		return getArrowheadShapeCompletions(), nil
+	case "label", "label.":
+		return getLabelCompletions(), nil
+	case "icon", "icon:":
+		return getIconCompletions(), nil
+	case "icon.":
+		return getLabelCompletions(), nil
+	case "near", "near:":
+		return getNearCompletions(), nil
+	case "tooltip:", "tooltip":
+		return getTooltipCompletions(), nil
+	case "direction:", "direction":
+		return getDirectionCompletions(), nil
+	default:
+		return nil, nil
+	}
+}
+
+func getTextUntilPosition(text string, line, column int) string {
+	lines := strings.Split(text, "\n")
+	if line >= len(lines) {
+		return text
+	}
+
+	result := strings.Join(lines[:line], "\n")
+	if len(result) > 0 {
+		result += "\n"
+	}
+	if column > len(lines[line]) {
+		result += lines[line]
+	} else {
+		result += lines[line][:column]
+	}
+	return result
+}
+
+func getKeywordContext(text string, m *d2ast.Map, line, column int) string {
+	if m == nil {
+		return ""
+	}
+	lines := strings.Split(text, "\n")
+
+	for _, n := range m.Nodes {
+		if n.MapKey == nil {
+			continue
+		}
+
+		var firstPart, lastPart string
+		var key *d2ast.KeyPath
+		if len(n.MapKey.Edges) > 0 {
+			key = n.MapKey.EdgeKey
+		} else {
+			key = n.MapKey.Key
+		}
+		if key != nil && len(key.Path) > 0 {
+			firstKey := key.Path[0].Unbox()
+			if !firstKey.IsUnquoted() {
+				continue
+			}
+			firstPart = firstKey.ScalarString()
+
+			pathLen := len(key.Path)
+			if pathLen > 1 {
+				lastKey := key.Path[pathLen-1].Unbox()
+				if lastKey.IsUnquoted() {
+					lastPart = lastKey.ScalarString()
+					_, isHolderLast := d2ast.ReservedKeywordHolders[lastPart]
+					if !isHolderLast {
+						_, isHolderLast = d2ast.CompositeReservedKeywords[lastPart]
+					}
+					keyRange := n.MapKey.Range
+					lineText := lines[keyRange.End.Line]
+					if isHolderLast && isAfterDot(lineText, column) {
+						return lastPart + "."
+					}
+				}
+			}
+		}
+		if _, isBoard := d2ast.BoardKeywords[firstPart]; isBoard {
+			firstPart = ""
+		}
+
+		_, isHolder := d2ast.ReservedKeywordHolders[firstPart]
+		if !isHolder {
+			_, isHolder = d2ast.CompositeReservedKeywords[firstPart]
+		}
+
+		// Check nested map
+		if n.MapKey.Value.Map != nil && isPositionInMap(line, column, n.MapKey.Value.Map) {
+			if nested := getKeywordContext(text, n.MapKey.Value.Map, line, column); nested != "" {
+				if isHolder {
+					// If we got a direct key completion from inside a holder's map,
+					// prefix it with the holder's name
+					if strings.HasSuffix(nested, ":") && !strings.Contains(nested, ".") {
+						return firstPart + "." + strings.TrimSuffix(nested, ":") + ":"
+					}
+				}
+				return nested
+			}
+			return firstPart
+		}
+
+		keyRange := n.MapKey.Range
+		if line != keyRange.End.Line {
+			continue
+		}
+
+		// 1) Skip if cursor is well above/below this key
+		if line < keyRange.Start.Line || line > keyRange.End.Line {
+			continue
+		}
+
+		// 2) If on the start line, skip if before the key
+		if line == keyRange.Start.Line && column < keyRange.Start.Column {
+			continue
+		}
+
+		// 3) If on the end line, allow up to keyRange.End.Column + 1
+		if line == keyRange.End.Line && column > keyRange.End.Column+1 {
+			continue
+		}
+
+		lineText := lines[keyRange.End.Line]
+
+		if isAfterColon(lineText, column) {
+			if key != nil && len(key.Path) > 1 {
+				if isHolder && (firstPart == "source-arrowhead" || firstPart == "target-arrowhead") {
+					return firstPart + "." + lastPart + ":"
+				}
+
+				_, isHolder := d2ast.ReservedKeywordHolders[lastPart]
+				if !isHolder {
+					return lastPart
+				}
+			}
+			return firstPart + ":"
+		}
+
+		if isAfterDot(lineText, column) && isHolder {
+			return firstPart
+		}
+	}
+
+	return ""
+}
+
+func isAfterDot(text string, pos int) bool {
+	return pos > 0 && pos <= len(text) && text[pos-1] == '.'
+}
+
+func isAfterColon(text string, pos int) bool {
+	if pos < 1 || pos > len(text) {
+		return false
+	}
+	i := pos - 1
+	for i >= 0 && unicode.IsSpace(rune(text[i])) {
+		i--
+	}
+	return i >= 0 && text[i] == ':'
+}
+
+func isPositionInMap(line, column int, m *d2ast.Map) bool {
+	if m == nil {
+		return false
+	}
+
+	mapRange := m.Range
+	if line < mapRange.Start.Line || line > mapRange.End.Line {
+		return false
+	}
+
+	if line == mapRange.Start.Line && column < mapRange.Start.Column {
+		return false
+	}
+	if line == mapRange.End.Line && column > mapRange.End.Column {
+		return false
+	}
+	return true
+}
+
+func getShapeCompletions() []CompletionItem {
+	items := make([]CompletionItem, 0, len(d2target.Shapes))
+	for _, shape := range d2target.Shapes {
+		item := CompletionItem{
+			Label:      shape,
+			Kind:       ShapeCompletion,
+			Detail:     "shape",
+			InsertText: shape,
+		}
+		items = append(items, item)
+	}
+	return items
+}
+
+func getValueCompletions(property string) []CompletionItem {
+	switch property {
+	case "opacity":
+		return []CompletionItem{{
+			Label:      "(number between 0.0 and 1.0)",
+			Kind:       KeywordCompletion,
+			Detail:     "e.g. 0.4",
+			InsertText: "",
+		}}
+	case "stroke-width":
+		return []CompletionItem{{
+			Label:      "(number between 0 and 15)",
+			Kind:       KeywordCompletion,
+			Detail:     "e.g. 2",
+			InsertText: "",
+		}}
+	case "font-size":
+		return []CompletionItem{{
+			Label:      "(number between 8 and 100)",
+			Kind:       KeywordCompletion,
+			Detail:     "e.g. 14",
+			InsertText: "",
+		}}
+	case "stroke-dash":
+		return []CompletionItem{{
+			Label:      "(number between 0 and 10)",
+			Kind:       KeywordCompletion,
+			Detail:     "e.g. 5",
+			InsertText: "",
+		}}
+	case "border-radius":
+		return []CompletionItem{{
+			Label:      "(number greater than or equal to 0)",
+			Kind:       KeywordCompletion,
+			Detail:     "e.g. 4",
+			InsertText: "",
+		}}
+	case "font-color", "stroke", "fill":
+		return []CompletionItem{{
+			Label:      "(color name or hex code)",
+			Kind:       KeywordCompletion,
+			Detail:     "e.g. blue, #ff0000",
+			InsertText: "",
+		}}
+	case "width", "height", "top", "left":
+		return []CompletionItem{{
+			Label:      "(pixels)",
+			Kind:       KeywordCompletion,
+			Detail:     "e.g. 400",
+			InsertText: "",
+		}}
+	}
+	return nil
+}
+
+func getStyleCompletions() []CompletionItem {
+	items := make([]CompletionItem, 0, len(d2ast.StyleKeywords))
+	for keyword := range d2ast.StyleKeywords {
+		item := CompletionItem{
+			Label:      keyword,
+			Kind:       StyleCompletion,
+			Detail:     "style property",
+			InsertText: keyword + ": ",
+		}
+		items = append(items, item)
+	}
+	return items
+}
+
+func getBooleanCompletions() []CompletionItem {
+	return []CompletionItem{
+		{
+			Label:      "true",
+			Kind:       KeywordCompletion,
+			Detail:     "boolean",
+			InsertText: "true",
+		},
+		{
+			Label:      "false",
+			Kind:       KeywordCompletion,
+			Detail:     "boolean",
+			InsertText: "false",
+		},
+	}
+}
+
+func getFillPatternCompletions() []CompletionItem {
+	items := make([]CompletionItem, 0, len(d2ast.FillPatterns))
+	for _, pattern := range d2ast.FillPatterns {
+		item := CompletionItem{
+			Label:      pattern,
+			Kind:       KeywordCompletion,
+			Detail:     "fill pattern",
+			InsertText: pattern,
+		}
+		items = append(items, item)
+	}
+	return items
+}
+
+func getTextTransformCompletions() []CompletionItem {
+	items := make([]CompletionItem, 0, len(d2ast.TextTransforms))
+	for _, transform := range d2ast.TextTransforms {
+		item := CompletionItem{
+			Label:      transform,
+			Kind:       KeywordCompletion,
+			Detail:     "text transform",
+			InsertText: transform,
+		}
+		items = append(items, item)
+	}
+	return items
+}
+
+func isOnEmptyLine(text string, line int) bool {
+	lines := strings.Split(text, "\n")
+	if line >= len(lines) {
+		return true
+	}
+
+	return strings.TrimSpace(lines[line]) == ""
+}
+
+func getLabelCompletions() []CompletionItem {
+	return []CompletionItem{{
+		Label:      "near",
+		Kind:       StyleCompletion,
+		Detail:     "label position",
+		InsertText: "near: ",
+	}}
+}
+
+func getNearCompletions() []CompletionItem {
+	items := make([]CompletionItem, 0, len(d2ast.LabelPositionsArray)+1)
+
+	items = append(items, CompletionItem{
+		Label:      "(object ID)",
+		Kind:       KeywordCompletion,
+		Detail:     "e.g. container.inner_shape",
+		InsertText: "",
+	})
+
+	for _, pos := range d2ast.LabelPositionsArray {
+		item := CompletionItem{
+			Label:      pos,
+			Kind:       KeywordCompletion,
+			Detail:     "label position",
+			InsertText: pos,
+		}
+		items = append(items, item)
+	}
+	return items
+}
+
+func getTooltipCompletions() []CompletionItem {
+	return []CompletionItem{
+		{
+			Label:      "(markdown)",
+			Kind:       KeywordCompletion,
+			Detail:     "markdown formatted text",
+			InsertText: "|md\n  # Tooltip\n  Hello world\n|",
+		},
+	}
+}
+
+func getIconCompletions() []CompletionItem {
+	return []CompletionItem{
+		{
+			Label:      "(URL, e.g. https://icons.terrastruct.com/xyz.svg)",
+			Kind:       KeywordCompletion,
+			Detail:     "icon URL",
+			InsertText: "https://icons.terrastruct.com/essentials%2F073-add.svg",
+		},
+	}
+}
+
+func getDirectionCompletions() []CompletionItem {
+	directions := []string{"up", "down", "right", "left"}
+	items := make([]CompletionItem, len(directions))
+	for i, dir := range directions {
+		items[i] = CompletionItem{
+			Label:      dir,
+			Kind:       KeywordCompletion,
+			Detail:     "direction",
+			InsertText: dir,
+		}
+	}
+	return items
+}
+
+func getArrowheadShapeCompletions() []CompletionItem {
+	arrowheads := []string{
+		"triangle",
+		"arrow",
+		"diamond",
+		"circle",
+		"cf-one", "cf-one-required",
+		"cf-many", "cf-many-required",
+	}
+
+	items := make([]CompletionItem, len(arrowheads))
+	details := map[string]string{
+		"triangle":         "default",
+		"arrow":            "like triangle but pointier",
+		"cf-one":           "crows foot one",
+		"cf-one-required":  "crows foot one (required)",
+		"cf-many":          "crows foot many",
+		"cf-many-required": "crows foot many (required)",
+	}
+
+	for i, shape := range arrowheads {
+		detail := details[shape]
+		if detail == "" {
+			detail = "arrowhead shape"
+		}
+		items[i] = CompletionItem{
+			Label:      shape,
+			Kind:       ShapeCompletion,
+			Detail:     detail,
+			InsertText: shape,
+		}
+	}
+	return items
+}
+
+func getArrowheadCompletions() []CompletionItem {
+	completions := []string{
+		"shape",
+		"label",
+		"style.filled",
+	}
+
+	items := make([]CompletionItem, len(completions))
+
+	for i, shape := range completions {
+		items[i] = CompletionItem{
+			Label:      shape,
+			Kind:       ShapeCompletion,
+			InsertText: shape,
+		}
+	}
+	return items
+}

d2lsp/completion_test.go

@@ -0,0 +1,421 @@
+package d2lsp
+
+import (
+	"testing"
+)
+
+func TestGetCompletionItems(t *testing.T) {
+	tests := []struct {
+		name    string
+		text    string
+		line    int
+		column  int
+		want    []CompletionItem
+		wantErr bool
+	}{
+		{
+			name:   "style dot suggestions",
+			text:   "a.style.",
+			line:   0,
+			column: 8,
+			want:   getStyleCompletions(),
+		},
+		{
+			name: "style map suggestions",
+			text: `a: {
+  style.
+}
+`,
+			line:   1,
+			column: 8,
+			want:   getStyleCompletions(),
+		},
+		{
+			name: "3d style map suggestions",
+			text: `a.style: {
+  3d:
+}
+`,
+			line:   1,
+			column: 5,
+			want:   getBooleanCompletions(),
+		},
+		{
+			name: "fill pattern style map suggestions",
+			text: `a.style: {
+  fill-pattern:
+}
+`,
+			line:   1,
+			column: 15,
+			want:   getFillPatternCompletions(),
+		},
+		{
+			name: "opacity style map suggestions",
+			text: `a.style: {
+  opacity:
+}
+`,
+			line:   1,
+			column: 10,
+			want:   getValueCompletions("opacity"),
+		},
+		{
+			name:   "width dot",
+			text:   `a.width:`,
+			line:   0,
+			column: 8,
+			want:   getValueCompletions("width"),
+		},
+		{
+			name: "layer shape",
+			text: `a
+
+layers: {
+  hey: {
+    go: {
+      shape:
+    }
+  }
+}
+`,
+			line:   5,
+			column: 12,
+			want:   getShapeCompletions(),
+		},
+		{
+			name:   "stroke width value",
+			text:   `a.style.stroke-width: 1`,
+			line:   0,
+			column: 23,
+			want:   nil,
+		},
+		{
+			name: "no style suggestions",
+			text: `a.style:
+`,
+			line:   0,
+			column: 8,
+			want:   nil,
+		},
+		{
+			name:   "style property suggestions",
+			text:   "a -> b: { style. }",
+			line:   0,
+			column: 16,
+			want:   getStyleCompletions(),
+		},
+		{
+			name:   "style.opacity value hint",
+			text:   "a -> b: { style.opacity: }",
+			line:   0,
+			column: 24,
+			want:   getValueCompletions("opacity"),
+		},
+		{
+			name:   "fill pattern completions",
+			text:   "a -> b: { style.fill-pattern: }",
+			line:   0,
+			column: 29,
+			want:   getFillPatternCompletions(),
+		},
+		{
+			name:   "text transform completions",
+			text:   "a -> b: { style.text-transform: }",
+			line:   0,
+			column: 31,
+			want:   getTextTransformCompletions(),
+		},
+		{
+			name:   "boolean property completions",
+			text:   "a -> b: { style.shadow: }",
+			line:   0,
+			column: 23,
+			want:   getBooleanCompletions(),
+		},
+		{
+			name:   "near position completions",
+			text:   "a -> b: { label.near: }",
+			line:   0,
+			column: 21,
+			want:   getNearCompletions(),
+		},
+		{
+			name:   "direction completions",
+			text:   "a -> b: { direction: }",
+			line:   0,
+			column: 20,
+			want:   getDirectionCompletions(),
+		},
+		{
+			name:   "icon url completions",
+			text:   "a -> b: { icon: }",
+			line:   0,
+			column: 15,
+			want:   getIconCompletions(),
+		},
+		{
+			name:   "icon dot url completions",
+			text:   "a.icon:",
+			line:   0,
+			column: 7,
+			want:   getIconCompletions(),
+		},
+		{
+			name:   "icon near completions",
+			text:   "a -> b: { icon.near: }",
+			line:   0,
+			column: 20,
+			want:   getNearCompletions(),
+		},
+		{
+			name: "icon map",
+			text: `a.icon: {
+  # here
+}`,
+			line:   1,
+			column: 2,
+			want:   nil,
+		},
+		{
+			name:   "icon flat dot",
+			text:   `a.icon.`,
+			line:   0,
+			column: 7,
+			want:   getLabelCompletions(),
+		},
+		{
+			name:   "label flat dot",
+			text:   `a.label.`,
+			line:   0,
+			column: 8,
+			want:   getLabelCompletions(),
+		},
+		{
+			name:   "arrowhead completions - dot syntax",
+			text:   "a -> b: { source-arrowhead. }",
+			line:   0,
+			column: 27,
+			want:   getArrowheadCompletions(),
+		},
+		{
+			name:   "arrowhead completions - colon syntax",
+			text:   "a -> b: { source-arrowhead: }",
+			line:   0,
+			column: 27,
+			want:   nil,
+		},
+		{
+			name: "arrowhead completions - map syntax",
+			text: `a -> b: {
+  source-arrowhead: {
+    # here
+  }
+}`,
+			line:   2,
+			column: 4,
+			want:   getArrowheadCompletions(),
+		},
+		{
+			name:   "arrowhead shape completions - flat dot syntax",
+			text:   "(a -> b)[0].source-arrowhead.shape:",
+			line:   0,
+			column: 35,
+			want:   getArrowheadShapeCompletions(),
+		},
+		{
+			name:   "arrowhead shape completions - dot syntax",
+			text:   "a -> b: { source-arrowhead.shape: }",
+			line:   0,
+			column: 33,
+			want:   getArrowheadShapeCompletions(),
+		},
+		{
+			name:   "arrowhead shape completions - map syntax",
+			text:   "a -> b: { source-arrowhead: { shape: } }",
+			line:   0,
+			column: 36,
+			want:   getArrowheadShapeCompletions(),
+		},
+		{
+			name:   "width value hint",
+			text:   "a -> b: { width: }",
+			line:   0,
+			column: 16,
+			want:   getValueCompletions("width"),
+		},
+		{
+			name:   "height value hint",
+			text:   "a -> b: { height: }",
+			line:   0,
+			column: 17,
+			want:   getValueCompletions("height"),
+		},
+		{
+			name:   "tooltip markdown template",
+			text:   "a -> b: { tooltip: }",
+			line:   0,
+			column: 18,
+			want:   getTooltipCompletions(),
+		},
+		{
+			name:   "tooltip dot markdown template",
+			text:   "a.tooltip:",
+			line:   0,
+			column: 10,
+			want:   getTooltipCompletions(),
+		},
+		{
+			name:   "shape dot suggestions",
+			text:   "a.shape:",
+			line:   0,
+			column: 8,
+			want:   getShapeCompletions(),
+		},
+		{
+			name:   "shape suggestions",
+			text:   "a -> b: { shape: }",
+			line:   0,
+			column: 16,
+			want:   getShapeCompletions(),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := GetCompletionItems(tt.text, tt.line, tt.column)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("GetCompletionItems() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+
+			if len(got) != len(tt.want) {
+				t.Errorf("GetCompletionItems() got %d completions, want %d", len(got), len(tt.want))
+				return
+			}
+
+			// Create maps for easy comparison
+			gotMap := make(map[string]CompletionItem)
+			wantMap := make(map[string]CompletionItem)
+			for _, item := range got {
+				gotMap[item.Label] = item
+			}
+			for _, item := range tt.want {
+				wantMap[item.Label] = item
+			}
+
+			// Check that each completion exists and has correct properties
+			for label, wantItem := range wantMap {
+				gotItem, exists := gotMap[label]
+				if !exists {
+					t.Errorf("missing completion for %q", label)
+					continue
+				}
+				if gotItem.Kind != wantItem.Kind {
+					t.Errorf("completion %q Kind = %v, want %v", label, gotItem.Kind, wantItem.Kind)
+				}
+				if gotItem.Detail != wantItem.Detail {
+					t.Errorf("completion %q Detail = %v, want %v", label, gotItem.Detail, wantItem.Detail)
+				}
+				if gotItem.InsertText != wantItem.InsertText {
+					t.Errorf("completion %q InsertText = %v, want %v", label, gotItem.InsertText, wantItem.InsertText)
+				}
+			}
+		})
+	}
+}
+
+// Helper function to compare CompletionItem slices
+func equalCompletions(a, b []CompletionItem) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i].Label != b[i].Label ||
+			a[i].Kind != b[i].Kind ||
+			a[i].Detail != b[i].Detail ||
+			a[i].InsertText != b[i].InsertText {
+			return false
+		}
+	}
+	return true
+}
+
+func TestGetArrowheadShapeCompletions(t *testing.T) {
+	got := getArrowheadShapeCompletions()
+
+	expectedLabels := []string{
+		"triangle", "arrow", "diamond", "circle",
+		"cf-one", "cf-one-required",
+		"cf-many", "cf-many-required",
+	}
+
+	if len(got) != len(expectedLabels) {
+		t.Errorf("getArrowheadShapeCompletions() returned %d items, want %d", len(got), len(expectedLabels))
+		return
+	}
+
+	for i, label := range expectedLabels {
+		if got[i].Label != label {
+			t.Errorf("completion[%d].Label = %v, want %v", i, got[i].Label, label)
+		}
+		if got[i].Kind != ShapeCompletion {
+			t.Errorf("completion[%d].Kind = %v, want ShapeCompletion", i, got[i].Kind)
+		}
+		if got[i].InsertText != label {
+			t.Errorf("completion[%d].InsertText = %v, want %v", i, got[i].InsertText, label)
+		}
+	}
+}
+
+func TestGetValueCompletions(t *testing.T) {
+	tests := []struct {
+		property   string
+		wantLabel  string
+		wantDetail string
+	}{
+		{
+			property:   "opacity",
+			wantLabel:  "(number between 0.0 and 1.0)",
+			wantDetail: "e.g. 0.4",
+		},
+		{
+			property:   "stroke-width",
+			wantLabel:  "(number between 0 and 15)",
+			wantDetail: "e.g. 2",
+		},
+		{
+			property:   "font-size",
+			wantLabel:  "(number between 8 and 100)",
+			wantDetail: "e.g. 14",
+		},
+		{
+			property:   "width",
+			wantLabel:  "(pixels)",
+			wantDetail: "e.g. 400",
+		},
+		{
+			property:   "stroke",
+			wantLabel:  "(color name or hex code)",
+			wantDetail: "e.g. blue, #ff0000",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.property, func(t *testing.T) {
+			got := getValueCompletions(tt.property)
+			if len(got) != 1 {
+				t.Fatalf("getValueCompletions(%s) returned %d items, want 1", tt.property, len(got))
+			}
+			if got[0].Label != tt.wantLabel {
+				t.Errorf("completion.Label = %v, want %v", got[0].Label, tt.wantLabel)
+			}
+			if got[0].Detail != tt.wantDetail {
+				t.Errorf("completion.Detail = %v, want %v", got[0].Detail, tt.wantDetail)
+			}
+			if got[0].InsertText != "" {
+				t.Errorf("completion.InsertText = %v, want empty string", got[0].InsertText)
+			}
+		})
+	}
+}