Align foundational Go conversion capabilities

minipdf-go/README.md

@@ -35,6 +35,61 @@ Convert in-memory Office package bytes:
 pdf, err := minipdf.ConvertBytesToPDF(input)
 ```
 
+Compress PDF page content streams:
+
+```go
+pdf, err := minipdf.ConvertBytesToPDFWithOptions(input, minipdf.ConversionOptions{
+	Compress: true,
+})
+```
+
+Override DOCX page margins in PDF points:
+
+```go
+margins, err := minipdf.NewMargins(36, 48, 36, 48)
+if err != nil {
+	panic(err)
+}
+pdf, err := minipdf.ConvertBytesToPDFWithOptions(input, minipdf.ConversionOptions{
+	Margins: &margins,
+})
+```
+
+Margin overrides are rejected for XLSX and PPTX input.
+
+Limit XLSX output or override worksheet orientation:
+
+```go
+landscape := true
+pdf, err := minipdf.ConvertBytesToPDFWithOptions(input, minipdf.ConversionOptions{
+	MaxRows: 100,
+	MaxColumns: 12,
+	Landscape: &landscape,
+})
+```
+
+Convert between streams:
+
+```go
+err := minipdf.ConvertReaderToWriter(input, output, minipdf.ConversionOptions{})
+```
+
+Register a TrueType font before conversion when built-in PDF fonts do not cover
+the document text:
+
+```go
+fontData, err := os.ReadFile("fonts/NotoSans-Regular.ttf")
+if err != nil {
+	panic(err)
+}
+minipdf.RegisterFont("Noto Sans", fontData)
+defer minipdf.ClearRegisteredFonts()
+```
+
+Registered `.ttf` fonts are embedded as Type0/CID fonts with ToUnicode maps.
+Font subsetting, TrueType Collections, automatic system-font discovery, and
+complex-script shaping are not yet implemented.
+
 Override the output page size:
 
 ```go
@@ -55,6 +110,9 @@ minipdf report.docx
 minipdf data.xlsx -o data.pdf
 minipdf slides.pptx --paper-size a4
 minipdf convert report.docx --page-width 400 --page-height 500
+minipdf report.docx --fonts ./fonts
+minipdf report.docx --compress
+minipdf data.xlsx --max-rows 100 --max-columns 12 --landscape
 ```
 
 ## Current Scope
@@ -66,8 +124,9 @@ minipdf convert report.docx --page-width 400 --page-height 500
 | PPTX to PDF | Basic slide text |
 | PDF output | Dependency-free PDF 1.4 writer |
 | Page size | Office geometry, A4/Letter presets, or custom points |
-| Fonts | Registration API reserved; embedding is not implemented yet |
-| Interfaces | Go package and native CLI |
+| Fonts | Embedded registered TTF fonts with ToUnicode; no subsetting or shaping yet |
+| Input safety | Bounded ZIP entry count, size, expansion ratio, encryption, and path validation |
+| Interfaces | Go package with file, byte, and stream APIs; native CLI |
 
 The initial renderer deliberately does not claim support for Office styles,
 images, tables, charts, themes, formulas, merged cells, or font embedding.

minipdf-go/cmd/minipdf/main.go

@@ -18,11 +18,16 @@ var (
 )
 
 type cliOptions struct {
-	input      string
-	output     string
-	paperSize  string
-	pageWidth  float64
-	pageHeight float64
+	input         string
+	output        string
+	fontDirectory string
+	compress      bool
+	maxRows       int
+	maxColumns    int
+	landscape     *bool
+	paperSize     string
+	pageWidth     float64
+	pageHeight    float64
 }
 
 func main() {
@@ -58,6 +63,9 @@ func run(options cliOptions) error {
 	if err != nil {
 		return err
 	}
+	if err := registerFontsFromDirectory(options.fontDirectory); err != nil {
+		return err
+	}
 	output := options.output
 	if output == "" {
 		output = strings.TrimSuffix(options.input, filepath.Ext(options.input)) + ".pdf"
@@ -69,6 +77,29 @@ func run(options cliOptions) error {
 	return nil
 }
 
+func registerFontsFromDirectory(directory string) error {
+	if directory == "" {
+		return nil
+	}
+	entries, err := os.ReadDir(directory)
+	if err != nil {
+		return fmt.Errorf("read font directory %q: %w", directory, err)
+	}
+	for _, entry := range entries {
+		if entry.IsDir() || !strings.EqualFold(filepath.Ext(entry.Name()), ".ttf") {
+			continue
+		}
+		fontPath := filepath.Join(directory, entry.Name())
+		fontData, err := os.ReadFile(fontPath)
+		if err != nil {
+			return fmt.Errorf("read font %q: %w", fontPath, err)
+		}
+		name := strings.TrimSuffix(entry.Name(), filepath.Ext(entry.Name()))
+		minipdf.RegisterFont(name, fontData)
+	}
+	return nil
+}
+
 func conversionOptions(options cliOptions) (minipdf.ConversionOptions, error) {
 	customPageSize := options.pageWidth != 0 || options.pageHeight != 0
 	if options.paperSize != "" && customPageSize {
@@ -96,7 +127,10 @@ func conversionOptions(options cliOptions) (minipdf.ConversionOptions, error) {
 		}
 		pageSize = &size
 	}
-	return minipdf.ConversionOptions{PageSize: pageSize}, nil
+	return minipdf.ConversionOptions{
+		PageSize: pageSize, Compress: options.compress,
+		MaxRows: options.maxRows, MaxColumns: options.maxColumns, Landscape: options.landscape,
+	}, nil
 }
 
 func parseArguments(arguments []string) (cliOptions, error) {
@@ -112,9 +146,21 @@ func parseArguments(arguments []string) (cliOptions, error) {
 		if argument == "--version" {
 			return cliOptions{}, errVersion
 		}
+		if argument == "--compress" {
+			options.compress = true
+			continue
+		}
+		if argument == "--landscape" || argument == "--portrait" {
+			landscape := argument == "--landscape"
+			if options.landscape != nil && *options.landscape != landscape {
+				return cliOptions{}, errors.New("use either --landscape or --portrait, not both")
+			}
+			options.landscape = &landscape
+			continue
+		}
 		name, inlineValue, hasInlineValue := strings.Cut(argument, "=")
 		switch name {
-		case "-o", "--output", "--paper-size", "--page-width", "--page-height":
+		case "-o", "--output", "--fonts", "--paper-size", "--page-width", "--page-height", "--max-rows", "--max-columns":
 			value := inlineValue
 			if !hasInlineValue {
 				index++
@@ -126,6 +172,8 @@ func parseArguments(arguments []string) (cliOptions, error) {
 			switch name {
 			case "-o", "--output":
 				options.output = value
+			case "--fonts":
+				options.fontDirectory = value
 			case "--paper-size":
 				options.paperSize = value
 			case "--page-width":
@@ -140,6 +188,18 @@ func parseArguments(arguments []string) (cliOptions, error) {
 					return cliOptions{}, fmt.Errorf("invalid page height %q", value)
 				}
 				options.pageHeight = height
+			case "--max-rows":
+				maximum, err := strconv.Atoi(value)
+				if err != nil || maximum <= 0 {
+					return cliOptions{}, fmt.Errorf("invalid maximum row count %q", value)
+				}
+				options.maxRows = maximum
+			case "--max-columns":
+				maximum, err := strconv.Atoi(value)
+				if err != nil || maximum <= 0 {
+					return cliOptions{}, fmt.Errorf("invalid maximum column count %q", value)
+				}
+				options.maxColumns = maximum
 			}
 		default:
 			if strings.HasPrefix(argument, "-") {
@@ -166,6 +226,12 @@ Usage:
 
 Options:
   -o, --output PATH          Output PDF path
+			--fonts DIR            Register .ttf fonts from a directory
+			--compress             Compress PDF page content streams
+			--max-rows COUNT       Maximum XLSX rows to render
+			--max-columns COUNT    Maximum XLSX columns to render
+			--landscape            Render XLSX pages in landscape
+			--portrait             Render XLSX pages in portrait
       --paper-size SIZE      a4 or letter
       --page-width POINTS    Custom page width
       --page-height POINTS   Custom page height

minipdf-go/cmd/minipdf/main_test.go

@@ -1,8 +1,13 @@
 package main
 
 import (
+	"bytes"
 	"errors"
+	"os"
+	"path/filepath"
 	"testing"
+
+	minipdf "github.com/mini-software/MiniPdf/minipdf-go"
 )
 
 func TestParseArgumentsAcceptsVersionWithoutInput(t *testing.T) {
@@ -18,3 +23,74 @@ func TestConversionOptionsRejectsMixedPageSizes(t *testing.T) {
 		t.Fatal("conversionOptions() accepted preset and custom page sizes")
 	}
 }
+
+func TestParseArgumentsAcceptsFontDirectory(t *testing.T) {
+	options, err := parseArguments([]string{"report.docx", "--fonts", "fonts"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if options.fontDirectory != "fonts" {
+		t.Fatalf("fontDirectory = %q, want %q", options.fontDirectory, "fonts")
+	}
+}
+
+func TestParseArgumentsAcceptsCompression(t *testing.T) {
+	options, err := parseArguments([]string{"report.docx", "--compress"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !options.compress {
+		t.Fatal("compress = false, want true")
+	}
+	conversion, err := conversionOptions(options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !conversion.Compress {
+		t.Fatal("ConversionOptions.Compress = false, want true")
+	}
+}
+
+func TestParseArgumentsAcceptsXLSXControls(t *testing.T) {
+	options, err := parseArguments([]string{
+		"report.xlsx", "--max-rows", "10", "--max-columns", "4", "--landscape",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	conversion, err := conversionOptions(options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if conversion.MaxRows != 10 || conversion.MaxColumns != 4 || conversion.Landscape == nil || !*conversion.Landscape {
+		t.Fatalf("conversion options = %#v", conversion)
+	}
+}
+
+func TestParseArgumentsRejectsConflictingOrientation(t *testing.T) {
+	_, err := parseArguments([]string{"report.xlsx", "--landscape", "--portrait"})
+	if err == nil {
+		t.Fatal("parseArguments() accepted conflicting orientation flags")
+	}
+}
+
+func TestRegisterFontsFromDirectory(t *testing.T) {
+	minipdf.ClearRegisteredFonts()
+	t.Cleanup(minipdf.ClearRegisteredFonts)
+	directory := t.TempDir()
+	fontData := []byte("test font")
+	if err := os.WriteFile(filepath.Join(directory, "Example.TTF"), fontData, 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(directory, "ignored.txt"), []byte("ignored"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := registerFontsFromDirectory(directory); err != nil {
+		t.Fatal(err)
+	}
+	fonts := minipdf.RegisteredFonts()
+	if len(fonts) != 1 || fonts[0].Name != "Example" || !bytes.Equal(fonts[0].Data, fontData) {
+		t.Fatalf("registered fonts = %#v", fonts)
+	}
+}