List/range support

internal/topdata/native.go

@@ -28,6 +28,7 @@ type nativeDataset struct {
 	OutputName       string
 	Spec             datasetTextSpec
 	Columns          []string
+	ValueEncodings   map[string]project.TopDataValueEncodingConfig
 	CompareReference bool
 }
 
@@ -236,6 +237,7 @@ func buildNativeUnchecked(p *project.Project, opts NativeBuildOptions, progress
 	if err != nil {
 		return BuildResult{}, err
 	}
+	datasets = applyTopDataValueEncodings(datasets, p.Config.TopData.ValueEncodings)
 	registryDatasets, err := collectGeneratedRegistryDatasets(dataDir)
 	if err != nil {
 		return BuildResult{}, err
@@ -406,6 +408,25 @@ func buildNativeUnchecked(p *project.Project, opts NativeBuildOptions, progress
 	}, nil
 }
 
+func applyTopDataValueEncodings(datasets []nativeDataset, encodings []project.TopDataValueEncodingConfig) []nativeDataset {
+	if len(encodings) == 0 {
+		return datasets
+	}
+	out := append([]nativeDataset(nil), datasets...)
+	for index := range out {
+		for _, encoding := range encodings {
+			if filepath.ToSlash(strings.TrimSpace(encoding.Dataset)) != out[index].Name {
+				continue
+			}
+			if out[index].ValueEncodings == nil {
+				out[index].ValueEncodings = map[string]project.TopDataValueEncodingConfig{}
+			}
+			out[index].ValueEncodings[strings.ToLower(strings.TrimSpace(encoding.Column))] = encoding
+		}
+	}
+	return out
+}
+
 func nativeCompileGroup(datasetName string) string {
 	head, _, ok := strings.Cut(datasetName, "/")
 	if !ok {
@@ -3694,6 +3715,15 @@ func (r *valueResolver) resolveValue(row map[string]any, field string, value any
 
 	switch typed := value.(type) {
 	case map[string]any:
+		if encoding, ok := r.valueEncodingForField(field); ok {
+			if _, hasList := typed["list"]; hasList {
+				value, err := encodeConfiguredValueList(typed, encoding)
+				if err != nil {
+					return tlkCompiledValue{}, fmt.Errorf("field %s: %w", field, err)
+				}
+				return tlkCompiledValue{Value: value}, nil
+			}
+		}
 		if refID, ok := typed["id"]; ok {
 			if refKey, ok := refID.(string); ok && strings.Contains(refKey, ":") {
 				id, ok := r.keyToID[refKey]
@@ -3750,6 +3780,109 @@ func (r *valueResolver) resolveValue(row map[string]any, field string, value any
 	}
 }
 
+func (r *valueResolver) valueEncodingForField(field string) (project.TopDataValueEncodingConfig, bool) {
+	if len(r.dataset.ValueEncodings) == 0 {
+		return project.TopDataValueEncodingConfig{}, false
+	}
+	encoding, ok := r.dataset.ValueEncodings[strings.ToLower(strings.TrimSpace(field))]
+	return encoding, ok
+}
+
+func encodeConfiguredValueList(obj map[string]any, encoding project.TopDataValueEncodingConfig) (string, error) {
+	if strings.TrimSpace(encoding.Mode) != "packed_hex_list" {
+		return "", fmt.Errorf("unsupported value encoding mode %q", encoding.Mode)
+	}
+	for key := range obj {
+		if key != "list" {
+			return "", fmt.Errorf("list encoding object contains unsupported key %q", key)
+		}
+	}
+	rawList, ok := obj["list"].([]any)
+	if !ok {
+		return "", fmt.Errorf("list must be an array")
+	}
+	values := make([]int, 0, len(rawList))
+	for _, raw := range rawList {
+		expanded, err := expandConfiguredValueListItem(raw, encoding)
+		if err != nil {
+			return "", err
+		}
+		values = append(values, expanded...)
+	}
+	if len(values) == 0 {
+		return "", nil
+	}
+	var builder strings.Builder
+	builder.WriteString("0x")
+	for _, value := range values {
+		builder.WriteString(fmt.Sprintf("%0*X", encoding.HexWidth, value))
+	}
+	return builder.String(), nil
+}
+
+func expandConfiguredValueListItem(raw any, encoding project.TopDataValueEncodingConfig) ([]int, error) {
+	if obj, ok := raw.(map[string]any); ok {
+		rawRange, ok := obj["range"]
+		if !ok {
+			return nil, fmt.Errorf("list object item must contain range")
+		}
+		if len(obj) != 1 {
+			return nil, fmt.Errorf("range item contains unsupported keys")
+		}
+		rangeList, ok := rawRange.([]any)
+		if !ok || len(rangeList) != 2 {
+			return nil, fmt.Errorf("range must be an array with two values")
+		}
+		start, err := parseConfiguredListValue(rangeList[0], encoding)
+		if err != nil {
+			return nil, err
+		}
+		end, err := parseConfiguredListValue(rangeList[1], encoding)
+		if err != nil {
+			return nil, err
+		}
+		if end < start {
+			return nil, fmt.Errorf("range %d-%d ends before it starts", start, end)
+		}
+		values := make([]int, 0, end-start+1)
+		for value := start; value <= end; value++ {
+			values = append(values, value)
+		}
+		return values, nil
+	}
+	value, err := parseConfiguredListValue(raw, encoding)
+	if err != nil {
+		return nil, err
+	}
+	return []int{value}, nil
+}
+
+func parseConfiguredListValue(raw any, encoding project.TopDataValueEncodingConfig) (int, error) {
+	var value int
+	switch typed := raw.(type) {
+	case int:
+		value = typed
+	case float64:
+		if typed != float64(int(typed)) {
+			return 0, fmt.Errorf("list value %v must be an integer", typed)
+		}
+		value = int(typed)
+	case string:
+		trimmed := strings.TrimSpace(typed)
+		parsed, err := strconv.Atoi(trimmed)
+		if err != nil {
+			return 0, fmt.Errorf("list value %q must be numeric", typed)
+		}
+		value = parsed
+	default:
+		return 0, fmt.Errorf("list value %v must be numeric", raw)
+	}
+	if value < encoding.Min || value > encoding.Max {
+		return 0, fmt.Errorf("value %d outside range %d-%d", value, encoding.Min, encoding.Max)
+	}
+	return value, nil
+}
+
 func (r *valueResolver) resolveLiteralFeatObject(row map[string]any, field string, value any) (string, bool) {
 	if r.dataset.Name != "feat" {
 		return "", false