@wp-typia/project-tools 0.11.1

package/templates/_shared/persistence/auth/{{slugKebabCase}}.php.mustache

@@ -0,0 +1,290 @@
+<?php
+/**
+ * Plugin Name:       {{title}}
+ * Description:       {{description}}
+ * Version:           0.1.0
+ * Requires at least: 6.7
+ * Tested up to:      6.9
+ * Requires PHP:      8.0
+ * Author:            {{author}}
+ * License:           GPL-2.0-or-later
+ * License URI:       https://www.gnu.org/licenses/gpl-2.0.html
+ * Text Domain:       {{textDomain}}
+ * Domain Path:       /languages
+ */
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit;
+}
+
+function {{phpPrefix}}_load_textdomain() {
+	load_plugin_textdomain(
+		'{{textDomain}}',
+		false,
+		dirname( plugin_basename( __FILE__ ) ) . '/languages'
+	);
+}
+
+define( '{{phpPrefixUpper}}_DATA_STORAGE_MODE', '{{dataStorageMode}}' );
+// These helper files are scaffold-owned plumbing. Customize them only when you are changing auth or request validation behavior.
+require_once __DIR__ . '/inc/rest-shared.php';
+require_once __DIR__ . '/inc/rest-auth.php';
+
+function {{phpPrefix}}_get_build_dir() {
+	$candidates = array(
+		__DIR__ . '/build',
+		__DIR__ . '/build/{{slugKebabCase}}',
+	);
+
+	foreach ( $candidates as $candidate ) {
+		if ( file_exists( $candidate . '/block.json' ) ) {
+			return $candidate;
+		}
+	}
+
+	return null;
+}
+
+function {{phpPrefix}}_get_counter_table_name() {
+	global $wpdb;
+	return $wpdb->prefix . '{{phpPrefix}}_counters';
+}
+
+function {{phpPrefix}}_get_counter_lock_name( $post_id, $resource_key ) {
+	return 'wpt_pcl_' . md5(
+		'{{phpPrefix}}|' . (int) $post_id . '|' . (string) $resource_key
+	);
+}
+
+function {{phpPrefix}}_with_counter_lock( $post_id, $resource_key, $callback ) {
+	global $wpdb;
+
+	$lock_name = {{phpPrefix}}_get_counter_lock_name( $post_id, $resource_key );
+	$acquired  = (int) $wpdb->get_var(
+		$wpdb->prepare(
+			'SELECT GET_LOCK(%s, 5)',
+			$lock_name
+		)
+	);
+
+	if ( 1 !== $acquired ) {
+		return new WP_Error( 'counter_lock_timeout', 'Could not acquire the counter lock.', array( 'status' => 503 ) );
+	}
+
+	try {
+		return $callback();
+	} finally {
+		$wpdb->get_var(
+			$wpdb->prepare(
+				'SELECT RELEASE_LOCK(%s)',
+				$lock_name
+			)
+		);
+	}
+}
+
+function {{phpPrefix}}_maybe_install_storage() {
+	if ( 'custom-table' !== '{{dataStorageMode}}' ) {
+		return;
+	}
+
+	global $wpdb;
+	require_once ABSPATH . 'wp-admin/includes/upgrade.php';
+
+	$table_name      = {{phpPrefix}}_get_counter_table_name();
+	$charset_collate = $wpdb->get_charset_collate();
+	$sql             = "CREATE TABLE {$table_name} (
+		post_id bigint(20) unsigned NOT NULL,
+		resource_key varchar(100) NOT NULL,
+		count bigint(20) unsigned NOT NULL DEFAULT 0,
+		updated_at datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
+		PRIMARY KEY  (post_id, resource_key)
+	) {$charset_collate};";
+
+	dbDelta( $sql );
+	$table_exists = $wpdb->get_var(
+		$wpdb->prepare(
+			'SHOW TABLES LIKE %s',
+			$table_name
+		)
+	);
+
+	if ( $table_name === $table_exists ) {
+		update_option( '{{phpPrefix}}_storage_version', '1.0.0' );
+	}
+}
+
+function {{phpPrefix}}_ensure_storage_installed() {
+	if ( 'custom-table' === '{{dataStorageMode}}' && '1.0.0' !== get_option( '{{phpPrefix}}_storage_version', '' ) ) {
+		{{phpPrefix}}_maybe_install_storage();
+	}
+}
+
+function {{phpPrefix}}_get_rest_build_dir() {
+	return {{phpPrefix}}_get_build_dir();
+}
+
+function {{phpPrefix}}_get_counter( $post_id, $resource_key ) {
+	global $wpdb;
+
+	if ( 'custom-table' === '{{dataStorageMode}}' ) {
+		$table_name = {{phpPrefix}}_get_counter_table_name();
+		$count      = $wpdb->get_var(
+			$wpdb->prepare(
+				// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Table name comes from an internal helper.
+				"SELECT count FROM {$table_name} WHERE post_id = %d AND resource_key = %s",
+				$post_id,
+				$resource_key
+			)
+		);
+
+		return null === $count ? 0 : (int) $count;
+	}
+
+	$meta_key = '_' . '{{phpPrefix}}' . '_counter_' . sanitize_key( $resource_key );
+	return (int) get_post_meta( $post_id, $meta_key, true );
+}
+
+// Customize storage helpers here when you need a different backend or aggregate behavior.
+function {{phpPrefix}}_increment_counter( $post_id, $resource_key, $delta ) {
+	global $wpdb;
+
+	if ( 'custom-table' === '{{dataStorageMode}}' ) {
+		$table_name    = {{phpPrefix}}_get_counter_table_name();
+		$delta_value   = (int) $delta;
+		$initial_count = max( 0, $delta_value );
+		$result        = $wpdb->query(
+			$wpdb->prepare(
+				// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Table name comes from an internal helper.
+				"INSERT INTO {$table_name} (post_id, resource_key, count, updated_at)
+				VALUES (%d, %s, %d, %s)
+				ON DUPLICATE KEY UPDATE
+					count = GREATEST(0, count + %d),
+					updated_at = VALUES(updated_at)",
+				$post_id,
+				$resource_key,
+				$initial_count,
+				current_time( 'mysql', true ),
+				$delta_value
+			)
+		);
+
+		if ( false === $result ) {
+			return new WP_Error( 'counter_update_failed', 'Failed to update the counter.', array( 'status' => 500 ) );
+		}
+
+		return {{phpPrefix}}_get_counter( $post_id, $resource_key );
+	}
+
+	return {{phpPrefix}}_with_counter_lock(
+		$post_id,
+		$resource_key,
+		function () use ( $delta, $post_id, $resource_key ) {
+			$meta_key   = '_' . '{{phpPrefix}}' . '_counter_' . sanitize_key( $resource_key );
+			$next_count = max( 0, {{phpPrefix}}_get_counter( $post_id, $resource_key ) + (int) $delta );
+			update_post_meta( $post_id, $meta_key, $next_count );
+			return $next_count;
+		}
+	);
+}
+
+function {{phpPrefix}}_build_state_response( $post_id, $resource_key, $count ) {
+	return array(
+		'postId'      => (int) $post_id,
+		'resourceKey' => (string) $resource_key,
+		'count'       => (int) $count,
+		'storage'     => '{{dataStorageMode}}',
+	);
+}
+
+// Route handlers are the main product-level extension point for request/response shaping.
+function {{phpPrefix}}_handle_get_state( WP_REST_Request $request ) {
+	$payload = {{phpPrefix}}_validate_and_sanitize_request(
+		array(
+			'postId'      => $request->get_param( 'postId' ),
+			'resourceKey' => $request->get_param( 'resourceKey' ),
+		),
+		{{phpPrefix}}_get_rest_build_dir(),
+		'state-query',
+		'query'
+	);
+
+	if ( is_wp_error( $payload ) ) {
+		return $payload;
+	}
+
+	$count = {{phpPrefix}}_get_counter( (int) $payload['postId'], (string) $payload['resourceKey'] );
+	return rest_ensure_response(
+		{{phpPrefix}}_build_state_response(
+			(int) $payload['postId'],
+			(string) $payload['resourceKey'],
+			$count
+		)
+	);
+}
+
+function {{phpPrefix}}_handle_write_state( WP_REST_Request $request ) {
+	$payload = {{phpPrefix}}_validate_and_sanitize_request(
+		$request->get_json_params(),
+		{{phpPrefix}}_get_rest_build_dir(),
+		'write-state-request',
+		'body'
+	);
+
+	if ( is_wp_error( $payload ) ) {
+		return $payload;
+	}
+
+	$count = {{phpPrefix}}_increment_counter(
+		(int) $payload['postId'],
+		(string) $payload['resourceKey'],
+		isset( $payload['delta'] ) ? (int) $payload['delta'] : 1
+	);
+
+	if ( is_wp_error( $count ) ) {
+		return $count;
+	}
+
+	return rest_ensure_response(
+		{{phpPrefix}}_build_state_response(
+			(int) $payload['postId'],
+			(string) $payload['resourceKey'],
+			$count
+		)
+	);
+}
+
+// Add or reorganize endpoints here as the REST surface grows.
+function {{phpPrefix}}_register_routes() {
+	register_rest_route(
+		'{{namespace}}/v1',
+		'/{{slugKebabCase}}/state',
+		array(
+			array(
+				'methods'             => WP_REST_Server::READABLE,
+				'callback'            => '{{phpPrefix}}_handle_get_state',
+				'permission_callback' => '__return_true',
+			),
+			array(
+				'methods'             => WP_REST_Server::CREATABLE,
+				'callback'            => '{{phpPrefix}}_handle_write_state',
+				'permission_callback' => '{{phpPrefix}}_can_write_authenticated',
+			),
+		)
+	);
+}
+
+function {{phpPrefix}}_register_block() {
+	$build_dir = {{phpPrefix}}_get_build_dir();
+	if ( ! $build_dir ) {
+		return;
+	}
+
+	register_block_type( $build_dir );
+}
+
+register_activation_hook( __FILE__, '{{phpPrefix}}_maybe_install_storage' );
+add_action( 'init', '{{phpPrefix}}_load_textdomain' );
+add_action( 'init', '{{phpPrefix}}_ensure_storage_installed' );
+add_action( 'init', '{{phpPrefix}}_register_block' );
+add_action( 'rest_api_init', '{{phpPrefix}}_register_routes' );

package/templates/_shared/persistence/core/package.json.mustache

@@ -0,0 +1,46 @@
+{
+	"name": "{{slug}}",
+	"version": "0.1.0",
+	"packageManager": "bun@1.3.10",
+	"description": "{{description}}",
+	"author": "{{author}}",
+	"license": "GPL-2.0-or-later",
+	"main": "build/index.js",
+	"scripts": {
+		"sync-types": "tsx scripts/sync-types-to-block-json.ts",
+		"sync-rest": "tsx scripts/sync-rest-contracts.ts",
+		"build": "bun run sync-types --check && bun run sync-rest --check && wp-scripts build --experimental-modules",
+		"start": "bun run sync-types && bun run sync-rest && wp-scripts start --experimental-modules",
+		"dev": "bun run start",
+		"lint:js": "wp-scripts lint-js",
+		"lint:css": "wp-scripts lint-style",
+		"lint": "bun run lint:js && bun run lint:css",
+		"format": "wp-scripts format",
+		"typecheck": "bun run sync-types --check && bun run sync-rest --check && tsc --noEmit"
+	},
+	"devDependencies": {
+		"@wp-typia/block-runtime": "{{blockRuntimePackageVersion}}",
+		"@wp-typia/api-client": "{{apiClientPackageVersion}}",
+		"@wp-typia/block-types": "{{blockTypesPackageVersion}}",
+		"@wp-typia/rest": "{{restPackageVersion}}",
+		"ajv": "^8.18.0",
+		"@types/wordpress__block-editor": "^11.5.17",
+		"@types/wordpress__blocks": "^12.5.18",
+		"@wordpress/browserslist-config": "^6.42.0",
+		"@wordpress/scripts": "^30.22.0",
+		"eslint-plugin-jsx-a11y": "^6.10.2",
+		"@typia/unplugin": "^12.0.1",
+		"tsx": "^4.20.5",
+		"typescript": "^5.9.2",
+		"typia": "^12.0.1"
+	},
+	"dependencies": {
+		"@wordpress/api-fetch": "^7.42.0",
+		"@wordpress/block-editor": "^15.2.0",
+		"@wordpress/blocks": "^15.2.0",
+		"@wordpress/components": "^30.2.0",
+		"@wordpress/element": "^6.29.0",
+		"@wordpress/i18n": "^6.2.0",
+		"@wordpress/interactivity": "^6.29.0"
+	}
+}

package/templates/_shared/persistence/core/scripts/sync-rest-contracts.ts.mustache

@@ -0,0 +1,113 @@
+/* eslint-disable no-console */
+import {
+	defineEndpointManifest,
+	syncEndpointClient,
+	syncRestOpenApi,
+	syncTypeSchemas,
+} from '@wp-typia/block-runtime/metadata-core';
+
+function parseCliOptions( argv: string[] ) {
+	const options = {
+		check: false,
+	};
+
+	for ( const argument of argv ) {
+		if ( argument === '--check' ) {
+			options.check = true;
+			continue;
+		}
+
+		throw new Error( `Unknown sync-rest flag: ${ argument }` );
+	}
+
+	return options;
+}
+
+const REST_ENDPOINT_MANIFEST = defineEndpointManifest( {
+	contracts: {
+		'state-query': {
+			sourceTypeName: '{{pascalCase}}StateQuery',
+		},
+		'write-state-request': {
+			sourceTypeName: '{{pascalCase}}WriteStateRequest',
+		},
+		'state-response': {
+			sourceTypeName: '{{pascalCase}}StateResponse',
+		},
+	},
+	endpoints: [
+		{
+			auth: 'public',
+			method: 'GET',
+			operationId: 'get{{pascalCase}}State',
+			path: '/{{namespace}}/v1/{{slugKebabCase}}/state',
+			queryContract: 'state-query',
+			responseContract: 'state-response',
+			summary: 'Read the current persisted state.',
+			tags: [ '{{title}}' ],
+		},
+		{
+			auth: '{{restWriteAuthIntent}}',
+			bodyContract: 'write-state-request',
+			method: 'POST',
+			operationId: 'write{{pascalCase}}State',
+			path: '/{{namespace}}/v1/{{slugKebabCase}}/state',
+			responseContract: 'state-response',
+			summary: 'Write the current persisted state.',
+			tags: [ '{{title}}' ],
+			wordpressAuth: {
+				mechanism: '{{restWriteAuthMechanism}}',
+			},
+		},
+	],
+	info: {
+		title: '{{title}} REST API',
+		version: '1.0.0',
+	},
+} );
+
+async function main() {
+	const options = parseCliOptions( process.argv.slice( 2 ) );
+
+	for ( const [ baseName, contract ] of Object.entries( REST_ENDPOINT_MANIFEST.contracts ) ) {
+		await syncTypeSchemas( {
+			jsonSchemaFile: `src/api-schemas/${ baseName }.schema.json`,
+			openApiFile: `src/api-schemas/${ baseName }.openapi.json`,
+			openApiInfo: {
+				title: `${ contract.sourceTypeName }`,
+				version: '1.0.0',
+			},
+			sourceTypeName: contract.sourceTypeName,
+			typesFile: 'src/api-types.ts',
+		}, {
+			check: options.check,
+		} );
+	}
+
+	await syncRestOpenApi( {
+		manifest: REST_ENDPOINT_MANIFEST,
+		openApiFile: 'src/api.openapi.json',
+		typesFile: 'src/api-types.ts',
+	}, {
+		check: options.check,
+	} );
+
+	await syncEndpointClient( {
+		clientFile: 'src/api-client.ts',
+		manifest: REST_ENDPOINT_MANIFEST,
+		typesFile: 'src/api-types.ts',
+	}, {
+		check: options.check,
+	} );
+
+	console.log(
+		options.check
+			? '✅ REST schemas, portable API clients, and endpoint-aware OpenAPI documents are already up to date with the TypeScript contracts!'
+			: '✅ REST schemas, portable API clients, and endpoint-aware OpenAPI documents were generated from TypeScript contracts!'
+	);
+}
+
+main().catch( ( error ) => {
+	console.error( '❌ REST contract sync failed:', error );
+	process.exit( 1 );
+} );

package/templates/_shared/persistence/core/scripts/sync-types-to-block-json.ts.mustache

@@ -0,0 +1,125 @@
+/* eslint-disable no-console */
+import { runSyncBlockMetadata } from '@wp-typia/block-runtime/metadata-core';
+
+type SyncTypesReportMode = 'human' | 'json';
+
+interface SyncTypesCliOptions {
+	check: boolean;
+	failOnLossy: boolean;
+	report: SyncTypesReportMode;
+	strict: boolean;
+}
+
+function parseCliOptions( argv: string[] ): SyncTypesCliOptions {
+	const options: SyncTypesCliOptions = {
+		check: false,
+		failOnLossy: false,
+		report: 'human',
+		strict: false,
+	};
+
+	for ( let index = 0; index < argv.length; index += 1 ) {
+		const argument = argv[ index ];
+
+		if ( argument === '--strict' ) {
+			options.strict = true;
+			continue;
+		}
+
+		if ( argument === '--fail-on-lossy' ) {
+			options.failOnLossy = true;
+			continue;
+		}
+
+		if ( argument === '--check' ) {
+			options.check = true;
+			continue;
+		}
+
+		if ( argument === '--report' ) {
+			const reportMode = argv[ index + 1 ];
+			if ( reportMode !== 'json' ) {
+				throw new Error( 'The `--report` flag currently supports only `json`.' );
+			}
+			options.report = reportMode;
+			index += 1;
+			continue;
+		}
+
+		throw new Error( `Unknown sync-types flag: ${ argument }` );
+	}
+
+	return options;
+}
+
+function printHumanReport(
+	options: SyncTypesCliOptions,
+	report: Awaited< ReturnType< typeof runSyncBlockMetadata > >
+) {
+	if ( report.failure ) {
+		console.error( '❌ Type sync failed:', report.failure.message );
+		return;
+	}
+
+	console.log(
+		options.check
+			? '✅ block.json, typia.manifest.json, typia-validator.php, typia.schema.json, and typia.openapi.json are already up to date with the TypeScript types!'
+			: '✅ block.json, typia.manifest.json, typia-validator.php, typia.schema.json, and typia.openapi.json were generated from TypeScript types!'
+	);
+	console.log( '📝 Generated attributes:', report.attributeNames );
+
+	if ( report.lossyProjectionWarnings.length > 0 ) {
+		console.warn(
+			'⚠️ Some Typia constraints were preserved only in typia.manifest.json:'
+		);
+		for ( const warning of report.lossyProjectionWarnings ) {
+			console.warn( `   - ${ warning }` );
+		}
+	}
+
+	if ( report.phpGenerationWarnings.length > 0 ) {
+		console.warn(
+			'⚠️ Some Typia constraints are not yet enforced by typia-validator.php:'
+		);
+		for ( const warning of report.phpGenerationWarnings ) {
+			console.warn( `   - ${ warning }` );
+		}
+	}
+
+	if ( report.status === 'error' ) {
+		console.error(
+			'❌ Type sync completed with warnings treated as errors because of the selected flags.'
+		);
+	}
+}
+
+async function main() {
+	const options = parseCliOptions( process.argv.slice( 2 ) );
+	const report = await runSyncBlockMetadata( {
+		blockJsonFile: 'src/block.json',
+		jsonSchemaFile: 'src/typia.schema.json',
+		manifestFile: 'src/typia.manifest.json',
+		openApiFile: 'src/typia.openapi.json',
+		sourceTypeName: '{{pascalCase}}Attributes',
+		typesFile: 'src/types.ts',
+	}, {
+		check: options.check,
+		failOnLossy: options.failOnLossy,
+		strict: options.strict,
+	} );
+
+	if ( options.report === 'json' ) {
+		process.stdout.write( `${ JSON.stringify( report, null, 2 ) }\n` );
+	} else {
+		printHumanReport( options, report );
+	}
+
+	if ( report.status === 'error' ) {
+		process.exitCode = 1;
+	}
+}
+
+main().catch( ( error ) => {
+	console.error( '❌ Type sync failed:', error );
+	process.exit( 1 );
+} );

package/templates/_shared/persistence/core/src/api-types.ts.mustache

@@ -0,0 +1,21 @@
+import { tags } from 'typia';
+
+export interface {{pascalCase}}StateQuery {
+	postId: number & tags.Type< 'uint32' >;
+	resourceKey: string & tags.MinLength< 1 > & tags.MaxLength< 100 >;
+}
+
+export interface {{pascalCase}}WriteStateRequest {
+	postId: number & tags.Type< 'uint32' >;
+	{{publicWriteRequestIdDeclaration}}
+	publicWriteToken?: string & tags.MinLength< 1 > & tags.MaxLength< 512 >;
+	resourceKey: string & tags.MinLength< 1 > & tags.MaxLength< 100 >;
+	delta?: number & tags.Minimum< 1 > & tags.Type< 'uint32' > & tags.Default< 1 >;
+}
+
+export interface {{pascalCase}}StateResponse {
+	postId: number & tags.Type< 'uint32' >;
+	resourceKey: string & tags.MinLength< 1 > & tags.MaxLength< 100 >;
+	count: number & tags.Minimum< 0 > & tags.Type< 'uint32' >;
+	storage: ( 'post-meta' | 'custom-table' );
+}

package/templates/_shared/persistence/core/src/api-validators.ts.mustache

@@ -0,0 +1,32 @@
+import typia from 'typia';
+
+import {
+	toValidationResult,
+	type ValidationResult,
+} from '@wp-typia/api-client';
+import type {
+	{{pascalCase}}StateQuery,
+	{{pascalCase}}StateResponse,
+	{{pascalCase}}WriteStateRequest,
+} from './api-types';
+
+const validateStateQuery = typia.createValidate< {{pascalCase}}StateQuery >();
+const validateWriteStateRequest =
+	typia.createValidate< {{pascalCase}}WriteStateRequest >();
+const validateStateResponse =
+	typia.createValidate< {{pascalCase}}StateResponse >();
+
+export const apiValidators = {
+	stateQuery: (
+		input: unknown
+	): ValidationResult< {{pascalCase}}StateQuery > =>
+		toValidationResult( validateStateQuery( input ) ),
+	stateResponse: (
+		input: unknown
+	): ValidationResult< {{pascalCase}}StateResponse > =>
+		toValidationResult( validateStateResponse( input ) ),
+	writeStateRequest: (
+		input: unknown
+	): ValidationResult< {{pascalCase}}WriteStateRequest > =>
+		toValidationResult( validateWriteStateRequest( input ) ),
+};

package/templates/_shared/persistence/core/src/api.ts.mustache

@@ -0,0 +1,68 @@
+import {
+	callEndpoint,
+	resolveRestRouteUrl,
+} from '@wp-typia/rest';
+
+import {
+	type {{pascalCase}}StateQuery,
+	type {{pascalCase}}WriteStateRequest,
+} from './api-types';
+import {
+	get{{pascalCase}}StateEndpoint,
+	write{{pascalCase}}StateEndpoint,
+} from './api-client';
+
+export function resolveRestNonce( fallback?: string ): string | undefined {
+	if ( typeof fallback === 'string' && fallback.length > 0 ) {
+		return fallback;
+	}
+
+	if ( typeof window === 'undefined' ) {
+		return undefined;
+	}
+
+	const wpApiSettings = ( window as typeof window & {
+		wpApiSettings?: { nonce?: string };
+	} ).wpApiSettings;
+
+	return typeof wpApiSettings?.nonce === 'string' && wpApiSettings.nonce.length > 0
+		? wpApiSettings.nonce
+		: undefined;
+}
+
+export const stateEndpoint = {
+	...get{{pascalCase}}StateEndpoint,
+	buildRequestOptions: () => ( {
+		url: resolveRestRouteUrl( get{{pascalCase}}StateEndpoint.path ),
+	} ),
+};
+
+export const writeStateEndpoint = {
+	...write{{pascalCase}}StateEndpoint,
+	buildRequestOptions: () => ( {
+		url: resolveRestRouteUrl( write{{pascalCase}}StateEndpoint.path ),
+	} ),
+};
+
+export function fetchState(
+	request: {{pascalCase}}StateQuery
+) {
+	return callEndpoint( stateEndpoint, request );
+}
+
+export function writeState(
+	request: {{pascalCase}}WriteStateRequest,
+	restNonce?: string
+) {
+	const nonce = resolveRestNonce( restNonce );
+
+	return callEndpoint( writeStateEndpoint, request, {
+		requestOptions: nonce
+			? {
+					headers: {
+						'X-WP-Nonce': nonce,
+					},
+				}
+			: undefined,
+	} );
+}