Minn\Theme

The archive title's prefix and title for a resolution.

The reference's prefixed shape, `Category: <span>Uncategorized</span>`, through the language's own order.

The body classes a classic theme's page carries.

The same list for a view named by the post type it shows alone (null when it shows no single post), as get_body_class needs off the front (probe post-template-remaining).

A post's content as the classic loop prints it, with the more link.

A classic renderer over the database door.

The page for a resolution through the theme's PHP templates.

The body-class tokens before plugins filter them (get_body_class filters them). @return list<string>

The active classic theme, or null under a block theme.

A block's own CSS under its selector (probe editor-styles; a block's style.css too, probe block-supports), split at each ampersand: a part with no rule applies to the block itself; a nested selector that starts with a space is scoped, every comma part after the block's selector; any other is appended to it; a pseudo element moves to the end, outside :where().

The styles' own CSS (WP_Theme_JSON::get_custom_css): the top-level css, then each block's under its root selector.

Whether a request for this resolution asks for its embed page.

The embed page, under the status the request's main query settled on; the body classes the theme's page would carry (the Minn bar's aside), read once its main query stands.

The styles each feature selector takes, and the node left over.

The headers, and whether the reader's copy is current.

A theme folder with its style.css headers.

The folder's path.

The screenshot file name, or null when the theme has none.

Whether any of the folders ships a block template index.

The first of the stylesheet and template directories that holds the file, or the template directory's path.

The rules for fonts given as families of faces, one rule a line; '' when no face can be printed.

The fonts a theme.json's settings declare, one list of faces per family that has any: each face's sources first (file:./ ones through $fileUri), then its family (the first name of its own, or of the family's, unquoted), then its other properties in kebab case.

Parses the request: false when a plugin's do_parse_request took the parse over (the main query then does not run). The query string is the main query's to build, after.

The 404 decision, the one place it is made: a plugin's pre_handle_404 may make it; otherwise a request for something the site does not have is a 404, as is an empty page past the first of any listing and an empty date archive that names nothing else (an existing term, author or type with no posts, a date inside one of those or inside a search, an empty search, the front: a 200); the status and no-cache headers follow. A feed is never a 404: one of nothing is an empty feed.

The headers the reference sends for the request: no caching for a signed-in reader or a 404, the content type, a pingback address for a single post that takes pings; then wp_headers, the status an error variable names, and send_headers.

Element selectors in the order the reference prints them, whatever order theme.json or the saved styles list them in: the heading group lands before the individual levels, so an h1 line-height beats the group's. Themes list h1..h6 before heading and would otherwise win.

The theme.json (plus site-editor) styles node, under the engine's own defaults.

The same node with every `var:preset|…` token resolved to the custom property it names, which is the shape a caller reading the styles as data expects (the CSS writer resolves them on the way out instead).

The global stylesheet from theme.json and the user's styles, as a page prints it: only the core blocks it rendered.

The stylesheet wp_get_global_stylesheet answers (probe editor-styles), by type: the custom properties, the styles (every block's, rendered or not), the preset classes; in that order.

The @font-face rules for every family that declares font files (Theme\FontFaces), with file:./ resolved against the theme that carries the file. The page prints them through wp_print_font_faces on wp_head; the editor's styles read them here.

The body's margin, the global padding rules under root-padding-aware alignments, and the site's alignments.

The block gap between the site's blocks and inside every layout.

The layouts' own rules: alignments inside flow and constrained layouts, the content and wide sizes, flex and grid.

The block-gap rules for a layout scope: "" for the root, or a block's -is-layout- prefix.

The element rules (links, headings, buttons, captions, citations), each state after it; under a block's selector when one is given.

A block's rules: its root rule, its layout gap rules, then a rule for each feature its metadata gives a selector of its own (the avatar's border on its image), its own CSS and its elements (probe editor-styles).

Each selector in a list under the scope ("" for none).

A block's root selector: its metadata's, the reference's own for a few core blocks, else .wp-block-{slug}.

A core block's selectors from its metadata. @return array<string, mixed>

A block's styles split between its root selector and the features (or a feature's single properties) its metadata selects elsewhere.

A numbered style variation's CSS (probe block-supports): its element rules scoped by the numbered class alone, then the variation on the block's root selector (the class riding on the block's own class: .wp-block-button.is-style-outline--3 .wp-block-button__link), its own CSS, and the blocks styled inside it.

theme.json style properties to declarations: color, typography, spacing, border, shadow, dimensions, outline.

The link to the engine's own block stylesheet.

The site's two feed links as feed_links prints them: the posts feed and the comments feed (each unless its feed_links_show_* filter says no), titled with the caller's separator and words, through feed_links_args.

No trailing newline: the reference prints the JSON alternate and the RSD link on the same physical line.

The wp/v2 alternate link for the resolution.

The front page templates.

The home templates.

The privacy policy templates.

The page templates, custom first.

The single templates, custom first.

The attachment templates by mime type: type-subtype, subtype, type (probe template-getters).

The term archive templates.

The author archive templates.

The post type archive templates.

The page of posts a resolution shows, through the runtime's main query; the variables a request adds of its own (a feed's) win.

The resolution as the main query left it: a 404 when the query decided one (an empty page past the first, an empty date), with the vars it was asked under.

Posts per page.

A page renderer over the database door.

The reference's body-class tokens: the singular and template tokens sit in front of the type token ("page", "single"), the custom-logo and embed tokens follow the core set, the paging tokens come after those, and the theme (and child theme) tokens close the list; then the body_class filter.

The body-class tokens before plugins filter them (bodyClasses()). @return list<string>

The page for a resolution, or null when the theme has no template for it.

The patterns directory's files by file name, in name order.

The pattern files a theme ships, file name => path, in name order.

The records of a list of pattern files, file name => path (a list a plugin may have changed); a file that is not a pattern is left out.

One file's record from the start of its text, or null when it names no title or slug.

A pattern file's HTML with its PHP interpreted, never executed.

The tokens for a main query.

The sizes the scale makes, smallest first.

Core's preset lists: as stored, unless a plugin changed core's layer (wp_theme_json_data_default), whose lists then stand in for them.

The blocks' styles as far as the kept nodes reach: a block's own declarations with its node, each of its elements with that element's node (the reference lists them apart); a block with neither goes.

The style nodes a plugin keeps (wp_theme_json_get_style_nodes) as their paths, the root, element and block nodes printed only when kept; null when no plugin filters them.

Every preset list the theme declares, over core's own (as given, else data/presets.json), keyed by kind.

A preset list as theme.json writes it is a plain list; as the site editor saves it, it is keyed by origin (default, theme, custom). The reference prints the origins in that order, so the two shapes flatten to one list here.

The font family presets in the settings.

The presets as custom properties for :root.

A settings.custom tree as custom properties: --wp--custom-- and the path to each value, every key in kebab case, lists by index; empty values are left out.

The has-* utility classes the presets give every colour, gradient, font size, and font family; each under the prefix given (a block's :where(selector)).

A theme size that reuses one of core's slugs prints in core's position; the theme's own slugs follow.

The default spacing scale (20 to 80) is always present, whatever defaultSpacingSizes says; a theme size with the same slug replaces the default in place, and the theme's other sizes follow the scale.

A font size preset as the global stylesheet writes it: fluid by the theme's settings (Typography::fontSize).

A settings node as written (theme.json, a variation, or the site editor's post) with its presets keyed by origin and appearanceTools expanded.

The preset lists, at the root and under each block, keyed by the origin given; nothing else changed.

Every var:preset|kind|slug token replaced by the custom property it names.

The page a render gives, as the buffers opened before it leave it; null when the render gives none. A render that fails leaves nothing behind.

A slug's fallback chain, most specific first, ending at index.

Every template of a type: the theme's files with the saved rows over them.

Null when the id names another theme, or a slug nothing provides.

A saved wp_template or wp_template_part row as a template. @param array<string, mixed> $row

The theme's files of a type, in the directory's order, each as _get_block_templates_files describes it (fileInfo).

One theme file: its slug, path, theme (the parent's for a file the child does not have) and type; a part's title (when theme.json gives one) and area; a custom template's title and post types. Null when the theme has no such file.

The post types a custom template declares; none for any other template.

The theme the index reads.

Whether the theme ships a file for a slug.

Who the caller is told made this: the theme's own name for anything that has a file behind it, the plugin for a registered one, the author's display name for a row a person saved, and the site's name when nobody is recorded.

theme when a file backs it, plugin when one registered it, user when someone saved it, else site.

A slug the reference does not name in its default template types is a custom template.

The default template types.

Markup as a caller of the REST route sees it: patterns spliced in where the template only named them, then every template-part block told which theme it belongs to. A record carries the markup as stored, because that is what get_block_templates() hands a plugin.

Template part blocks with the theme attribute set.

Markup with its pattern blocks replaced by the patterns' content.

The reference's template id: theme//slug.

Whether this is a template part.

Writes the site's own copy of a template, creating the row the first time. Returns the post id.

A new site copy from the collection's create: as a save inserts one, but recording no origin, even over a theme file (probe rest-template-create).

Moves a site copy to the trash, which hands the theme's file back.

Deletes a saved template row.

The template that renders a resolution, or null.

A template's markup by slug, saved first.

A template part's markup by slug, saved first.

Where a template part comes from: a part saved for the theme (its post id), the theme's file (its path), or nowhere; with its markup.

The block-theme template hierarchy for each kind of resolution.

The site editor's saved global styles for the active theme, when any. An emptied node is stored as [] and reads as nothing, the way the reference reads it; a list where a map belongs is dropped the same way.

A page's chosen custom template, from _wp_page_template meta.

The active block theme, or null under a classic one.

The active theme as styling data (theme.json present), whether or not it is a block theme; the classic renderer prints its presets where the reference prints a classic theme's global styles.

The theme's own name, and the parent's, for body classes.

The theme.json with the parent's merged in; with plugins loaded, through wp_theme_json_data_theme.

Every JSON file under styles/, the parent theme's first and each theme's in path order: block style partials and style variations alike.

Layered theme.json: maps merge key by key, lists (palettes, font sizes, template parts) replace as a whole.

A template file's markup, or null.

The file a template is read from: this theme's, else its parent's; null when neither has one.

A template part file's markup, or null.

The file a template part is read from: this theme's, else its parent's; null when neither has one.

The theme's display name, as the stylesheet header states it; a child theme answers with its own. Falls back to theme.json's title, then the folder name.

Every template (or part) slug the theme offers, the child's files first and the parent's after, each in the order the directory hands them back: the reference walks these directories unsorted and its template list carries that order through.

A template title and description the theme declares for a custom template slug.

The title theme.json gives a template part, when it names one.

The template-part area declared in theme.json (header, footer, or uncategorized).

A pattern's markup, with its PHP text subset interpreted; null when unknown.

A pattern's declared Block Types and Categories, the header fields a plugin reads to tell (say) a header pattern from any other.

The header fields a pattern declares, as the metadata attribute the reference writes onto the pattern's first block when it splices the pattern into a template. A field the header omits is omitted here.

The theme's stylesheet URL when it ships one; a child's own, else nothing (the parent's is not enqueued for it).

The theme layer through wp_theme_json_data_theme; as written when nothing filters it. @param array<string, mixed> $json

The core layer (wp_theme_json_data_default, origin default) or the site editor's (wp_theme_json_data_user, origin custom) as plugins leave it, each a WP_Theme_JSON_Data they update; as given when nothing filters it. Worked out once a request for each set of callbacks and layer.

The same styling data over core's layer as wp_theme_json_data_default leaves it, for the places the reference reads core's layer through that filter (its resolver's core and merged data).

The site's active theme as styling data, whether or not it is a block theme.

Settings: presets by origin, appearanceTools expanded, the defaults underneath.

The pattern directory slugs the theme.json lists (its patterns), as given; [] when it lists none. @return array<mixed>

Styles: the theme's over the defaults, block style partials and section styles in, every var:preset token resolved.

The style variations under styles/: every JSON file there that names no blockTypes (those are block style partials), the parent theme's first, in path order, $schema dropped and the nodes normalized the way the theme's own are.

The stylesheet for the types asked for, in the order variables, styles, presets, the tree's own CSS; origins narrow the presets.

The presets and settings.custom as custom properties: on :root, then on each block's settings selector that has its own.

One settings node's custom properties under its selector; nothing when it has none.

The has-* classes: the root's bare, each block's under :where(its settings selector).

One settings node's has-* classes, under :where(selector) unless it is the bare :root.

The styles: the root layout (unless skip_root_layout_styles), the root's own rule, its CSS when the root is not body, the elements, then each block; under the root_selector and scope options.

The root layout: the content and wide sizes, the body's margin, the global padding rules, the alignments; for body, the block gap (or the fallback gap of flex and grid) and the layouts' own rules.

The block gap and the layouts' own rules; flex and grid fall back to a 0.5em gap when the tree has no block gap.

The root's own rule: body as it is, any other root under :root :where().

One block's rules; its own block gap only when the tree turns block gaps on.

One block's own rules, its elements left out: each element is a style node of its own.

The elements a block styles, in the order they print.

One element's rules, under a block's selector when it belongs to one.

The tree's own top-level CSS, as written.

A block's settings selector: its experimental selector when it has one, else .wp-block-{slug}.

A CSS length split into its number and unit (px, rem or em, or the units given), converted to another unit on request at a 16px root (or the one given); a bare number is px. Null for anything else.

A font size preset as CSS (wp_get_typography_font_size_value). It stays as written unless fluid typography is on and the size is in a known unit and above the floor (14px, or the settings' minFontSize); then it grows from a minimum (the preset's own, else the size scaled by 1 - 0.075 log2 of its px, held between 0.25 and 0.75, never under the floor) to a maximum (the preset's own, else the size).

The clamp() between two sizes over two viewport widths (wp_get_computed_fluid_typography_value): the slope in the minimum's unit, the base in rem. Null when a size or a width is missing or in an unknown unit, or the widths are equal.

The newest published global-styles post carrying the theme's term, or null.

The theme's post, made the way the reference makes it when there is none yet.

The post when it is a global-styles post, else null.

What a global-styles body holds; a missing, malformed, or list-shaped node is empty, as the reference reads it.

True when the body carries nothing at all under settings or styles, malformed or not.

Replaces what the caller names (null keeps the stored value), stamps the modified time, and snapshots a revision when anything changed. A filter, when given, has the last word on the content and title written (the save filters a REST save runs them through).