| 1 |
<?php |
| 2 |
/** |
| 3 |
* Shared setting-key declarations for the settings abilities. |
| 4 |
* |
| 5 |
* @package ThinkRank\Abilities\Settings |
| 6 |
* @since 2.1.1 |
| 7 |
*/ |
| 8 |
|
| 9 |
declare(strict_types=1); |
| 10 |
|
| 11 |
namespace ThinkRank\Abilities\Settings; |
| 12 |
|
| 13 |
if ( ! defined( 'ABSPATH' ) ) { |
| 14 |
exit; |
| 15 |
} |
| 16 |
|
| 17 |
/** |
| 18 |
* The keys each settings category exposes over the abilities layer, and their |
| 19 |
* JSON types. |
| 20 |
* |
| 21 |
* Declared once and shared by the get/update pair for each category, because |
| 22 |
* two hand-maintained allowlists per category is how the gap opened in the |
| 23 |
* first place: site identity exposed 13 of its 54 keys and sitemap 8 of its 20, |
| 24 |
* so an MCP agent could neither read nor set any title template, the whole |
| 25 |
* business/Local SEO block, or the sitemap index toggle — and, since the read |
| 26 |
* ability omitted them silently, had no way to tell its picture was incomplete |
| 27 |
* (#518). |
| 28 |
* |
| 29 |
* AbilitySettingsCoverageTest walks each manager's get_known_setting_keys() |
| 30 |
* against these maps and fails when a category gains a key that is neither |
| 31 |
* exposed here nor listed as deliberately excluded, so the drift cannot recur |
| 32 |
* unnoticed. |
| 33 |
* |
| 34 |
* @since 2.1.1 |
| 35 |
*/ |
| 36 |
final class Settings_Key_Map { |
| 37 |
|
| 38 |
/** |
| 39 |
* `site_identity` keys that belong to another ability. |
| 40 |
* |
| 41 |
* Not gaps: each is already reachable, and exposing it twice would give an |
| 42 |
* agent two ways to write the same row. |
| 43 |
* |
| 44 |
* @var array<string,string> Key => the ability that owns it. |
| 45 |
*/ |
| 46 |
public const SITE_IDENTITY_ELSEWHERE = [ |
| 47 |
'robots_txt_content' => 'thinkrank/update-robots-txt', |
| 48 |
'custom_robots_rules' => 'thinkrank/update-robots-txt', |
| 49 |
'knowledge_graph' => 'thinkrank/update-schema-settings', |
| 50 |
'organization_schema' => 'thinkrank/update-schema-settings', |
| 51 |
'post_title' => 'thinkrank/update-global-settings', |
| 52 |
'page_title' => 'thinkrank/update-global-settings', |
| 53 |
]; |
| 54 |
|
| 55 |
/** |
| 56 |
* `sitemap` keys that are derived state rather than settings. |
| 57 |
* |
| 58 |
* @var array<string,string> Key => why it is not exposed. |
| 59 |
*/ |
| 60 |
public const SITEMAP_ELSEWHERE = [ |
| 61 |
'last_generated' => 'written by the generator, not a setting', |
| 62 |
'sitemap_urls' => 'written by the generator, not a setting', |
| 63 |
'selected_preset' => 'UI marker the settings screen maintains for itself', |
| 64 |
]; |
| 65 |
|
| 66 |
/** |
| 67 |
* JSON schema properties for every exposed `site_identity` key. |
| 68 |
* |
| 69 |
* @return array<string, array<string, mixed>> |
| 70 |
*/ |
| 71 |
public static function site_identity(): array { |
| 72 |
return [ |
| 73 |
// Core. |
| 74 |
'enabled' => self::boolean( __( 'Whether site identity management is active.', 'thinkrank' ) ), |
| 75 |
'site_name' => self::string( __( 'Official name of the site, used in titles and schema.', 'thinkrank' ) ), |
| 76 |
'site_description' => self::string( __( 'Short description of the site.', 'thinkrank' ) ), |
| 77 |
'tagline' => self::string( __( 'Site tagline.', 'thinkrank' ) ), |
| 78 |
'alternate_name' => self::alternate_name(), |
| 79 |
'identity_type' => self::string( __( 'What the site is, e.g. "blog", "business", "portfolio".', 'thinkrank' ) ), |
| 80 |
'represents' => self::string( __( 'Whether the site represents a "person" or an "organization".', 'thinkrank' ) ), |
| 81 |
'default_meta_description' => self::string( __( 'Meta description used where no more specific one is set.', 'thinkrank' ) ), |
| 82 |
'default_social_image' => self::string( __( 'URL of the fallback social sharing image.', 'thinkrank' ) ), |
| 83 |
'social_media_accounts' => [ |
| 84 |
'type' => 'array', |
| 85 |
'description' => __( 'Profile URLs for the site\'s social accounts.', 'thinkrank' ), |
| 86 |
'items' => [ 'type' => 'string' ], |
| 87 |
], |
| 88 |
|
| 89 |
// Titles. These are %token% templates; the manager sanitizes them |
| 90 |
// without stripping their tokens. |
| 91 |
'title_template' => self::string( __( 'Named title layout, e.g. "default", "reverse", "category".', 'thinkrank' ) ), |
| 92 |
'title_separator' => self::string( __( 'Separator between title parts, e.g. "pipe", "dash".', 'thinkrank' ) ), |
| 93 |
'homepage_title' => self::template( __( 'the homepage', 'thinkrank' ), '' ), |
| 94 |
'category_title' => self::template( __( 'category archives', 'thinkrank' ), '%category_title%, %category%' ), |
| 95 |
'tag_title' => self::template( __( 'tag archives', 'thinkrank' ), '%tag_title%' ), |
| 96 |
'author_title' => self::template( __( 'author archives', 'thinkrank' ), '%author_name%' ), |
| 97 |
'search_title' => self::template( __( 'search results pages', 'thinkrank' ), '%search_term%' ), |
| 98 |
'archive_title' => self::template( __( 'date and other archives', 'thinkrank' ), '%archive_title%' ), |
| 99 |
|
| 100 |
// Breadcrumbs. |
| 101 |
'breadcrumbs_enabled' => self::boolean( __( 'Whether breadcrumb markup is generated.', 'thinkrank' ) ), |
| 102 |
'breadcrumb_type' => self::string( __( 'Breadcrumb structure, e.g. "hierarchical".', 'thinkrank' ) ), |
| 103 |
'breadcrumb_home_text' => self::string( __( 'Label for the home link in breadcrumbs.', 'thinkrank' ) ), |
| 104 |
'breadcrumb_separator' => self::string( __( 'Separator drawn between breadcrumb items.', 'thinkrank' ) ), |
| 105 |
'breadcrumb_prefix' => self::string( __( 'Text shown before the breadcrumb trail.', 'thinkrank' ) ), |
| 106 |
'show_current_page' => self::boolean( __( 'Whether the current page appears in its own breadcrumb trail.', 'thinkrank' ) ), |
| 107 |
'breadcrumb_use_seo_title' => self::boolean( __( 'Whether breadcrumb labels use the SEO title of a post or term when one is set, instead of its raw title.', 'thinkrank' ) ), |
| 108 |
|
| 109 |
// Brand imagery. |
| 110 |
'logo_url' => self::string( __( 'URL of the site logo.', 'thinkrank' ) ), |
| 111 |
'favicon_url' => self::string( __( 'URL of the site favicon.', 'thinkrank' ) ), |
| 112 |
'apple_touch_icon_url' => self::string( __( 'URL of the Apple touch icon.', 'thinkrank' ) ), |
| 113 |
|
| 114 |
// Homepage hero. |
| 115 |
'hero_title' => self::string( __( 'Homepage hero heading.', 'thinkrank' ) ), |
| 116 |
'hero_subtitle' => self::string( __( 'Homepage hero subheading.', 'thinkrank' ) ), |
| 117 |
'hero_cta_text' => self::string( __( 'Label on the homepage hero call to action.', 'thinkrank' ) ), |
| 118 |
'hero_cta_url' => self::string( __( 'URL the homepage hero call to action points at.', 'thinkrank' ) ), |
| 119 |
'hero_background_image' => self::string( __( 'URL of the homepage hero background image.', 'thinkrank' ) ), |
| 120 |
|
| 121 |
// Business / Local SEO. Feeds LocalBusiness schema. |
| 122 |
'local_seo_enabled' => self::boolean( __( 'Whether Local SEO output and LocalBusiness schema are enabled.', 'thinkrank' ) ), |
| 123 |
'business_name' => self::string( __( 'Registered business name.', 'thinkrank' ) ), |
| 124 |
// Enumerated rather than free-form: the value goes straight into |
| 125 |
// LocalBusiness schema, so an invented type is invalid structured |
| 126 |
// data. ~150 schema.org subtypes are accepted (#623). |
| 127 |
// |
| 128 |
// '' is in the list because it is a real stored state ("not set"): |
| 129 |
// the store holds it on every site that never opened Local SEO, and |
| 130 |
// without it the READ ability failed its own output schema on those |
| 131 |
// sites and there was no way to clear the value over MCP. It goes |
| 132 |
// last so the root stays first, which read() falls back to. |
| 133 |
'business_type' => [ |
| 134 |
'type' => 'string', |
| 135 |
'enum' => array_merge( \ThinkRank\Config\Local_Business_Types_Config::get_types(), [ '' ] ), |
| 136 |
'description' => __( 'schema.org LocalBusiness type, e.g. "Restaurant", "HealthAndBeautyBusiness". "LocalBusiness" is the general-purpose default and is always valid. An empty string means not set, and is published as LocalBusiness.', 'thinkrank' ), |
| 137 |
], |
| 138 |
'business_email' => self::string( __( 'Public contact email address.', 'thinkrank' ) ), |
| 139 |
'business_phone' => self::string( __( 'Public contact telephone number.', 'thinkrank' ) ), |
| 140 |
'business_address' => self::string( __( 'Street address.', 'thinkrank' ) ), |
| 141 |
'business_city' => self::string( __( 'City or locality.', 'thinkrank' ) ), |
| 142 |
'business_state' => self::string( __( 'State, province or region.', 'thinkrank' ) ), |
| 143 |
'business_country' => self::string( __( 'Country.', 'thinkrank' ) ), |
| 144 |
'business_postal_code' => self::string( __( 'Postal or ZIP code.', 'thinkrank' ) ), |
| 145 |
'business_latitude' => self::string( __( 'Latitude of the business location, in decimal degrees.', 'thinkrank' ) ), |
| 146 |
'business_longitude' => self::string( __( 'Longitude of the business location, in decimal degrees.', 'thinkrank' ) ), |
| 147 |
'business_price_range' => self::string( __( 'Price range indicator, e.g. "$$".', 'thinkrank' ) ), |
| 148 |
'business_hours' => self::business_hours(), |
| 149 |
|
| 150 |
// Indexing. |
| 151 |
'allow_search_engines' => self::boolean( __( 'Whether search engines are allowed to index the site.', 'thinkrank' ) ), |
| 152 |
'query_protection' => self::boolean( __( 'Whether a URL whose content selector resolved to nothing (for example ?post_type=nosuchtype) answers 404 instead of serving the blog listing at 200.', 'thinkrank' ) ), |
| 153 |
'canonical_scheme' => [ |
| 154 |
'type' => 'string', |
| 155 |
'description' => __( 'Scheme for canonical URLs, og:url, schema @ids and sitemap entries. "automatic" follows WordPress; the other two override it, for a site behind a proxy that terminates TLS and leaves WordPress reporting the wrong scheme.', 'thinkrank' ), |
| 156 |
'enum' => \ThinkRank\SEO\Url_Scheme::MODES, |
| 157 |
], |
| 158 |
'robots_txt_enabled' => self::boolean( __( 'Whether ThinkRank manages robots.txt. Its contents are set with thinkrank/update-robots-txt.', 'thinkrank' ) ), |
| 159 |
|
| 160 |
// RSS feeds. |
| 161 |
'feed_excerpt_only' => self::boolean( __( 'Whether feed entries are shortened to an excerpt instead of carrying the full post.', 'thinkrank' ) ), |
| 162 |
'feed_source_link' => self::boolean( __( 'Whether each feed entry is signed with a link back to the original post and the site.', 'thinkrank' ) ), |
| 163 |
'feed_noindex' => self::boolean( __( 'Whether feeds are served with X-Robots-Tag: noindex. Leave off for a podcast feed, which needs to be indexable.', 'thinkrank' ) ), |
| 164 |
'ai_crawler_rules' => self::ai_crawler_rules(), |
| 165 |
]; |
| 166 |
} |
| 167 |
|
| 168 |
/** |
| 169 |
* JSON schema properties for every exposed `sitemap` key. |
| 170 |
* |
| 171 |
* @return array<string, array<string, mixed>> |
| 172 |
*/ |
| 173 |
public static function sitemap(): array { |
| 174 |
return [ |
| 175 |
'enabled' => self::boolean( __( 'Whether XML sitemap generation is active.', 'thinkrank' ) ), |
| 176 |
'delivery_mode' => [ |
| 177 |
'type' => 'string', |
| 178 |
'enum' => \ThinkRank\SEO\Sitemap_Generator::DELIVERY_MODES, |
| 179 |
'description' => __( 'How the sitemap reaches crawlers. "auto" writes files when the WordPress root is writable and serves the sitemap from WordPress when it is not. "static" always writes files, and fails where that is not possible. "dynamic" always serves from WordPress and writes nothing.', 'thinkrank' ), |
| 180 |
], |
| 181 |
'auto_generate' => self::boolean( __( 'Whether the sitemap regenerates automatically when content changes.', 'thinkrank' ) ), |
| 182 |
'use_sitemap_index' => self::boolean( __( 'Whether to publish a sitemap index that links per-type sitemaps, rather than one flat file.', 'thinkrank' ) ), |
| 183 |
'links_per_sitemap' => [ |
| 184 |
'type' => 'integer', |
| 185 |
'description' => __( 'Maximum URLs per sitemap file before it is split.', 'thinkrank' ), |
| 186 |
'minimum' => 1, |
| 187 |
'maximum' => 50000, |
| 188 |
], |
| 189 |
'custom_url_pattern' => self::string( __( 'Filename pattern for generated sitemaps, e.g. "sitemap-{type}.xml".', 'thinkrank' ) ), |
| 190 |
'enable_styling' => self::boolean( __( 'Whether an XSL stylesheet is attached so the sitemap is readable in a browser.', 'thinkrank' ) ), |
| 191 |
'ping_search_engines' => self::boolean( __( 'Whether search engines are notified after the sitemap is regenerated.', 'thinkrank' ) ), |
| 192 |
|
| 193 |
// How the styled sitemap looks. All four need enable_styling on. |
| 194 |
'styling_logo' => self::boolean( __( 'Whether a logo is shown above the sitemap heading. Requires enable_styling.', 'thinkrank' ) ), |
| 195 |
'styling_logo_url' => self::string( __( 'URL of the sitemap logo image. Empty falls back to the site icon.', 'thinkrank' ) ), |
| 196 |
'styling_color_main' => self::string( __( 'Hex colour ("#rrggbb") for the sitemap header, links and table head. Empty keeps the stock palette.', 'thinkrank' ) ), |
| 197 |
'styling_color_accent' => self::string( __( 'Hex colour ("#rrggbb") for the header gradient end and link hovers. Empty keeps the stock palette.', 'thinkrank' ) ), |
| 198 |
|
| 199 |
// What goes in. |
| 200 |
'include_posts' => self::boolean( __( 'Whether posts are included.', 'thinkrank' ) ), |
| 201 |
'include_pages' => self::boolean( __( 'Whether pages are included.', 'thinkrank' ) ), |
| 202 |
'include_categories' => self::boolean( __( 'Whether category archives are included.', 'thinkrank' ) ), |
| 203 |
'include_tags' => self::boolean( __( 'Whether tag archives are included.', 'thinkrank' ) ), |
| 204 |
'include_images' => self::boolean( __( 'Whether image entries are included for each URL.', 'thinkrank' ) ), |
| 205 |
'include_featured_images' => self::boolean( __( 'Whether featured images are included as image entries.', 'thinkrank' ) ), |
| 206 |
|
| 207 |
// What stays out. |
| 208 |
'exclude_posts' => self::string( __( 'Comma-separated post IDs to leave out.', 'thinkrank' ) ), |
| 209 |
'exclude_terms' => self::string( __( 'Comma-separated term IDs to leave out.', 'thinkrank' ) ), |
| 210 |
'exclude_private_posts' => self::boolean( __( 'Whether privately published posts are left out.', 'thinkrank' ) ), |
| 211 |
'exclude_password_protected' => self::boolean( __( 'Whether password-protected posts are left out.', 'thinkrank' ) ), |
| 212 |
]; |
| 213 |
} |
| 214 |
|
| 215 |
/** |
| 216 |
* Read the exposed keys out of a manager's stored settings. |
| 217 |
* |
| 218 |
* The store keeps everything as strings ("1"/""), so each value is coerced |
| 219 |
* back to the type the schema advertises before it reaches an agent. |
| 220 |
* |
| 221 |
* The same properties are the read ability's OUTPUT schema, which the |
| 222 |
* Abilities API validates, and one value that fails it fails the whole |
| 223 |
* call. So what comes out has to fit the schema for any stored value, not |
| 224 |
* only for what today's save path writes: a business type imported before |
| 225 |
* the list was enumerated, or a crawler rule whose crawler a filter has |
| 226 |
* since removed, used to turn every get-site-identity-settings call into |
| 227 |
* ability_invalid_output. Hence the recursion into objects, and the enum |
| 228 |
* fallback in read_value(). |
| 229 |
* |
| 230 |
* @param array<string, array<string, mixed>> $properties Schema properties for the category. |
| 231 |
* @param array<string, mixed> $stored Settings as the manager returns them. |
| 232 |
* @return array<string, mixed> Exposed settings, one entry per declared key. |
| 233 |
*/ |
| 234 |
public static function read( array $properties, array $stored ): array { |
| 235 |
$out = []; |
| 236 |
|
| 237 |
foreach ( $properties as $key => $property ) { |
| 238 |
$out[ $key ] = self::read_value( $property, $stored[ $key ] ?? null ); |
| 239 |
} |
| 240 |
|
| 241 |
return $out; |
| 242 |
} |
| 243 |
|
| 244 |
/** |
| 245 |
* Coerce one stored value to the shape its property declares. |
| 246 |
* |
| 247 |
* An enumerated string that holds something outside its enum reads as the |
| 248 |
* enum's FIRST entry. Every enum in this map is ordered so that entry is |
| 249 |
* the value its manager falls back to for anything unrecognised |
| 250 |
* (`automatic`, `auto`, `allow`, `LocalBusiness`), so the agent is told |
| 251 |
* what the site actually does rather than a value it would be refused if |
| 252 |
* it wrote it back. |
| 253 |
* |
| 254 |
* @since 2.10.0 |
| 255 |
* |
| 256 |
* @param array<string, mixed> $property Schema property. |
| 257 |
* @param mixed $value Stored value, or null when absent. |
| 258 |
* @return mixed |
| 259 |
*/ |
| 260 |
private static function read_value( array $property, $value ) { |
| 261 |
$type = $property['type'] ?? 'string'; |
| 262 |
|
| 263 |
// A union type ('string' or a list of them) keeps whichever shape |
| 264 |
// it arrived in: casting to string would flatten a list, and |
| 265 |
// casting to array would replace a name with [] (#692). |
| 266 |
if ( is_array( $type ) ) { |
| 267 |
return is_array( $value ) |
| 268 |
? array_values( array_map( 'strval', array_filter( $value, 'is_scalar' ) ) ) |
| 269 |
: ( is_scalar( $value ) ? (string) $value : '' ); |
| 270 |
} |
| 271 |
|
| 272 |
switch ( $type ) { |
| 273 |
case 'boolean': |
| 274 |
return (bool) $value; |
| 275 |
case 'integer': |
| 276 |
return (int) $value; |
| 277 |
case 'array': |
| 278 |
if ( ! is_array( $value ) ) { |
| 279 |
return []; |
| 280 |
} |
| 281 |
if ( isset( $property['items'] ) && is_array( $property['items'] ) ) { |
| 282 |
$items = $property['items']; |
| 283 |
return array_values( array_map( static fn( $item ) => self::read_value( $items, $item ), $value ) ); |
| 284 |
} |
| 285 |
return $value; |
| 286 |
case 'object': |
| 287 |
if ( ! is_array( $value ) ) { |
| 288 |
return []; |
| 289 |
} |
| 290 |
if ( empty( $property['properties'] ) || ! is_array( $property['properties'] ) ) { |
| 291 |
return $value; |
| 292 |
} |
| 293 |
|
| 294 |
$declared = $property['properties']; |
| 295 |
$closed = isset( $property['additionalProperties'] ) && false === $property['additionalProperties']; |
| 296 |
$object = []; |
| 297 |
|
| 298 |
foreach ( $value as $name => $item ) { |
| 299 |
if ( isset( $declared[ $name ] ) ) { |
| 300 |
$object[ $name ] = self::read_value( $declared[ $name ], $item ); |
| 301 |
} elseif ( ! $closed ) { |
| 302 |
$object[ $name ] = $item; |
| 303 |
} |
| 304 |
} |
| 305 |
|
| 306 |
return $object; |
| 307 |
default: |
| 308 |
$string = is_scalar( $value ) ? (string) $value : ''; |
| 309 |
|
| 310 |
if ( ! empty( $property['enum'] ) && ! in_array( $string, $property['enum'], true ) ) { |
| 311 |
return (string) reset( $property['enum'] ); |
| 312 |
} |
| 313 |
|
| 314 |
return $string; |
| 315 |
} |
| 316 |
} |
| 317 |
|
| 318 |
/** |
| 319 |
* Coerce an incoming patch to the declared types, dropping unknown keys. |
| 320 |
* |
| 321 |
* Strings are passed through rather than sanitized here: the manager's own |
| 322 |
* save path already picks the right sanitizer per key, and running |
| 323 |
* sanitize_text_field() first would strip %date% and %category% out of the |
| 324 |
* title templates as percent-encoding before it ever got the chance (#521). |
| 325 |
* |
| 326 |
* @param array<string, array<string, mixed>> $properties Schema properties for the category. |
| 327 |
* @param array<string, mixed> $incoming Caller-supplied settings. |
| 328 |
* @return array<string, mixed> Recognized keys only, coerced to type. |
| 329 |
*/ |
| 330 |
public static function coerce( array $properties, array $incoming ): array { |
| 331 |
$out = []; |
| 332 |
|
| 333 |
foreach ( $properties as $key => $property ) { |
| 334 |
if ( ! array_key_exists( $key, $incoming ) ) { |
| 335 |
continue; |
| 336 |
} |
| 337 |
|
| 338 |
$value = $incoming[ $key ]; |
| 339 |
|
| 340 |
$type = $property['type'] ?? 'string'; |
| 341 |
|
| 342 |
// A union type ('string' or a list of them) keeps whichever shape |
| 343 |
// it arrived in: casting to string would flatten a list, and |
| 344 |
// casting to array would replace a name with [] (#692). |
| 345 |
if ( is_array( $type ) ) { |
| 346 |
$out[ $key ] = is_array( $value ) |
| 347 |
? array_values( array_map( 'strval', $value ) ) |
| 348 |
: (string) ( $value ?? '' ); |
| 349 |
continue; |
| 350 |
} |
| 351 |
|
| 352 |
switch ( $type ) { |
| 353 |
case 'boolean': |
| 354 |
$out[ $key ] = (bool) $value; |
| 355 |
break; |
| 356 |
case 'integer': |
| 357 |
$number = (int) $value; |
| 358 |
if ( isset( $property['minimum'] ) ) { |
| 359 |
$number = max( (int) $property['minimum'], $number ); |
| 360 |
} |
| 361 |
if ( isset( $property['maximum'] ) ) { |
| 362 |
$number = min( (int) $property['maximum'], $number ); |
| 363 |
} |
| 364 |
$out[ $key ] = $number; |
| 365 |
break; |
| 366 |
case 'array': |
| 367 |
case 'object': |
| 368 |
if ( ! is_array( $value ) ) { |
| 369 |
// A structured key given a scalar is a caller error, not |
| 370 |
// something to flatten into a string and store. |
| 371 |
continue 2; |
| 372 |
} |
| 373 |
$out[ $key ] = $value; |
| 374 |
break; |
| 375 |
default: |
| 376 |
if ( is_array( $value ) ) { |
| 377 |
continue 2; |
| 378 |
} |
| 379 |
$out[ $key ] = (string) $value; |
| 380 |
} |
| 381 |
} |
| 382 |
|
| 383 |
return $out; |
| 384 |
} |
| 385 |
|
| 386 |
/** |
| 387 |
* The opening hours object, one entry per day. |
| 388 |
* |
| 389 |
* A real sub-schema rather than string coercion: the value is a map of day |
| 390 |
* name to {open, close, closed}, and flattening it to a string would make |
| 391 |
* it unwritable over MCP. |
| 392 |
* |
| 393 |
* @return array<string, mixed> |
| 394 |
*/ |
| 395 |
private static function business_hours(): array { |
| 396 |
$day = [ |
| 397 |
'type' => 'object', |
| 398 |
'additionalProperties' => false, |
| 399 |
'properties' => [ |
| 400 |
'open' => [ |
| 401 |
'type' => 'string', |
| 402 |
'description' => __( 'Opening time as 24-hour HH:MM, or "" when closed.', 'thinkrank' ), |
| 403 |
], |
| 404 |
'close' => [ |
| 405 |
'type' => 'string', |
| 406 |
'description' => __( 'Closing time as 24-hour HH:MM, or "" when closed.', 'thinkrank' ), |
| 407 |
], |
| 408 |
'closed' => [ |
| 409 |
'type' => 'boolean', |
| 410 |
'description' => __( 'Whether the business is closed all day.', 'thinkrank' ), |
| 411 |
], |
| 412 |
], |
| 413 |
]; |
| 414 |
|
| 415 |
$properties = []; |
| 416 |
foreach ( [ 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday' ] as $name ) { |
| 417 |
$properties[ $name ] = $day; |
| 418 |
} |
| 419 |
|
| 420 |
return [ |
| 421 |
'type' => 'object', |
| 422 |
'description' => __( 'Opening hours per day of the week.', 'thinkrank' ), |
| 423 |
'additionalProperties' => false, |
| 424 |
'properties' => $properties, |
| 425 |
]; |
| 426 |
} |
| 427 |
|
| 428 |
/** |
| 429 |
* The per-agent AI crawler allow/block map. |
| 430 |
* |
| 431 |
* Enumerating the known slugs rather than accepting a free-form object is |
| 432 |
* what makes this usable by an agent: the alternative is a caller guessing |
| 433 |
* `chatgpt` for a crawler registered as `chatgpt-user`, having the key |
| 434 |
* dropped as unknown, and being told the save succeeded — because it did, |
| 435 |
* with nothing in it. |
| 436 |
* |
| 437 |
* @return array<string, mixed> |
| 438 |
*/ |
| 439 |
private static function ai_crawler_rules(): array { |
| 440 |
$properties = []; |
| 441 |
|
| 442 |
foreach ( \ThinkRank\SEO\AI_Crawlers::for_display() as $agent ) { |
| 443 |
$properties[ $agent['slug'] ] = [ |
| 444 |
'type' => 'string', |
| 445 |
'enum' => [ 'allow', 'block' ], |
| 446 |
/* translators: 1: crawler user-agent token, e.g. GPTBot. 2: what that crawler is for. */ |
| 447 |
'description' => sprintf( __( '%1$s — %2$s', 'thinkrank' ), $agent['token'], $agent['purpose'] ), |
| 448 |
]; |
| 449 |
} |
| 450 |
|
| 451 |
return [ |
| 452 |
'type' => 'object', |
| 453 |
'description' => __( 'Per-agent AI crawler rules. "block" writes a User-agent/Disallow pair for that crawler into robots.txt; "allow" (the default for any crawler not listed) writes nothing. Blocking Google-Extended does not affect normal Google Search indexing.', 'thinkrank' ), |
| 454 |
'additionalProperties' => false, |
| 455 |
'properties' => $properties, |
| 456 |
]; |
| 457 |
} |
| 458 |
|
| 459 |
/** |
| 460 |
* A boolean property. |
| 461 |
* |
| 462 |
* @param string $description Translated text describing what the toggle does. |
| 463 |
* @return array<string, mixed> |
| 464 |
*/ |
| 465 |
/** |
| 466 |
* The site's alternate name, as one value or several. |
| 467 |
* |
| 468 |
* schema.org and Google both allow `alternateName` to carry a list, and the |
| 469 |
* store already round-trips either shape, so the schema says so rather than |
| 470 |
* forcing a caller to pick one name and drop the rest (#692). |
| 471 |
* |
| 472 |
* @since 2.7.0 |
| 473 |
* @return array<string, mixed> |
| 474 |
*/ |
| 475 |
private static function alternate_name(): array { |
| 476 |
return [ |
| 477 |
// A union rather than anyOf: read() and coerce() switch on `type`, |
| 478 |
// and an entry without one is dropped as unrecognised. WordPress's |
| 479 |
// schema validator accepts a type list, so this is both valid JSON |
| 480 |
// Schema and legible to this file's own consumers. |
| 481 |
'type' => [ 'string', 'array' ], |
| 482 |
'items' => [ 'type' => 'string' ], |
| 483 |
'description' => __( 'Alternate or former name of the site, published as schema alternateName on the homepage WebSite node. Send a string for one name, or an array for several. Blank entries and duplicates are dropped, and a single surviving name is published as a string.', 'thinkrank' ), |
| 484 |
]; |
| 485 |
} |
| 486 |
|
| 487 |
private static function boolean( string $description ): array { |
| 488 |
return [ |
| 489 |
'type' => 'boolean', |
| 490 |
'description' => $description, |
| 491 |
]; |
| 492 |
} |
| 493 |
|
| 494 |
/** |
| 495 |
* A string property. |
| 496 |
* |
| 497 |
* @param string $description Translated text describing the value. |
| 498 |
* @return array<string, mixed> |
| 499 |
*/ |
| 500 |
private static function string( string $description ): array { |
| 501 |
return [ |
| 502 |
'type' => 'string', |
| 503 |
'description' => $description, |
| 504 |
]; |
| 505 |
} |
| 506 |
|
| 507 |
/** |
| 508 |
* A %token% title template property. |
| 509 |
* |
| 510 |
* The vocabulary here is Site Identity's, which is not the one the Global |
| 511 |
* SEO per-post-type templates use — %site_title% rather than %title%, |
| 512 |
* %site_name% rather than %sitename% — so the description spells it out |
| 513 |
* instead of leaving an agent to guess between the two. |
| 514 |
* |
| 515 |
* @param string $what Translated name of the pages the template titles. |
| 516 |
* @param string $extra Comma-separated tags available only on those pages, or ''. |
| 517 |
* @return array<string, mixed> |
| 518 |
*/ |
| 519 |
private static function template( string $what, string $extra ): array { |
| 520 |
$shared = '%site_title%, %site_name%, %site_description%, %tagline%, %sep%, %separator%, %date%'; |
| 521 |
|
| 522 |
$description = '' === $extra |
| 523 |
/* translators: 1: the pages a title template applies to. 2: the list of available variable tags. */ |
| 524 |
? sprintf( __( 'Title template for %1$s. Available tags: %2$s.', 'thinkrank' ), $what, $shared ) |
| 525 |
/* translators: 1: the pages a title template applies to. 2: tags available everywhere. 3: tags available only on those pages. */ |
| 526 |
: sprintf( __( 'Title template for %1$s. Available tags: %2$s, and on these pages also %3$s.', 'thinkrank' ), $what, $shared, $extra ); |
| 527 |
|
| 528 |
return [ |
| 529 |
'type' => 'string', |
| 530 |
'description' => $description, |
| 531 |
]; |
| 532 |
} |
| 533 |
} |
| 534 |
|
