backend

type Availabler ¶ added in v0.1.1

type Availabler interface {
	IsAvailable(from, to string) bool
}

Availabler is an optional interface a Backend may implement to declare, per-capability, whether the underlying tooling is currently installed. Backends with multiple edge-specific binaries (e.g. csvkit uses in2csv/xlsx2csv for xlsx→csv but csvjson for csv→json) should implement this so the router can filter out edges that cannot actually run.

If a backend does not implement Availabler, IsAvailable falls back to checking whether BinaryName() is present in $PATH.

type Backend ¶

type Backend interface {
	Name() string
	BinaryName() string
	Capabilities() []Capability
	Convert(ctx context.Context, in, out string, opts Options) error
}

Backend is the interface every converter must satisfy.

func All() []Backend

func Resolve(from, to string) (Backend, error)

type Capability ¶

type Capability struct {
	From    string
	To      string
	Cost    int // 1=fast, 5=slow/lossy
	Quality int // 0-100
	Lossy   bool
}

Capability declares a single From→To conversion that a backend can perform.

func AllCapabilities() []Capability

type ConvertError ¶

type ConvertError struct {
	BackendName string
	From        string
	To          string
	Err         error
}

ConvertError wraps a backend error with routing context.

func (e *ConvertError) Error() string

func (e *ConvertError) Is(target error) bool

func (e *ConvertError) Unwrap() error

type OpType ¶ added in v0.1.1

type OpType string

OpType identifies a specific processing operation (e.g. "pdf.merge").

const (
	OpPDFMerge     OpType = "pdf.merge"
	OpPDFSplit     OpType = "pdf.split"
	OpPDFRotate    OpType = "pdf.rotate"
	OpPDFCrop      OpType = "pdf.crop"
	OpPDFOptimize  OpType = "pdf.optimize"
	OpPDFEncrypt   OpType = "pdf.encrypt"
	OpPDFDecrypt   OpType = "pdf.decrypt"
	OpPDFWatermark OpType = "pdf.watermark"
	OpPDFStamp     OpType = "pdf.stamp"
	OpPDFNUp       OpType = "pdf.nup"
	OpPDFBooklet   OpType = "pdf.booklet"
	OpPDFExtract   OpType = "pdf.extract"
	OpPDFValidate  OpType = "pdf.validate"
	OpPDFInfo      OpType = "pdf.info"
)

func AllOperations() []OpType

type Options ¶

type Options struct {
	Quality   int
	StripMeta bool
	Workers   int
	ExtraArgs []string
	Named     map[string]string // "backend.key" → value
	Fonts     fonts.Config      // font preferences for PDF-producing backends
}

Options carries conversion parameters passed from CLI / config.

func (o Options) Get(backend, key string) string

type ProcessParams ¶ added in v0.1.1

type ProcessParams map[string]string

ProcessParams carries operation-specific parameters as string key-value pairs. The Processor is responsible for parsing and validating each parameter before constructing its CLI invocation.

Common keys (operation-specific subsets):

pages   - page selection expression (e.g. "1-3,7")
angle   - rotation angle (multiple of 90)
mode    - operation mode (e.g. "page", "span", "bookmark", "create")
unit    - measurement unit (e.g. "pt", "mm", "cm", "in")
password - owner or user password (NEVER log or include in status)
n       - grid size for nup/booklet (2, 3, 4, 8, 9, 12, 16)
desc    - crop/stamp/watermark description string
value   - text or file path for stamp/watermark content

type ProcessRequest ¶ added in v0.1.1

type ProcessRequest struct {
	Op     OpType
	Inputs []string      // input file paths (1 for most ops, N for merge/nup/booklet)
	Output string        // output file or directory path
	Params ProcessParams // operation-specific parameters
	Opts   Options       // shared backend options (quality, extra args, etc.)
}

ProcessRequest describes a single processing operation to execute.

type ProcessResult ¶ added in v0.1.1

type ProcessResult struct {
	OutputPath string   // primary output file or directory
	Outputs    []string // all output files (for split/extract producing multiple files)
}

ProcessResult describes the outcome of a processing operation.

type Processor ¶ added in v0.1.1

type Processor interface {
	// Name returns the processor's unique identifier (e.g. "pdfcpu").
	Name() string

	// BinaryName returns the CLI binary this processor wraps (e.g. "pdfcpu").
	BinaryName() string

	// Operations returns the set of operation types this processor supports.
	Operations() []OpType

	// Process executes the requested operation. Implementations must return
	// ErrUnsupportedOp if the operation type is not in their supported set.
	Process(ctx context.Context, req ProcessRequest) (*ProcessResult, error)
}

Processor is the interface for backends that perform file-processing operations beyond simple from→to conversion (e.g. PDF merge, split, rotate). Processors are discovered and invoked separately from the conversion router/Engine pipeline.

func AllProcessors() []Processor

func FindProcessor(op OpType) (Processor, error)

func ProcessorsByOp(op OpType) []Processor

type Registry ¶ added in v0.1.1

type Registry struct {
	// contains filtered or unexported fields
}

Registry is an isolated, concurrency-safe collection of backends and processors. Create one via NewRegistry for tests, TUI, or server adapters that need their own scope, independent of the process-global registry.

func NewRegistry(backends ...Backend) *Registry

func (r *Registry) All() []Backend

func (r *Registry) AllCapabilities() []Capability

func (r *Registry) AllOperations() []OpType

func (r *Registry) AllProcessors() []Processor

func (r *Registry) Find(name string) (Backend, bool)

func (r *Registry) FindProcessor(op OpType) (Processor, error)

func (r *Registry) ProcessorsByOp(op OpType) []Processor

func (r *Registry) Register(b Backend)

func (r *Registry) RegisterProcessor(p Processor)

func (r *Registry) Resolve(from, to string) (Backend, error)