xtemplate

type CleanupDotProvider interface {
	DotConfig
	Cleanup(any, error) error
}

type Config struct {
	// The path to the templates directory within the filesystem. Default `templates`.
	TemplatesDir string `json:"templates_dir,omitempty" arg:"-t,--template-dir,--templates-dir" default:"templates"`

	// The FS to load templates from. Default: a FS made from the current working directory.
	TemplatesFS afero.Fs `json:"-" arg:"-"`

	// File extension to search for to find template files. Default `.html`.
	TemplateExtension string `json:"template_extension,omitempty" arg:"--template-ext" default:".html"`

	// Whether html templates are minified at load time. Default `true`.
	//
	// This is a *bool to distinguish unset (nil) from set false.
	Minify *bool `json:"minify,omitempty" arg:"-m,--minify" default:"true"`

	CrossOrigin CrossOriginConfig `json:"crossorigin" arg:"-"`

	ProvidersRaw []json.RawMessage `json:"providers,omitempty" arg:"-"`
	Providers    []DotConfig       `json:"-" arg:"-"`

	// Encodings to pre-compress static files into at load time. Supported values:
	// "gzip", "zstd", "br". Default empty (no pre-compression).
	Precompress []string `json:"precompress,omitempty" arg:"--precompress,separate"`

	// Left template action delimiter. Default `{{`.
	LDelim string `json:"left,omitempty" arg:"--ldelim" default:"{{"`

	// Right template action delimiter. Default `}}`.
	RDelim string `json:"right,omitempty" arg:"--rdelim" default:"}}"`

	// Additional functions to add to the template execution context.
	FuncMaps []template.FuncMap `json:"-" arg:"-"`

	// Peer HTTP handlers registered on the instance ServeMux next to template
	// and static routes. Use this to embed existing handlers (APIs, webhooks,
	// health checks) under the same ServeMux as the template app. Errors if the
	// pattern conflicts with another route registered by the template root.
	//
	// Each entry is a sibling route on the mux (net/http.ServeMux pattern).
	// Re-registered when a new instance is built, so they survive reloads.
	Handlers []HandlerRoute `json:"-" arg:"-"`

	// The instance context that is threaded through dot providers and can
	// cancel the server. Defaults to `context.Background()`.
	Ctx context.Context `json:"-" arg:"-"`

	// The default logger. Defaults to `slog.Default()`.
	Logger *slog.Logger `json:"-" arg:"-"`

	// Reload, when non-nil, triggers server.Reload(opts...) on each receive.
	// Send options to mutate the config for that reload (e.g. WithTemplateFS to
	// swap the templates source). Send nil to reload in place. Close the channel
	// to stop the consumer. The caller owns the source and any debounce.
	//
	// Options apply to a copy of the config per reload, so they are not sticky:
	// the next reload starts from the original config again. Use a single reload
	// source per server unless you persist options into the base config yourself.
	Reload <-chan []Option `json:"-" arg:"-"`
}

type CrossOriginConfig struct {
	Disabled               bool     `json:"disabled" arg:"--disable-cors" default:"false"`
	TrustedOrigins         []string `json:"trusted_origins" arg:"--trusted-origin,separate"`
	InsecureBypassPatterns []string `json:"insecure_bypass_patterns" arg:"--insecure-bypass-pattern,separate"`
}

type DotConfig interface {
	FieldName() string
	Init(context.Context) error
	// Value returns the value to assign to this provider's dot field for a
	// given request. It must return a stable, non-nil concrete type: makeDot
	// calls it once with a mock request purely to infer the field type via
	// reflection, so a nil return (e.g. on error during inference) cannot be
	// used to build the dot struct.
	Value(Request) (any, error)
}

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

type DotReq struct {
	*http.Request
}

type DotResp struct {
	http.Header
	// contains filtered or unexported fields
}

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

type ErrorStatus int

type HandlerRoute struct {
	// Pattern uses net/http.ServeMux syntax (e.g. "POST /foo/{bar}").
	Pattern string
	Handler http.Handler
}

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

type InstanceRoute struct {
	Pattern string
	Handler http.Handler
}

type InstanceStats struct {
	Routes                        int
	TemplateFiles                 int
	TemplateDefinitions           int
	InitializationTemplates       int
	StaticFiles                   int
	StaticFilesAlternateEncodings int
}

type MarkdownDoc struct {
	Meta map[string]any `json:"meta,omitempty"`
	Body template.HTML  `json:"body,omitempty"`
}

type Option func(*Config) error

type Request struct {
	DotConfig
	ServerCtx context.Context
	W         http.ResponseWriter
	R         *http.Request
}

type ReturnError struct{}

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