editor

type Config[F, T, I any] struct {
	// ID, Title, Path and Icon describe the admin section; see admin.Section.
	// Path is below the admin, such as "/news"; empty is "/" followed by ID.
	ID    string
	Title string
	Path  string
	Icon  string
	// NewLabel is the "new item" button text, for example "New post".
	NewLabel string
	// Links are extra buttons on the overview, for example to categories.
	Links []Link
	// Permission is the section whose rights apply, when shared with another
	// section (see admin.Section.Permission). Empty means ID.
	Permission string
	// Single allows one item, for modules where an instance is one thing (a
	// form). "New" disappears once it exists.
	Single bool

	// Store keeps the items, bound to the instance (see
	// content.Revisions.In and content.Collection.In).
	Store content.Store[F, T]
	// Locales gives the languages the editor offers tabs for.
	Locales locales.Provider

	// Form fills the input for one language of an item; item is empty for new content.
	Form func(ctx context.Context, item content.Item[F, T], locale string) (I, error)
	// Apply writes a validated submission into the draft for one language.
	Apply func(ctx context.Context, input I, draft *content.Draft[F, T], locale string) error
	// Label names an item in lists, from its text in one language.
	Label func(text T) string
	// ItemLabel names an item from the whole item, for content named by its
	// Fields (a person's name, a social network). It is used instead of Label
	// when set.
	ItemLabel func(item content.Item[F, T], locale string) string
	// Notes are shown muted after the labels in the overview, such as a
	// download count or "Expired", by item ID; a missing or empty note shows
	// nothing. It is called once per overview with all listed items, so a
	// module can read what it needs in one query. Notes are shown as written:
	// translate fixed texts with admin.T and admin.TN, which use ctx.
	Notes func(ctx context.Context, items []content.Item[F, T], locale string) map[string]string

	// PreviewURL is the address at which an editor previews a revision on
	// the website, in locale: its public address with
	// frontend.PreviewParam (see frontend.PagePreviewURL and
	// ModulePreviewURL); empty when it has none yet, for example while the
	// module is on no page. Nil offers no preview.
	PreviewURL func(ctx context.Context, item content.Item[F, T], locale string) string
	// Names maps user IDs to names for the revision history.
	Names func(ctx context.Context) (map[string]string, error)
	// Issue turns module errors of saving, publishing and deleting into
	// messages for the editor; empty means unknown. A refused delete because
	// the item is still referenced (a foreign key) defaults to "This item is
	// still in use.".
	Issue func(err error) string
	// Badge is a count next to the section in the navigation; see
	// admin.Section.Badge.
	Badge func(ctx context.Context) int
	// Stylesheet names a CSS file in Files that the admin links; see
	// admin.Section.Stylesheet.
	Stylesheet string

	// Files can override the editor templates and add module templates.
	Files fs.FS
	// Overview replaces the default overview, for content with a structure
	// of its own such as the page tree. Nil uses the default list.
	Overview func(w http.ResponseWriter, r *http.Request, editor Editor[F, T, I])
	// Permanent reports items that must stay on the website by their
	// nature, such as the home page: their editor offers no unpublish, no
	// planned unpublication and no delete, refuses them when they are
	// posted anyway, and offers no way to remove the mark. Administrators
	// can mark other items permanent, and remove that mark again, in the
	// item's editor when the admin keeps marks (see admin.Permanence).
	Permanent func(item content.Item[F, T]) bool
	// Routes adds module screens to the section.
	Routes func(routes *admin.Routes, editor Editor[F, T, I])
	// Edit adds to the edit screen of an item that exists, once the editor
	// has built it: it may add Notices, such as the pages that link to the
	// item, and change or replace the forms of view, such as with a
	// question before the item is unpublished (admin.Admin.Confirm) or a
	// publish form that posts to a route of its own (Config.Routes). Nil
	// adds nothing.
	Edit func(r *http.Request, editor Editor[F, T, I], item content.Item[F, T], locale string, view *EditView) error
	// Saved follows up the save of an item that existed, with the item
	// before and after: it may act on the change, such as redirecting the
	// item's old address (Linked.Saved), and returns the toast to show,
	// nil for the editor's own. Nil does nothing.
	Saved func(r *http.Request, editor Editor[F, T, I], before, after content.Item[F, T], locale string) *flash.Message
	// Trash adds the module's own deleted records to the section's trash,
	// such as a form's submissions, next to the deleted items of Store.
	Trash admin.Trash
}

type Conflict struct {
	// Text says who saved the item and when; it is shown as written.
	Text string
	// URL is the editor of the saved version, which the notice opens in a
	// new tab to compare.
	URL string
	// Form is the id of the edit form; Name and Value are those of the
	// "Save anyway" button that submits it. Value is the saved version,
	// which the form may then save over.
	Form  string
	Name  string
	Value string
}

type EditView struct {
	// Title is the item's label, or for a new item the translated "new"
	// label of the section; it is shown as written.
	Title   string
	BackURL string
	// BackLabel names the overview BackURL leads to, the section's title,
	// as a translation key.
	BackLabel string
	Tabs      []admin.LocaleTab
	Panel     *admin.RevisionPanel
	Publish   *form.RenderModel
	Unpublish *form.RenderModel
	Form      form.RenderModel
	Errors    form.FieldErrors
	// Conflict is the notice of a save that was refused because someone
	// saved the item after its form was opened; Form then shows what the
	// editor typed. Nil otherwise.
	Conflict *Conflict
	// ReadOnly is set for users who may view the item but not edit it: Form
	// is then read-only (disabled, without its button).
	ReadOnly bool
	Delete   *form.RenderModel
	// Permanent items stay on the website: they cannot be unpublished,
	// scheduled to be unpublished or deleted. PermanentFixed items are
	// permanent by their nature (see Config.Permanent); the mark of others
	// was set by an administrator.
	Permanent      bool
	PermanentFixed bool
	// Permanence sets or removes the permanent mark, for administrators
	// when the admin keeps marks; nil otherwise.
	Permanence *form.RenderModel
	// Notices are warnings shown above the form (see Config.Edit).
	Notices []Notice
}

type Editor[F, T, I any] struct {
	// contains filtered or unexported fields
}

type IndexView struct {
	Title    string
	NewURL   string
	NewLabel string
	Links    []Link
	// TrashURL shows the section's deleted items in the admin's trash.
	TrashURL   string
	Revisioned bool
	Tabs       []admin.LocaleTab
	Rows       []Row
	// Pager pages through long lists.
	Pager admin.Pager
}

type Link struct {
	Label string
	URL   string
	Route string
}

type Linked[F, T, I any] struct {
	// Check is the site's link check (webthings.Env.Links); nil adds
	// nothing.
	Check *links.Check
	// Address is the address of item, which may be any revision of it, on
	// the site in locale, such as "/en/news/hello": where visitors find it
	// once it is published. Empty when it has none there, such as an item
	// of an instance on no page. It is asked only for languages in which
	// the item is complete (content.Spec.Available).
	Address func(ctx context.Context, item content.Item[F, T], locale string) (string, error)
	// Below, if set, are the addresses below the item's address in locale
	// that leave the website with it, such as the entries of a directory's
	// category, which go offline when the category is unpublished but keep
	// working at their old addresses when its slug changes. The editor then
	// counts the links below the item's address apart from those to the
	// item itself, and unpublishing it with redirects redirects these
	// addresses too, to the same page. Without it, links below the item's
	// address count as links to the item. It is asked only for languages in
	// which the item is complete.
	Below func(ctx context.Context, item content.Item[F, T], locale string) ([]string, error)
}

type MovedInput struct {
	Redirect bool `` /* 155-byte string literal not displayed */
}

type Notice struct {
	// Text is shown as written: translate it first (admin.T, admin.TN).
	Text string
	// Items are listed below the text, such as the pages that link to the
	// item.
	Items []NoticeItem
	// Forms act on the notice, such as one that creates a redirect.
	Forms []form.RenderModel
}

type NoticeItem struct {
	Label string
	URL   string
	Note  string
}

type RedirectInput struct {
	Target form.SortedSelect[string] `form:"dropdown" label:"Redirect to" required:"true" placeholder:"—"`
}

type Row struct {
	Title string
	// Note is shown muted after the title; see Config.Notes.
	Note    string
	URL     string
	Status  string
	Missing bool
	// Moves are the item's up and down arrows, for ordered stores; see
	// admin.Moves.
	Moves []admin.Move
}