locale_merge.go

package internal

func mergeUISection(base, over UISection) UISection {
	return UISection{
		UIStrings:       mergeUIStrings(base.UIStrings, over.UIStrings),
		EmploymentTypes: mergeStringMap(base.EmploymentTypes, over.EmploymentTypes),
		EndDate:         mergeStringMap(base.EndDate, over.EndDate),
	}
}

func mergeUIStrings(base, over UIStrings) UIStrings {
	out := base
	for _, p := range []struct{ dst, src *string }{
		{&out.Contact, &over.Contact},
		{&out.Socials, &over.Socials},
		{&out.LanguagesSection, &over.LanguagesSection},
		{&out.About, &over.About},
		{&out.Experience, &over.Experience},
		{&out.PersonalProjects, &over.PersonalProjects},
		{&out.Education, &over.Education},
		{&out.SavePDF, &over.SavePDF},
		{&out.Remote, &over.Remote},
		{&out.Email, &over.Email},
		{&out.Phone, &over.Phone},
		{&out.Location, &over.Location},
	} {
		if *p.src != "" {
			*p.dst = *p.src
		}
	}
	return out
}

func mergeStringMap(base, over map[string]string) map[string]string {
	if len(base) == 0 && len(over) == 0 {
		return nil
	}
	out := make(map[string]string, len(base)+len(over))
	for k, v := range base {
		out[k] = v
	}
	for k, v := range over {
		if v == "" {
			continue
		}
		out[k] = v
	}
	return out
}

func overlay[T any](p *T, base T) T {
	if p == nil {
		return base
	}
	return *p
}

// overlaySlice mirrors overlay for slices: nil pointer keeps base, an explicit
// (possibly empty) slice replaces it.
func overlaySlice[T any](p *[]T, base []T) []T {
	if p == nil {
		return base
	}
	return *p
}

func mergeExperienceEntry(base Experience, loc LocalExperience) Experience {
	return Experience{
		Company:      overlay(loc.Company, base.Company),
		Position:     overlay(loc.Position, base.Position),
		Type:         overlay(loc.Type, base.Type),
		StartDate:    overlay(loc.StartDate, base.StartDate),
		EndDate:      overlay(loc.EndDate, base.EndDate),
		Location:     overlay(loc.Location, base.Location),
		IsRemote:     overlay(loc.IsRemote, base.IsRemote),
		Description:  overlaySlice(loc.Description, base.Description),
		Achievements: overlaySlice(loc.Achievements, base.Achievements),
		Skills:       overlaySlice(loc.Skills, base.Skills),
	}
}

func mergePersonalProjectEntry(base PersonalProject, loc LocalPersonalProject) PersonalProject {
	return PersonalProject{
		Name:        overlay(loc.Name, base.Name),
		Link:        overlay(loc.Link, base.Link),
		StartDate:   overlay(loc.StartDate, base.StartDate),
		EndDate:     overlay(loc.EndDate, base.EndDate),
		Description: overlaySlice(loc.Description, base.Description),
		Skills:      overlaySlice(loc.Skills, base.Skills),
	}
}

func mergeEducationEntry(base Education, loc LocalEducation) Education {
	return Education{
		Institution: overlay(loc.Institution, base.Institution),
		Degree:      overlay(loc.Degree, base.Degree),
		StartDate:   overlay(loc.StartDate, base.StartDate),
		EndDate:     overlay(loc.EndDate, base.EndDate),
		Location:    overlay(loc.Location, base.Location),
	}
}

// mergeIndexed merges per-index overlays onto a base list. If overlays is empty
// the base is returned unchanged. Where a base entry is missing the zero value
// is used as the merge target so a locale can still introduce a new row.
func mergeIndexed[B, O any](base []B, overlays []O, merge func(B, O) B) []B {
	if len(overlays) == 0 {
		return base
	}
	n := len(base)
	if len(overlays) > n {
		n = len(overlays)
	}
	out := make([]B, n)
	for i := 0; i < n; i++ {
		var b B
		if i < len(base) {
			b = base[i]
		}
		if i < len(overlays) {
			out[i] = merge(b, overlays[i])
		} else {
			out[i] = b
		}
	}
	return out
}

func mergeExperienceList(base []Experience, overlays []LocalExperience) []Experience {
	return mergeIndexed(base, overlays, mergeExperienceEntry)
}

func mergePersonalProjectsList(base []PersonalProject, overlays []LocalPersonalProject) []PersonalProject {
	return mergeIndexed(base, overlays, mergePersonalProjectEntry)
}

func mergeEducationList(base []Education, overlays []LocalEducation) []Education {
	return mergeIndexed(base, overlays, mergeEducationEntry)
}