Merge pull request #2590 from alixander/customize-mono-font

customize mono font

Author: alixander

ci/release/changelogs/next.md

@@ -6,6 +6,7 @@
 - markdown, latex, and code can be used as edge labels [#2545](https://github.com/terrastruct/d2/pull/2545)
 - border-x label positioning functionality [#2549](https://github.com/terrastruct/d2/pull/2549)
 - tooltips with `near` set always show even without hover [#2564](https://github.com/terrastruct/d2/pull/2564)
+- CLI supports customizing monospace fonts with `--font-mono`, `--font-mono-bold`, `--font-mono-italic`, and `--font-mono-semibold` flags [#2590](https://github.com/terrastruct/d2/pull/2590)
 
 #### Improvements 🧹
 

ci/release/template/man/d2.1

@@ -105,6 +105,21 @@ Path to .ttf file to use for the italic font. If none provided, Source Sans Pro
 .It Fl -font-bold
 Path to .ttf file to use for the bold font. If none provided, Source Sans Pro Bold is used
 .Ns .
+.It Fl -font-semibold
+Path to .ttf file to use for the semibold font. If none provided, Source Sans Pro Semibold is used
+.Ns .
+.It Fl -font-mono
+Path to .ttf file to use for the monospace font. If none provided, Source Code Pro Regular is used
+.Ns .
+.It Fl -font-mono-bold
+Path to .ttf file to use for the monospace bold font. If none provided, Source Code Pro Bold is used
+.Ns .
+.It Fl -font-mono-italic
+Path to .ttf file to use for the monospace italic font. If none provided, Source Code Pro Italic is used
+.Ns .
+.It Fl -font-mono-semibold
+Path to .ttf file to use for the monospace semibold font. If none provided, Source Code Pro Semibold is used
+.Ns .
 .It Fl -pad Ar 100
 Pixels padded around the rendered diagram
 .Ns .
@@ -210,6 +225,14 @@ See --font-italic flag.
 See --font-bold flag.
 .It Ev Sy D2_FONT_SEMIBOLD
 See --font-semibold flag.
+.It Ev Sy D2_FONT_MONO
+See --font-mono flag.
+.It Ev Sy D2_FONT_MONO_BOLD
+See --font-mono-bold flag.
+.It Ev Sy D2_FONT_MONO_ITALIC
+See --font-mono-italic flag.
+.It Ev Sy D2_FONT_MONO_SEMIBOLD
+See --font-mono-semibold flag.
 .It Ev Sy D2_ANIMATE_INTERVAL
 See --animate-interval flag.
 .It Ev Sy D2_TIMEOUT

d2chaos/d2chaos_test.go

@@ -119,15 +119,15 @@ func test(t *testing.T, textPath, text string) {
 		ruler, err := textmeasure.NewRuler()
 		assert.Nil(t, err)
 
-		err = g.SetDimensions(nil, ruler, nil)
+		err = g.SetDimensions(nil, ruler, nil, nil)
 		assert.Nil(t, err)
 
 		err = d2dagrelayout.DefaultLayout(ctx, g)
 		if err != nil {
 			t.Fatal(err)
 		}
 
-		_, err = d2exporter.Export(ctx, g, nil)
+		_, err = d2exporter.Export(ctx, g, nil, nil)
 		if err != nil {
 			t.Fatal(err)
 		}

d2cli/main.go

@@ -125,6 +125,10 @@ func Run(ctx context.Context, ms *xmain.State) (err error) {
 	fontItalicFlag := ms.Opts.String("D2_FONT_ITALIC", "font-italic", "", "", "path to .ttf file to use for the italic font. If none provided, Source Sans Pro Regular-Italic is used.")
 	fontBoldFlag := ms.Opts.String("D2_FONT_BOLD", "font-bold", "", "", "path to .ttf file to use for the bold font. If none provided, Source Sans Pro Bold is used.")
 	fontSemiboldFlag := ms.Opts.String("D2_FONT_SEMIBOLD", "font-semibold", "", "", "path to .ttf file to use for the semibold font. If none provided, Source Sans Pro Semibold is used.")
+	fontMonoFlag := ms.Opts.String("D2_FONT_MONO", "font-mono", "", "", "path to .ttf file to use for the monospace font. If none provided, Source Code Pro Regular is used.")
+	fontMonoBoldFlag := ms.Opts.String("D2_FONT_MONO_BOLD", "font-mono-bold", "", "", "path to .ttf file to use for the monospace bold font. If none provided, Source Code Pro Bold is used.")
+	fontMonoItalicFlag := ms.Opts.String("D2_FONT_MONO_ITALIC", "font-mono-italic", "", "", "path to .ttf file to use for the monospace italic font. If none provided, Source Code Pro Italic is used.")
+	fontMonoSemiboldFlag := ms.Opts.String("D2_FONT_MONO_SEMIBOLD", "font-mono-semibold", "", "", "path to .ttf file to use for the monospace semibold font. If none provided, Source Code Pro Semibold is used.")
 
 	checkFlag, err := ms.Opts.Bool("D2_CHECK", "check", "", false, "check that the specified files are formatted correctly.")
 	if err != nil {
@@ -167,7 +171,7 @@ func Run(ctx context.Context, ms *xmain.State) (err error) {
 		return nil
 	}
 
-	fontFamily, err := loadFonts(ms, *fontRegularFlag, *fontItalicFlag, *fontBoldFlag, *fontSemiboldFlag)
+	fontFamily, monoFontFamily, err := loadFonts(ms, *fontRegularFlag, *fontItalicFlag, *fontBoldFlag, *fontSemiboldFlag, *fontMonoFlag, *fontMonoBoldFlag, *fontMonoItalicFlag, *fontMonoSemiboldFlag)
 	if err != nil {
 		return xmain.UsageErrorf("failed to load specified fonts: %v", err)
 	}
@@ -366,6 +370,7 @@ func Run(ctx context.Context, ms *xmain.State) (err error) {
 			forceAppendix:   *forceAppendixFlag,
 			pw:              pw,
 			fontFamily:      fontFamily,
+			monoFontFamily:  monoFontFamily,
 			outputFormat:    outputFormat,
 			asciiMode:       *asciiModeFlag,
 		})
@@ -398,7 +403,7 @@ func Run(ctx context.Context, ms *xmain.State) (err error) {
 	ctx, cancel := timelib.WithTimeout(ctx, time.Minute*2)
 	defer cancel()
 
-	_, written, err := compile(ctx, ms, plugins, nil, layoutFlag, renderOpts, fontFamily, *animateIntervalFlag, inputPath, outputPath, boardPath, noChildren, *bundleFlag, *forceAppendixFlag, pw.Page, outputFormat, *asciiModeFlag)
+	_, written, err := compile(ctx, ms, plugins, nil, layoutFlag, renderOpts, fontFamily, monoFontFamily, *animateIntervalFlag, inputPath, outputPath, boardPath, noChildren, *bundleFlag, *forceAppendixFlag, pw.Page, outputFormat, *asciiModeFlag)
 	if err != nil {
 		if written {
 			return fmt.Errorf("failed to fully compile (partial render written) %s: %w", ms.HumanPath(inputPath), err)
@@ -473,7 +478,7 @@ func RouterResolver(ctx context.Context, ms *xmain.State, plugins []d2plugin.Plu
 	}
 }
 
-func compile(ctx context.Context, ms *xmain.State, plugins []d2plugin.Plugin, fs fs.FS, layout *string, renderOpts d2svg.RenderOpts, fontFamily *d2fonts.FontFamily, animateInterval int64, inputPath, outputPath string, boardPath []string, noChildren, bundle, forceAppendix bool, page playwright.Page, ext exportExtension, asciiMode string) (_ []byte, written bool, _ error) {
+func compile(ctx context.Context, ms *xmain.State, plugins []d2plugin.Plugin, fs fs.FS, layout *string, renderOpts d2svg.RenderOpts, fontFamily *d2fonts.FontFamily, monoFontFamily *d2fonts.FontFamily, animateInterval int64, inputPath, outputPath string, boardPath []string, noChildren, bundle, forceAppendix bool, page playwright.Page, ext exportExtension, asciiMode string) (_ []byte, written bool, _ error) {
 	// Use ELK layout for ascii outputs when layout is dagre or unspecified
 	if ext == TXT {
 		if layout == nil || *layout == "dagre" {
@@ -502,6 +507,7 @@ func compile(ctx context.Context, ms *xmain.State, plugins []d2plugin.Plugin, fs
 	opts := &d2lib.CompileOptions{
 		Ruler:          ruler,
 		FontFamily:     fontFamily,
+		MonoFontFamily: monoFontFamily,
 		InputPath:      inputPath,
 		LayoutResolver: LayoutResolver(ctx, ms, plugins),
 		Layout:         layout,
@@ -1301,43 +1307,90 @@ func loadFont(ms *xmain.State, path string) ([]byte, error) {
 	return ttf, nil
 }
 
-func loadFonts(ms *xmain.State, pathToRegular, pathToItalic, pathToBold, pathToSemibold string) (*d2fonts.FontFamily, error) {
-	if pathToRegular == "" && pathToItalic == "" && pathToBold == "" && pathToSemibold == "" {
-		return nil, nil
+func loadFonts(ms *xmain.State, pathToRegular, pathToItalic, pathToBold, pathToSemibold, pathToMono, pathToMonoBold, pathToMonoItalic, pathToMonoSemibold string) (*d2fonts.FontFamily, *d2fonts.FontFamily, error) {
+	if pathToRegular == "" && pathToItalic == "" && pathToBold == "" && pathToSemibold == "" &&
+		pathToMono == "" && pathToMonoBold == "" && pathToMonoItalic == "" && pathToMonoSemibold == "" {
+		return nil, nil, nil
 	}
 
 	var regularTTF []byte
 	var italicTTF []byte
 	var boldTTF []byte
 	var semiboldTTF []byte
+	var monoTTF []byte
+	var monoBoldTTF []byte
+	var monoItalicTTF []byte
+	var monoSemiboldTTF []byte
 
 	var err error
 	if pathToRegular != "" {
 		regularTTF, err = loadFont(ms, pathToRegular)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 	}
 	if pathToItalic != "" {
 		italicTTF, err = loadFont(ms, pathToItalic)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 	}
 	if pathToBold != "" {
 		boldTTF, err = loadFont(ms, pathToBold)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 	}
 	if pathToSemibold != "" {
 		semiboldTTF, err = loadFont(ms, pathToSemibold)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
+		}
+	}
+
+	if pathToMono != "" {
+		monoTTF, err = loadFont(ms, pathToMono)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+	if pathToMonoBold != "" {
+		monoBoldTTF, err = loadFont(ms, pathToMonoBold)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+	if pathToMonoItalic != "" {
+		monoItalicTTF, err = loadFont(ms, pathToMonoItalic)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+	if pathToMonoSemibold != "" {
+		monoSemiboldTTF, err = loadFont(ms, pathToMonoSemibold)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+
+	var fontFamily *d2fonts.FontFamily
+	var monoFontFamily *d2fonts.FontFamily
+
+	if pathToRegular != "" || pathToItalic != "" || pathToBold != "" || pathToSemibold != "" {
+		fontFamily, err = d2fonts.AddFontFamily("custom", regularTTF, italicTTF, boldTTF, semiboldTTF)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+
+	if pathToMono != "" || pathToMonoBold != "" || pathToMonoItalic != "" || pathToMonoSemibold != "" {
+		monoFontFamily, err = d2fonts.AddFontFamily("customMono", monoTTF, monoItalicTTF, monoBoldTTF, monoSemiboldTTF)
+		if err != nil {
+			return nil, nil, err
 		}
 	}
 
-	return d2fonts.AddFontFamily("custom", regularTTF, italicTTF, boldTTF, semiboldTTF)
+	return fontFamily, monoFontFamily, nil
 }
 
 const LAYERS = "layers"

d2cli/watch.go

@@ -57,6 +57,7 @@ type watcherOpts struct {
 	forceAppendix   bool
 	pw              png.Playwright
 	fontFamily      *d2fonts.FontFamily
+	monoFontFamily  *d2fonts.FontFamily
 	outputFormat    exportExtension
 	asciiMode       string
 }
@@ -443,7 +444,7 @@ func (w *watcher) compileLoop(ctx context.Context) error {
 		if w.boardPath != "" {
 			boardPath = strings.Split(w.boardPath, string(os.PathSeparator))
 		}
-		svg, _, err := compile(ctx, w.ms, w.plugins, &fs, w.layout, w.renderOpts, w.fontFamily, w.animateInterval, w.inputPath, w.outputPath, boardPath, false, w.bundle, w.forceAppendix, w.pw.Page, w.outputFormat, w.asciiMode)
+		svg, _, err := compile(ctx, w.ms, w.plugins, &fs, w.layout, w.renderOpts, w.fontFamily, w.monoFontFamily, w.animateInterval, w.inputPath, w.outputPath, boardPath, false, w.bundle, w.forceAppendix, w.pw.Page, w.outputFormat, w.asciiMode)
 		w.boardpathMu.Unlock()
 		errs := ""
 		if err != nil {

d2exporter/export.go

@@ -19,7 +19,7 @@ import (
 	"oss.terrastruct.com/d2/lib/label"
 )
 
-func Export(ctx context.Context, g *d2graph.Graph, fontFamily *d2fonts.FontFamily) (*d2target.Diagram, error) {
+func Export(ctx context.Context, g *d2graph.Graph, fontFamily *d2fonts.FontFamily, monoFontFamily *d2fonts.FontFamily) (*d2target.Diagram, error) {
 	diagram := d2target.NewDiagram()
 	applyStyles(&diagram.Root, g.Root)
 	if g.Root.Label.MapKey == nil {
@@ -36,6 +36,11 @@ func Export(ctx context.Context, g *d2graph.Graph, fontFamily *d2fonts.FontFamil
 		fontFamily = go2.Pointer(d2fonts.SourceCodePro)
 	}
 	diagram.FontFamily = fontFamily
+	if monoFontFamily == nil {
+		diagram.MonoFontFamily = go2.Pointer(d2fonts.SourceCodePro)
+	} else {
+		diagram.MonoFontFamily = monoFontFamily
+	}
 
 	diagram.Shapes = make([]d2target.Shape, len(g.Objects))
 	for i := range g.Objects {

d2exporter/export_test.go

@@ -255,7 +255,7 @@ func run(t *testing.T, tc testCase) {
 	ruler, err := textmeasure.NewRuler()
 	assert.JSON(t, nil, err)
 
-	err = g.SetDimensions(nil, ruler, nil)
+	err = g.SetDimensions(nil, ruler, nil, nil)
 	assert.JSON(t, nil, err)
 
 	graphInfo := d2layouts.NestedGraphInfo(g.Root)
@@ -264,7 +264,7 @@ func run(t *testing.T, tc testCase) {
 		t.Fatal(err)
 	}
 
-	got, err := d2exporter.Export(ctx, g, nil)
+	got, err := d2exporter.Export(ctx, g, nil, nil)
 	if err != nil {
 		t.Fatal(err)
 	}