/home/techb158/public_html/wp-content/plugins/kirki/app/Managers
Edit: /home/techb158/public_html/wp-content/plugins/kirki/app/Managers/PageManager.php (26304B)
staged_versions = collection();
}
/**
* Save random global style blocks
*
* @param int $page_id
* @param array $data
* @param int|false $staging_version
*/
public function save_style_blocks(int $page_id, $data = [], $staging_version = false)
{
if (!$staging_version) {
PostMeta::update_meta_value($page_id, PageMetaKeys::STYLE_BLOCKS, $data);
return;
}
$new_meta_key = $this->get_staged_meta_name(PageMetaKeys::STYLE_BLOCKS, $page_id, $staging_version);
PostMeta::update_meta_value($page_id, $new_meta_key, $data);
}
/**
* Save global style blocks
*
* @param int $page_id
* @param array $data
* @param int|false $staging_version
*/
public function save_deprecated_global_style_blocks(int $page_id, $data = [], $staging_version = false)
{
if (!$staging_version) {
PostMeta::update_meta_value($page_id, PageMetaKeys::GLOBAL_STYLE_BLOCK_DEPRECATED, $data);
return;
}
$new_meta_key = $this->get_staged_meta_name(PageMetaKeys::GLOBAL_STYLE_BLOCK_DEPRECATED, $page_id, $staging_version);
PostMeta::update_meta_value($page_id, $new_meta_key, $data);
}
/**
* Save used style block ids
*
* @param int $page_id
* @param array $data
* @param int|false $staging_version
*/
public function save_used_global_style_block_ids(int $page_id, $data = [], $staging_version = false)
{
if (!$staging_version) {
PostMeta::update_meta_value($page_id, PageMetaKeys::USED_GLOBAL_STYLE_BLOCK_IDS, $data);
return;
}
$new_meta_key = $this->get_staged_meta_name(PageMetaKeys::USED_GLOBAL_STYLE_BLOCK_IDS, $page_id, $staging_version);
PostMeta::update_meta_value($page_id, $new_meta_key, $data);
}
/**
* Save random used style block ids
*
* @param int $page_id
* @param array $data
* @param int|false $staging_version
*/
public function save_used_style_block_ids(int $page_id, $data = [], $staging_version = false)
{
if (!$staging_version) {
PostMeta::update_meta_value($page_id, PageMetaKeys::USED_STYLE_BLOCK_IDS, $data);
return;
}
$new_meta_key = $this->get_staged_meta_name(PageMetaKeys::USED_STYLE_BLOCK_IDS, $page_id, $staging_version);
PostMeta::update_meta_value($page_id, $new_meta_key, $data);
}
/**
* Save used font list
*
* @param int $page_id
* @param array $data
* @param int|false $staging_version
*/
public function save_used_font_list(int $page_id, $data = [], $staging_version = false)
{
if (!$staging_version) {
PostMeta::update_meta_value($page_id, PageMetaKeys::USED_FONT_LIST, $data);
return;
}
$new_meta_key = $this->get_staged_meta_name(PageMetaKeys::USED_FONT_LIST, $page_id, $staging_version);
PostMeta::update_meta_value($page_id, $new_meta_key, $data);
}
/**
* Save kirki blocks
*
* @param int $page_id
* @param array $data
* @param int|false $staging_version
*/
public function save_blocks(int $page_id, $data = [], $staging_version = false)
{
if (!$staging_version) {
PostMeta::update_meta_value($page_id, PageMetaKeys::BLOCKS, $data);
return;
}
$new_meta_key = $this->get_staged_meta_name(PageMetaKeys::BLOCKS, $page_id, $staging_version);
PostMeta::update_meta_value($page_id, $new_meta_key, $data);
}
public function save_editor_mode(int $page_id)
{
PostMeta::update_meta_value(
$page_id,
PageMetaKeys::EDITOR_MODE,
get_editor_mode()
);
}
public function is_kirki_editor_mode(int $page_id)
{
$editor_mode = PostMeta::get_meta_value($page_id, PageMetaKeys::EDITOR_MODE);
return $editor_mode === get_editor_mode();
}
/**
* Update last edited datetime of stage version
*
* @param int $page_id
* @param bool $has_legacy_global_style default false
* @return array|false
*/
public function set_last_edited_datetime_of_stage_version(int $page_id, bool $has_legacy_global_style = false)
{
$staged_versions = $this->get_all_staged_versions($page_id);
$total_versions = $staged_versions->count();
if ($total_versions === 0) {
return false;
}
$this->staged_versions = $staged_versions->map(function ($item, $index) use ($total_versions, $has_legacy_global_style) {
if ($index === $total_versions - 1) {
$item['last_updated'] = Date::now(get_timezone(true))->format(DateTimeFormats::DB_DATETIME);
$item['no_legacy_global_style'] = !$has_legacy_global_style;
}
return $item;
});
PostMeta::update_meta_value(
$page_id,
PageMetaKeys::STAGED_VERSIONS,
$this->staged_versions->to_array()
);
return $this->staged_versions;
}
/**
* Get most recent stage version
*
* @param int $page_id
* @param bool $stage_must
* @param bool $restoring
* @param int|bool $old_version
*
* @return int
*/
public function get_most_recent_stage_version(int $page_id, $stage_must = true, $restoring = false, $old_version = false)
{
$staged_versions = $this->get_all_staged_versions($page_id);
$recent_stage_version = false;
$version_number = 0;
$being_restored = false;
foreach ($staged_versions as $version) {
if (is_array($version) && intval($version['version']) > $version_number) {
$version_number = $version['version'];
$recent_stage_version = $version;
}
if ($restoring && intval($old_version) === intval($version['version'])) {
$being_restored = $version;
}
}
if (
$version_number === 0
|| ($stage_must && isset($recent_stage_version['publish']) && $recent_stage_version['publish'])
|| $restoring
) {
$version_number = $this->add_stage_version($page_id, $version_number + 1, $staged_versions->to_array(), $being_restored);
}
return (int) $version_number;
}
/**
* Get all staged versions
*
* @param int $page_id
* @param bool $create_if_empty - default true
* @return Collection
*/
public function get_all_staged_versions(int $page_id, bool $create_if_empty = true)
{
if ($this->staged_versions->not_empty()) {
return $this->staged_versions;
}
$staged_versions = PostMeta::get_meta_value($page_id, PageMetaKeys::STAGED_VERSIONS);
if (empty($staged_versions) || !is_array($staged_versions)) {
if (!$create_if_empty) {
return $this->staged_versions = collection();
}
$staged_versions = $this->create_first_stage_version_if_empty($page_id);
} else {
$staged_versions = collection($staged_versions);
}
$this->staged_versions = $staged_versions->map(function ($item) {
if (isset($item['edited_by']) && is_numeric($item['edited_by'])) {
return array_merge(
$item,
[
'edited_by_id' => (int) $item['edited_by'],
'edited_by' => user((int) $item['edited_by'])->get_display_name(),
]
);
}
return $item;
});
return $this->staged_versions;
}
/**
* Create first stage version
*
* @param int $page_id
* @return Collection
*/
private function create_first_stage_version_if_empty(int $page_id)
{
// When stage version is empty, it means there is legacy global style blocks
$has_legacy_global_style = true;
$new_version = $this->add_stage_version($page_id, 1, [], false, $has_legacy_global_style);
$style_blocks_old_data = PostMeta::get_meta_value($page_id, PageMetaKeys::STYLE_BLOCKS, []);
$this->save_style_blocks($page_id, $style_blocks_old_data, $new_version);
$used_global_style_block_ids = PostMeta::get_meta_value($page_id, PageMetaKeys::USED_GLOBAL_STYLE_BLOCK_IDS, []);
$this->save_used_global_style_block_ids($page_id, $used_global_style_block_ids, $new_version);
$random_used_style_block_ids = PostMeta::get_meta_value($page_id, PageMetaKeys::USED_STYLE_BLOCK_IDS, []);
$this->save_used_style_block_ids($page_id, $random_used_style_block_ids, $new_version);
$used_font_list_data = PostMeta::get_meta_value($page_id, PageMetaKeys::USED_FONT_LIST, []);
$this->save_used_font_list($page_id, $used_font_list_data, $new_version);
$kirki_block_data = PostMeta::get_meta_value($page_id, PageMetaKeys::BLOCKS, []);
$this->save_blocks($page_id, $kirki_block_data, $new_version);
return $this->publish_stage_version($page_id, $has_legacy_global_style);
}
/**
* Add a new stage version
*
* @param int $page_id
* @param int $version_number
* @param array $prev_versions
* @param array|false $being_restored
* @param bool $has_legacy_global_style default false
* @return int
*/
private function add_stage_version(int $page_id, int $version_number, array $prev_versions = [], $being_restored = false, $has_legacy_global_style = false)
{
$version_name = $being_restored
? sprintf(__('[Restored] %s', 'kirki'), $being_restored['name'])
: wp_date(KirkiDateTimeFormat::HUMAN_READABLE_DAY_OF_MONTH_WITH_TIME); // @todo: improve later
$datetime = wp_date(KirkiDateTimeFormat::DB_DATETIME); // @todo: improve later
if (!empty($being_restored)) {
$has_legacy_global_style = !($being_restored['has_legacy_global_style'] ?? false);
}
$new_version = [
'version' => $version_number,
'edited_by_id' => user()->get_id(),
'edited_by' => user()->get_display_name(),
'created_on' => $datetime,
'last_updated' => $datetime,
'name' => $version_name,
'publish' => false,
'no_legacy_global_style' => !$has_legacy_global_style,
];
$prev_versions[] = $new_version;
PostMeta::update_meta_value($page_id, PageMetaKeys::STAGED_VERSIONS, $prev_versions);
$this->staged_versions = collection($prev_versions);
return $version_number;
}
/**
* Publish stage version
*
* @param int $page_id
* @param bool $has_legacy_global_style default false
* @return Collection
*/
public function publish_stage_version(int $page_id, bool $has_legacy_global_style = false)
{
$stage_must = false;
$version_id = $this->get_most_recent_stage_version($page_id, $stage_must);
$this->staged_versions = $this->get_all_staged_versions($page_id)
->map(function ($item) use ($version_id, $has_legacy_global_style) {
$is_published = isset($item['version']) && intval($item['version']) === intval($version_id);
$item['publish'] = $is_published;
$item['no_legacy_global_style'] = !$has_legacy_global_style;
return $item;
});
PostMeta::update_meta_value(
$page_id,
PageMetaKeys::STAGED_VERSIONS,
$this->staged_versions->to_array()
);
return $this->staged_versions;
}
/**
* Rename stage version
*
* @param int $page_id
* @param int $version_id
* @param string $new_name
* @return Collection
*/
public function rename_stage_version(int $page_id, int $version_id, string $new_name)
{
$staged_versions = $this->get_all_staged_versions($page_id, false);
$this->staged_versions = $staged_versions->map(function ($item) use ($version_id, $new_name) {
if (is_array($item) && isset($item['version']) && intval($item['version']) === $version_id) {
$item['name'] = $new_name;
}
return $item;
}
);
PostMeta::update_meta_value($page_id, PageMetaKeys::STAGED_VERSIONS, $this->staged_versions->to_array());
return $this->staged_versions;
}
/**
* Remove stage version
*
* @param int $page_id
* @param int $version_id
* @return Collection
*/
public function remove_stage_version(int $page_id, int $version_id)
{
$stage_only = true;
$meta_keys = [];
foreach([
PageMetaKeys::STYLE_BLOCKS,
PageMetaKeys::GLOBAL_STYLE_BLOCK_DEPRECATED,
PageMetaKeys::USED_GLOBAL_STYLE_BLOCK_IDS,
PageMetaKeys::USED_STYLE_BLOCK_IDS,
PageMetaKeys::USED_FONT_LIST,
PageMetaKeys::BLOCKS
] as $key) {
$meta_keys[] = $this->get_staged_meta_name($key, $page_id, $version_id, $stage_only);
}
PostMeta::query()
->where('post_id', $page_id)
->where_in('meta_key', $meta_keys)
->delete();
$staged_versions = $this->get_all_staged_versions($page_id, false);
$this->staged_versions = $staged_versions->filter(function ($item) use ($version_id) {
// Filter out the version which is matched and not published
return !(
is_array($item)
&& isset($item['publish'], $item['version'])
&& is_falsy($item['publish'])
&& intval($item['version']) === $version_id
);
})->values();
PostMeta::update_meta_value($page_id, PageMetaKeys::STAGED_VERSIONS, $this->staged_versions->to_array());
return $this->staged_versions;
}
protected function restore_page_meta(string $meta_key,int $page_id, int $old_version_id, int $new_version_id)
{
$old_meta_key = $this->get_staged_meta_name($meta_key, $page_id, $old_version_id);
$old_data = PostMeta::get_meta_value($page_id, $old_meta_key);
$new_meta_key = $this->get_staged_meta_name($meta_key, $page_id, $new_version_id);
PostMeta::update_meta_value($page_id, $new_meta_key, $old_data);
}
/**
* Restore stage version
*
* @param int $page_id
* @param int $old_version_id
* @return int return new version id
*/
public function restore_stage_version(int $page_id, int $old_version_id)
{
$new_version_id = $this->get_most_recent_stage_version($page_id, true, true, $old_version_id);
$meta_keys = [
PageMetaKeys::STYLE_BLOCKS,
PageMetaKeys::GLOBAL_STYLE_BLOCK_DEPRECATED,
PageMetaKeys::USED_GLOBAL_STYLE_BLOCK_IDS,
PageMetaKeys::USED_STYLE_BLOCK_IDS,
PageMetaKeys::USED_FONT_LIST,
PageMetaKeys::BLOCKS
];
foreach($meta_keys as $meta_key) {
$this->restore_page_meta($meta_key, $page_id, $old_version_id, $new_version_id);
}
return $new_version_id;
}
/**
* Get the staged meta name
*
* @param string $meta_name
* @param int $page_id
* @param int|false $stage_version
* @param bool $stage_only
* @return string
*/
public function get_staged_meta_name(string $meta_name, int $page_id, $stage_version = false, $stage_only = false)
{
if (!$stage_version) {
$stage_must = false;
$stage_version = $this->get_most_recent_stage_version($page_id, $stage_must);
} elseif (!$stage_only) {
$published_version = $this->get_published_stage_version($page_id);
if ($published_version && $stage_version === $published_version) {
return $meta_name;
}
}
return sprintf('staged_%s_%s', $stage_version, $meta_name);
}
/**
* Get the published stage version info
*
* @param int $page_id
*
* @return array|null
*/
public function get_published_staged_version_info(int $page_id)
{
$staged_versions = $this->get_all_staged_versions($page_id);
// Find the first staged version that has 'publish' set to true
foreach ($staged_versions as $item) {
if (is_array($item) && isset($item['publish']) && is_truthy($item['publish'])) {
return $item;
}
}
return null;
}
/**
* Get the published stage version
*
* @param int $page_id
* @return int|false
*/
public function get_published_stage_version(int $page_id)
{
$published_version = $this->get_published_staged_version_info($page_id);
if ($published_version && isset($published_version['version'])) {
return (int) $published_version['version'];
}
return false;
}
/**
* Get the stage version info
*
* @param int $page_id
* @param int $stage_version
*
* @return array|null
*/
public function get_staged_version_info(int $page_id, int $stage_version)
{
$staged_versions = $this->get_all_staged_versions($page_id);
// Find the first staged version that has 'publish' set to true
foreach ($staged_versions as $item) {
if (is_array($item) && isset($item['version']) && intval($item['version']) === intval($stage_version)) {
return $item;
}
}
return null;
}
private function has_legacy_global_style(int $page_id, int $stage_version)
{
$info = $this->get_staged_version_info($page_id, $stage_version);
$has_no_legacy = isset($info['no_legacy_global_style']) && is_truthy($info['no_legacy_global_style']);
return !$has_no_legacy;
}
/**
* This function will return page style blocks from option meta and post meta
* post meta for migration and option meta for global style block
*
* @param int $page_id post id.
* @param int|false $stage_version
* @return array
*/
protected function get_page_styleblocks_legacy(int $page_id, $stage_version = false)
{
$current_style_blocks = PostMeta::get_meta_value($page_id, PageMetaKeys::STYLE_BLOCKS, []);
$legacy_global_style_blocks = GlobalData::get_deprecated_global_style_blocks();
$current_style_blocks = $this->resolve_duplicate_current_style_block_names($current_style_blocks, $legacy_global_style_blocks);
$merged_style_blocks = $current_style_blocks;
if ($legacy_global_style_blocks) {
$merged_style_blocks = array_merge($merged_style_blocks, $legacy_global_style_blocks);
}
$published_version = $this->get_published_stage_version($page_id);
if (!$published_version || $stage_version === $published_version) {
return $merged_style_blocks;
}
$staging_style_blocks = [];
$meta_key = $this->get_staged_meta_name(PageMetaKeys::GLOBAL_STYLE_BLOCK_DEPRECATED, $page_id, $stage_version);
$global_stage_style_blocks = PostMeta::get_meta_value($page_id, $meta_key, []);
if ($global_stage_style_blocks) {
$staging_style_blocks = $global_stage_style_blocks;
}
$current_style_meta_key = $this->get_staged_meta_name(PageMetaKeys::STYLE_BLOCKS, $page_id, $stage_version);
$current_stage_style_blocks = PostMeta::get_meta_value($page_id, $current_style_meta_key, []);
if ($current_stage_style_blocks) {
$staging_style_blocks = array_merge($staging_style_blocks, $current_stage_style_blocks);
}
if ($stage_version) {
return $this->merge_style_blocks($merged_style_blocks, $staging_style_blocks);
}
return $this->merge_style_blocks($staging_style_blocks, $merged_style_blocks);
}
public function get_page_styleblocks(int $page_id, $stage_version = false)
{
$global_style_blocks = GlobalData::get_style_blocks();
if ($this->has_legacy_global_style($page_id, $stage_version)) {
$legacy_style_blocks = $this->get_page_styleblocks_legacy($page_id, $stage_version);
$legacy_style_blocks = $this->resolve_duplicate_current_style_block_names($legacy_style_blocks, $global_style_blocks);
return $this->merge_style_blocks($legacy_style_blocks, $global_style_blocks);
}
$published_version = $this->get_published_stage_version($page_id);
// When published
if (!$stage_version || $stage_version === $published_version) {
$current_style_blocks = PostMeta::get_meta_value($page_id, PageMetaKeys::STYLE_BLOCKS, []);
$current_style_blocks = $this->resolve_duplicate_current_style_block_names($current_style_blocks, $global_style_blocks);
return $this->merge_style_blocks($current_style_blocks, $global_style_blocks);
}
$current_stage_style_meta_key = $this->get_staged_meta_name(PageMetaKeys::STYLE_BLOCKS, $page_id, $stage_version);
$current_stage_style_blocks = PostMeta::get_meta_value($page_id, $current_stage_style_meta_key, []);
$current_stage_style_blocks = $this->resolve_duplicate_current_style_block_names($current_stage_style_blocks, $global_style_blocks);
return $this->merge_style_blocks($current_stage_style_blocks, $global_style_blocks);
}
/**
* Fix duplicate class name from random style blocks
*
* @param array $current_style_blocks
* @param array $global_style_blocks
*
* @return array
*/
private function resolve_duplicate_current_style_block_names($current_style_blocks, $global_style_blocks)
{
$global_class_names = $this->extract_class_names($global_style_blocks);
$current_class_names = $this->extract_class_names($current_style_blocks);
$duplicate_classes = array_intersect_key($current_class_names, $global_class_names);
if (empty($duplicate_classes)) {
return $current_style_blocks;
}
$class_map = $this->make_duplicate_classes_to_unique(
$duplicate_classes,
$global_class_names,
$current_class_names
);
foreach ($current_style_blocks as &$style_block) {
if (!isset($style_block['name'])) {
continue;
}
if (is_string($style_block['name'])) {
$class_name = $this->normalize_style_block_name($style_block['name']);
if (isset($class_map[$class_name])) {
$style_block['name'] = $class_map[$class_name];
}
continue;
}
if (!is_array($style_block['name'])) {
continue;
}
foreach ($style_block['name'] as &$name) {
$class_name = $this->normalize_style_block_name($name);
if (isset($class_map[$class_name])) {
$name = $class_map[$class_name];
}
}
unset($name);
}
unset($style_block);
return $current_style_blocks;
}
private function extract_class_names(array $style_blocks)
{
$class_names = [];
foreach ($style_blocks as $style_block) {
if (!isset($style_block['name']) || !is_string($style_block['name'])) {
continue;
}
$class_names[$this->normalize_style_block_name($style_block['name'])] = true;
}
return $class_names;
}
/**
* Check or generate new class names
*
* @param array $duplicate_classes
* @param array $global_class_names
* @param array $current_class_names
*
* @return array
*/
private function make_duplicate_classes_to_unique(array $duplicate_classes, array $global_class_names, array $current_class_names)
{
foreach ($duplicate_classes as $class_name => $_) {
$counter = 1;
do {
$new_class_name = $counter === 1
? $class_name . '-copy'
: $class_name . '-copy_' . $counter;
$counter++;
} while (
isset($global_class_names[$new_class_name]) ||
isset($current_class_names[$new_class_name])
);
$duplicate_classes[$class_name] = $new_class_name;
}
return $duplicate_classes;
}
/**
* Get class name from string
*
* @param string $string
*
* @return string
*/
private function normalize_style_block_name(string $string)
{
$class_name = strtolower(str_replace(' ', '-', trim($string)));
return $class_name;
}
/**
* Merge style blocks
*
* @param array $old_blocks
* @param array $new_blocks
*
* @return array
*/
public function merge_style_blocks($old_blocks, $new_blocks)
{
$names_in_old_blocks = $this->extract_class_names($old_blocks);
$names_in_new_blocks = $this->extract_class_names($new_blocks);
foreach ($new_blocks as $new_block_key => &$new_block) {
if (empty($new_block['name']) || !is_string($new_block['name'])) {
continue;
}
$original_name = $new_block['name'];
$normalized_name = strtolower($original_name);
// If same ID exists in $old_blocks, remove it first (old behavior)
if (isset($old_blocks[$new_block_key])) {
unset($old_blocks[$new_block_key]);
if (isset($names_in_old_blocks[$normalized_name])) {
unset($names_in_old_blocks[$normalized_name]);
}
}
if (!isset($names_in_old_blocks[$normalized_name])) {
continue;
}
// If name already exists in $old_blocks, make it unique
$suffix = 1;
while (
isset($names_in_old_blocks[$normalized_name . '_' . $suffix])
|| isset($names_in_new_blocks[$normalized_name . '_' . $suffix])
) {
$suffix++;
}
$new_name = $original_name . '_' . $suffix;
foreach ($new_blocks as &$block) {
if (!isset($block['name']) || !is_array($block['name'])) {
continue;
}
$block['name'] = array_map(fn($item) => $item === $original_name ? $new_name : $item, $block['name']);
}
unset($block);
$new_block['name'] = $new_name;
unset($names_in_new_blocks[$normalized_name]);
$names_in_new_blocks[strtolower($new_name)] = true;
}
unset($new_block);
// Use array_merge to keep old semantics
return array_merge($old_blocks, $new_blocks);
}
/**
* Get variable mode
*
* @param PageModel|PostModel|int $page
*
* @return string
*/
public function get_variable_mode($page)
{
if ($page instanceof PageModel || $page instanceof PostModel) {
$meta = isset($page->meta) && $page->meta->not_empty() ? $page->meta->pluck('meta_value', 'meta_key')->to_array() : [];
if (isset($meta[PageMetaKeys::VARIABLE_MODE])) {
return $meta[PageMetaKeys::VARIABLE_MODE] ?? 'inherit';
}
}
return PostMeta::get_meta_value($page->ID, PageMetaKeys::VARIABLE_MODE, 'inherit');
}
/**
* Collect all block post IDs (including draft, published)
*
* @return array
*/
public function get_all_block_post_ids()
{
if (!is_null($this->all_block_post_ids)) {
return $this->all_block_post_ids;
}
return $this->all_block_post_ids = PostModel::query()
->where_not_in('post_type', [PostTypes::SYMBOL, PostTypes::POPUP])
->where_has('meta', fn($q) => $q->where('meta_key', PageMetaKeys::BLOCKS))
->pluck('ID')
->to_array();
}
/**
* Get most recent unpublished stage version
*
* @param int $page_id
*
* @return int|null
*/
public function get_most_recent_unpublished_stage_version(int $page_id)
{
$staged_versions = $this->get_all_staged_versions($page_id, false);
$most_recent_unpublished_stage_version = $staged_versions->filter(function ($version) {
return empty($version['publish']);
})->last();
if ($most_recent_unpublished_stage_version) {
return (int) $most_recent_unpublished_stage_version['version'];
}
return null;
}
/**
* Get front page ID
*
* @return int
*/
public function get_front_page_id()
{
return (int) Option::get(OptionKeys::PAGE_ON_FRONT, 0);
}
/**
* Is front page
*
* @param int $page_id
*
* @return bool
*/
public function is_front_page(int $page_id) {
return $this->get_front_page_id() === $page_id;
}
}