render

type Data struct {
	Ctx          context.Context
	Sources      map[string]*Source
	ExtraHeaders map[string]http.Header
	// contains filtered or unexported fields
}

type Datasource struct {
	// URL is the datasource URL (any scheme gomplate supports). A bare absolute
	// path is treated as a file:// URL.
	URL string
	// Headers are extra HTTP headers sent to http(s) datasources.
	Headers map[string][]string
}

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

type Engine interface {
	Renderer
}

type FuncsWrapper func(funcs template.FuncMap, sources *Data) (template.FuncMap, error)

type Option func(*engine)

type Renderer interface {
	Render(ctx context.Context, req *Request) (string, error)
}

type Request struct {
	// Name is the template name used in error messages.
	Name string
	// Text is the template source.
	Text string
	// Data is the value bound to `.` when the template executes. It may be a
	// map or any Go value; it is never serialized.
	Data any
	// Funcs are functions merged last, so they override Gomplate and Sprig
	// functions with the same name (e.g. the `atmos` namespace).
	Funcs template.FuncMap
	// LeftDelim and RightDelim override the default action delimiters.
	LeftDelim  string
	RightDelim string
	// MissingKey is the text/template "missingkey" option; empty means MissingKeyError.
	MissingKey string
	// Datasources are read lazily when the template calls `datasource`/`ds`/`include`.
	// They are added to Sources (or to a fresh Data when Sources is nil).
	Datasources map[string]Datasource
	// Sources serves the template's datasource functions. Pass the same Data to
	// functions that read datasources themselves (such as the `atmos`
	// namespace) so they share its definitions. Nil means a fresh Data.
	Sources *Data
	// ContextSources are read eagerly before execution and exposed on `.`; the
	// alias "." replaces the whole context, as in gomplate's renderer. When set,
	// Data is ignored. They are also readable as datasources (for example
	// `ds "config"`).
	ContextSources map[string]Datasource
	// WrapFuncs, when set, receives the fully assembled function map (Gomplate,
	// Sprig, compatibility shims and Funcs) and the render's datasources, and
	// returns the map the template is parsed with. Policy admission uses it to
	// guard every function call. Gomplate's `tmpl` namespace and `tpl` alias
	// need the parsed root, so they are passed through it in a second call of
	// their own once they are bound.
	WrapFuncs FuncsWrapper
	// Prepare, when set, runs on the parsed template before it executes, for
	// callers that rewrite or guard the parse tree. Gomplate's `tmpl`/`tpl`
	// functions are unavailable when it is set, so run-time templates can't
	// escape it. It does not apply to ContextSources renders.
	Prepare func(*template.Template)
}

type Source struct {
	Alias  string
	URL    *url.URL
	Header http.Header
}