nextpress-core 1.0.3 → 2.0.0

package/{dist/router/routes/not-found-page.js → lib/router/nextpress-not-found-route.tsx}

@@ -1,20 +1,22 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { NotFoundMetadata, NotFoundTemplate } from "@/template-heirarchy/not-found.tsx/not-found";
+import { Metadata } from "next";
+import { NotFoundMetadata, NotFoundTemplate } from "nextpress/template-heirarchy/not-found.tsx/not-found";
+
 /**
  * Generates the metadata for the generic Not Found page.
  * Maps to the Nextpress `NotFoundMetadata` which falls back to `IndexMetadata`.
  *
  * @returns {Promise<Metadata>} The generated metadata object.
  */
-export async function notFoundMetadata() {
+export async function NextpressNotFoundMetadata(): Promise<Metadata> {
     return await NotFoundMetadata();
 }
+
 /**
  * Default Not Found component to handle unmatched routes.
  * Maps to the Nextpress `NotFoundTemplate` which defaults back to `IndexTemplate` if not defined.
  *
  * @returns {Promise<JSX.Element>} The rendered Not Found template.
  */
-export async function NotFoundPage() {
-    return _jsx(NotFoundTemplate, {});
+export async function NextpressNotFoundRoute() {
+    return <NotFoundTemplate/>
 }

package/{dist/router/nextpress-proxy.js → lib/router/nextpress-proxy.ts}

@@ -1,18 +1,22 @@
-import { NextResponse } from "next/server";
+import { NextRequest, NextResponse } from "next/server";
+
 /**
  * Processes incoming requests to manage WordPress session cookies and redirects.
  *
  * @param {NextRequest} request - Incoming request.
  * @returns {NextResponse} Response to proceed or redirect.
  */
-export function nextpressProxy(request) {
+export function nextpressProxy(request: NextRequest): NextResponse {
     const url = request.nextUrl;
+
     if (url.pathname.startsWith('/api/draft')) {
         return NextResponse.next();
     }
+
     if (url.searchParams.has('nextpress_logged_in_user_id')) {
         const loggedInUserId = url.searchParams.get('nextpress_logged_in_user_id');
         url.searchParams.delete('nextpress_logged_in_user_id');
+
         const response = NextResponse.redirect(url);
         response.cookies.set('nextpress_logged_in_user_id', loggedInUserId || '0');
         return response;
@@ -20,14 +24,22 @@ export function nextpressProxy(request) {
     if (request.cookies.has('nextpress_logged_in_user_id')) {
         return NextResponse.next();
     }
+
     const cookies = request.cookies;
-    const hasWordpressCookie = cookies.getAll().some(cookie => cookie.name.startsWith('wordpress_logged_in_'));
+
+    const hasWordpressCookie = cookies.getAll().some(cookie =>
+        cookie.name.startsWith('wordpress_logged_in_')
+    );
+
     if (hasWordpressCookie) {
         const currentPath = url.pathname + url.search;
+
         const redirectUrl = url.clone();
         redirectUrl.pathname = '/api/draft';
         redirectUrl.searchParams.set('redirect', currentPath);
+
         return NextResponse.redirect(redirectUrl);
     }
+
     return NextResponse.next();
 }

package/{dist/router/nextpress-static-params.js → lib/router/nextpress-static-params.ts}

@@ -1,13 +1,17 @@
 import { splitPath } from "./helpers";
+import { NextpressRouterProps } from "./router";
+
+export type NextpressStaticParams = Awaited<NextpressRouterProps['params']>[];
+
 const { publicPostTypes, archivedPostTypes } = nextpressConfig;
+
 /**
  * Generates static parameters for Next.js build-time prerendering.
  * Queries authors, terms, and posts to generate a comprehensive list of all active routes.
  *
  * @returns {NextpressStaticParams} An array containing the route parameters to be generated statically.
  */
-export async function nextpressStaticParams() {
-    var _a;
+export async function nextpressStaticParams(): Promise<NextpressStaticParams> {
     const { ids: authorIds } = await userLoader.findAndPrime({
         hasPublishedPosts: true,
         noFoundRows: false,
@@ -15,28 +19,35 @@ export async function nextpressStaticParams() {
     });
     const authors = await getUsers(authorIds);
     const authorPaths = authors.map((author) => ['author', author.userLogin]);
+
     const { ids: termIds } = await termLoader.findAndPrime({});
     const terms = await getTerms(termIds);
     const termPaths = terms.map(term => [term.taxonomy, ...splitPath(term.path)]);
+
     const { ids: archivedPostIds } = await postLoader.findAndPrime({
         postStatus: 'publish',
-        postType: (_a = archivedPostTypes === null || archivedPostTypes === void 0 ? void 0 : archivedPostTypes.filter(p => !(publicPostTypes === null || publicPostTypes === void 0 ? void 0 : publicPostTypes.includes(p)))) !== null && _a !== void 0 ? _a : 'post',
+        postType: archivedPostTypes?.filter(p => !publicPostTypes?.includes(p)) ?? 'post',
         ignoreStickyPosts: true,
         noFoundRows: true,
         noPaging: true,
     });
     const { ids: postIds } = await postLoader.findAndPrime({
         postStatus: 'publish',
-        postType: archivedPostTypes !== null && archivedPostTypes !== void 0 ? archivedPostTypes : 'post',
+        postType: archivedPostTypes ?? 'post',
         ignoreStickyPosts: true,
         noFoundRows: true,
         noPaging: true,
     });
+
     const archivedPosts = await getPosts(archivedPostIds);
     const posts = await getPosts(postIds);
+
     const archivedPostsPaths = archivedPosts.map(post => splitPath(post.path));
-    const archivedPostArchivePaths = (archivedPostTypes !== null && archivedPostTypes !== void 0 ? archivedPostTypes : []).map(type => [type]);
+
+    const archivedPostArchivePaths = (archivedPostTypes ?? []).map(type => [type]);
+
     const postPaths = posts.map(post => splitPath(post.path));
+
     const allPaths = [
         ...authorPaths,
         ...termPaths,
@@ -44,6 +55,7 @@ export async function nextpressStaticParams() {
         ...archivedPostArchivePaths,
         ...postPaths
     ];
+
     return allPaths.map(segments => ({
         path: segments.filter(Boolean)
     }));

package/{dist/router/router.js → lib/router/router.tsx}

@@ -1,10 +1,17 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import "../globals/globals";
+import { Metadata } from "next";
 import { AuthorArchive } from "./routes/author-archive";
 import { SingularPage } from "./routes/singular-page";
 import { SiteFrontPage } from "./routes/site-front-page";
 import { TermArchive } from "./routes/term-archive";
+
+export type NextpressRouterProps = {
+    params: Promise<{
+        path: string[] | undefined;
+    }>;
+}
+
 const { publicTaxonomies } = nextpressConfig;
+
 /**
  * Generates metadata dynamically for a given request path.
  * Routes the path to the correct Nextpress routing function based on the configuration logic.
@@ -12,22 +19,22 @@ const { publicTaxonomies } = nextpressConfig;
  * @param {NextpressRouterProps} props - The dynamic properties for this page route.
  * @returns {Promise<Metadata>} The Metadata object for the matched route.
  */
-export async function generateNextpressMetadata({ params }) {
-    var _a;
-    const path = (_a = (await params).path) !== null && _a !== void 0 ? _a : [];
+export async function generateNextpressMetadata({ params }: NextpressRouterProps): Promise<Metadata> {
+    const path = (await params).path ?? [];
+
     if (!path.length) {
-        return await SiteFrontPage({ path, metadata: true });
+        return await SiteFrontPage({path, metadata: true});
     }
-    if (publicTaxonomies === null || publicTaxonomies === void 0 ? void 0 : publicTaxonomies.includes(path[0])) {
-        return await TermArchive({ path, metadata: true });
+    if (publicTaxonomies?.includes(path[0]!)) {
+        return await TermArchive({path, metadata: true});
     }
     if (path[0] === 'author') {
-        return await AuthorArchive({ path, metadata: true });
-    }
-    else {
-        return await SingularPage({ path, metadata: true });
+        return await AuthorArchive({path, metadata: true});
+    } else {
+        return await SingularPage({path, metadata: true});
     }
 }
+
 /**
  * The main catch-all Page component that renders the layout for matched routes.
  * Routes the path to the correct Nextpress routing component to return a template.
@@ -35,19 +42,19 @@ export async function generateNextpressMetadata({ params }) {
  * @param {NextpressRouterProps} props - The dynamic properties for this page route.
  * @returns {Promise<JSX.Element>} The rendered React component mapping to the matched route's template.
  */
-export default async function NextPressPage({ params }) {
-    var _a;
-    const path = (_a = (await params).path) !== null && _a !== void 0 ? _a : [];
+export async function NextPressPage({ params }: NextpressRouterProps) {
+    const path = (await params).path ?? [];
+
     if (!path.length) {
-        return _jsx(SiteFrontPage, { path: path });
+        return <SiteFrontPage path={path}/>
     }
-    if (publicTaxonomies === null || publicTaxonomies === void 0 ? void 0 : publicTaxonomies.includes(path[0])) {
-        return _jsx(TermArchive, { path: path });
+    if (publicTaxonomies?.includes(path[0]!)) {
+        return <TermArchive path={path}/>
     }
     if (path[0] === 'author') {
-        return _jsx(AuthorArchive, { path: path });
-    }
-    else {
-        return _jsx(SingularPage, { path: path });
+        return <AuthorArchive path={path}/>
+    } else {
+        return <SingularPage path={path}/>
     }
 }
+

package/{dist/router/routes/api/api-get-admin-bar.js → lib/router/routes/api/api-get-admin-bar.ts}

@@ -1,26 +1,28 @@
-import { NextResponse } from "next/server";
+import { NextRequest, NextResponse } from "next/server";
+
 /**
  * Processes GET requests to fetch WordPress admin bar data.
  *
  * @param {NextRequest} request - Incoming request.
  * @returns {Promise<NextResponse>} Response containing admin bar data or error.
  */
-export async function apiGetAdminBar(request) {
+export async function apiGetAdminBar(request: NextRequest): Promise<NextResponse> {
     const { searchParams } = new URL(request.url);
     const userId = searchParams.get('user_id');
     const path = searchParams.get('path');
+
     try {
         const response = await fetch(`${process.env.WP_SERVICE_URL}/wp-json/nextpress/v1/get-admin-bar?user_id=${userId}&path=${path}`, {
             headers: {
                 'Authorization': `api-key ${process.env.CROSS_CONTAINER_API_KEY}`
             }
         });
-        if (!response.ok)
-            return NextResponse.json({ error: 'Failed to fetch from WP' }, { status: response.status });
+
+        if (!response.ok) return NextResponse.json({ error: 'Failed to fetch from WP' }, { status: response.status });
+
         const data = await response.json();
         return NextResponse.json(data);
-    }
-    catch (error) {
+    } catch (error: any) {
         console.error(error.message);
         return NextResponse.json({ error: 'Internal Server Error' }, { status: 500 });
     }

package/{dist/router/routes/api/api-get-draft-mode.js → lib/router/routes/api/api-get-draft-mode.ts}

@@ -1,38 +1,47 @@
 import { draftMode } from 'next/headers';
 import { redirect } from 'next/navigation';
+import { NextRequest } from "next/server";
+
 /**
  * Processes GET requests to validate WordPress session and enable draft mode.
  *
  * @param {NextRequest} request - Incoming request.
  * @returns {Promise<never>} Redirects to target URL.
  */
-export async function apiGetDraftMode(request) {
+export async function apiGetDraftMode(request: NextRequest): Promise<never> {
     const { searchParams } = new URL(request.url);
     const redirectUrl = searchParams.get('redirect') || '/';
+
     const draft = await draftMode();
+
     const cookies = request.cookies.getAll();
     const wpCookie = cookies.find(cookie => cookie.name.startsWith('wordpress_logged_in_'));
+
     let userId = 0;
-    if (!(wpCookie === null || wpCookie === void 0 ? void 0 : wpCookie.value)) {
+
+    if (!wpCookie?.value) {
         console.warn('Wordpress login cookie missing.');
         draft.disable();
         redirect(redirectUrl + `?nextpress_logged_in_user_id=${userId}`);
     }
+
     try {
         const validLogin = await fetch(`${process.env.WP_SERVICE_URL}/wp-json/nextpress/v1/validate-user-session/?user_hash=${wpCookie.value}`, {
             headers: {
                 'Authorization': `api-key ${process.env.CROSS_CONTAINER_API_KEY}`
             }
         });
-        if (!validLogin.ok)
-            throw new Error(`Validation failed with status code: ${validLogin.status}`);
+
+        if (!validLogin.ok) throw new Error(`Validation failed with status code: ${validLogin.status}`);
+
         const response = await validLogin.json();
         userId = Number(response.user_id) || 0;
+
         draft.enable();
-    }
-    catch (error) {
+    } catch (error: any) {
         console.warn('Could not validate Wordpress login:', error.message);
         draft.disable();
     }
+
     redirect(redirectUrl + `?nextpress_logged_in_user_id=${userId}`);
 }

package/{dist/router/routes/api/api-get-field-groups.js → lib/router/routes/api/api-get-field-groups.ts}

@@ -1,24 +1,29 @@
 import { headers } from "next/headers";
 import { NextResponse } from "next/server";
 import { isAuthorized } from "./helpers";
-import { acfFieldGroupAutoloader } from "@/acf-functions/core/acf-field-group-autoloader";
-import { ACFBuilder } from "@/acf-functions/core/acf-builder";
+import { acfFieldGroupAutoloader } from "nextpress/acf-functions/core/acf-field-group-autoloader";
+import { ACFBuilder } from "nextpress/acf-functions/core/acf-builder";
+
 /**
  * Processes GET requests to retrieve built ACF field groups.
  *
  * @returns {Promise<NextResponse>} Response containing field groups or error.
  */
-export async function apiGetFieldGroups() {
+export async function apiGetFieldGroups(): Promise<NextResponse> {
     if (!isAuthorized(await headers())) {
-        return NextResponse.json('Unauthorized access', { status: 403 });
+        return NextResponse.json('Unauthorized access', { status: 403 })
     }
+
     try {
         const fieldGroups = await acfFieldGroupAutoloader();
         const acfBuilder = new ACFBuilder().registerFieldGroups(fieldGroups);
+
         return NextResponse.json(acfBuilder.getFieldGroups(), { status: 200 });
-    }
-    catch (error) {
-        console.error('Field Group API:', error.message);
-        return NextResponse.json({ message: 'Error building ACF fields', error: String(error) }, { status: 500 });
+    } catch (error: any) {
+        console.error('Field Group API:', error.message)
+        return NextResponse.json(
+            { message: 'Error building ACF fields', error: String(error) },
+            { status: 500 }
+        );
     }
 }

package/{dist/router/routes/api/api-post-revalidate.js → lib/router/routes/api/api-post-revalidate.ts}

@@ -2,23 +2,25 @@ import { revalidatePath } from "next/cache";
 import { headers } from "next/headers";
 import { NextResponse } from "next/server";
 import { isAuthorized } from "./helpers";
+
 /**
  * Processes POST requests to revalidate root layout path.
  *
  * @returns {Promise<NextResponse>} Response indicating success or error.
  */
-export async function apiPostRevalidate() {
+export async function apiPostRevalidate(): Promise<NextResponse> {
     if (!isAuthorized(await headers())) {
-        return NextResponse.json('Unauthorized access', { status: 403 });
+        return NextResponse.json('Unauthorized access', { status: 403 })
     }
     try {
         revalidatePath('/', 'layout');
+
         return NextResponse.json({
             success: true,
             message: 'Saving and revalidation successful'
         }, { status: 200 });
-    }
-    catch (error) {
+
+    } catch (error) {
         const errorMessage = error instanceof Error ? error.message : 'Unknown error';
         return NextResponse.json({
             success: false,

package/{dist/router/routes/api/helpers.js → lib/router/routes/api/helpers.ts}

@@ -1,16 +1,17 @@
+import { ReadonlyHeaders } from "next/dist/server/web/spec-extension/adapters/headers";
+
 /**
  * Checks if request is authorized using API key.
  *
  * @param {ReadonlyHeaders} headerList - Headers from request.
  * @returns {boolean} True if authorized, false otherwise.
  */
-export function isAuthorized(headerList) {
+export function isAuthorized(headerList: ReadonlyHeaders): boolean {
     const authHeader = headerList.get('Authorization');
     if (authHeader && authHeader.startsWith('api-key ')) {
         const apiKey = authHeader.split(' ')[1];
         return apiKey === process.env.CROSS_CONTAINER_API_KEY;
-    }
-    else {
+    } else {
         return false;
     }
 }

package/lib/router/routes/author-archive.tsx

@@ -0,0 +1,75 @@
+import { MetadataResult, RouteProps, TemplateResult } from "../types";
+import { getPageNumber } from "../helpers";
+import { notFound } from "next/navigation";
+import { queriedObjectState } from "nextpress/globals/globals";
+import { AuthorMetadata, AuthorTemplate } from "nextpress/template-heirarchy/archive/author";
+
+/**
+ * Resolves the author archive route and maps it to the template hierarchy to return Metadata.
+ * * Routing Behavior:
+ * - Unconditionally routes to `AuthorMetadata`.
+ *
+ * @param {{ path: string[], metadata: true }} props - Route properties requesting metadata.
+ * @returns {Promise<MetadataResult>} The generated metadata.
+ */
+export function AuthorArchive(props: { path: string[], metadata: true }): Promise<MetadataResult>;
+
+/**
+ * Resolves the author archive route and maps it to the template hierarchy to return a Template.
+ * * Routing Behavior:
+ * - Unconditionally routes to `AuthorTemplate`.
+ *
+ * @param {{ path: string[], metadata?: false }} props - Route properties requesting a template.
+ * @returns {Promise<TemplateResult>} The rendered template component.
+ */
+export function AuthorArchive(props: { path: string[], metadata?: false }): Promise<TemplateResult>;
+
+/**
+ * Core implementation for the author archive route.
+ * Retrieves posts published by a specific author and updates the queried object state.
+ *
+ * @param {RouteProps} props - Route properties including the path array and metadata flag.
+ * @returns {Promise<MetadataResult | TemplateResult>} The metadata or template result based on the hierarchy.
+ * @throws {Error} Throws a Next.js notFound error if the author is not found.
+ */
+export async function AuthorArchive({ path, metadata = false }: RouteProps) {
+    const postsPerPage = Number(await getOption('posts_per_page')) ?? 10;
+
+    const page = getPageNumber(path) || 1;
+
+    const login = path[1];
+    if (!login) notFound();
+
+    const userQuery = await userLoader.findAndPrime({
+        login: login,
+        multiple: false,
+        noFoundRows: true
+    });
+
+    const user = await getUser(userQuery.ids[0] ?? 0)
+    if (!user) notFound();
+
+    const postIds = await postLoader.findAndPrime({
+        authorId: user.ID,
+        noFoundRows: false,
+        noPaging: false,
+        postType: 'post',
+        page: page,
+        postsPerPage: postsPerPage,
+        postStatus: 'publish',
+        orderBy: 'date'
+    });
+
+    const currentQueriedObject = {
+        objectType: 'user',
+        posts: postIds.ids,
+        page,
+        pageCount: Math.ceil(postIds.count / postsPerPage),
+        user: user.ID
+    }
+
+    const state = queriedObjectState();
+    state.currentState = currentQueriedObject;
+
+    return metadata ? await AuthorMetadata() : <AuthorTemplate/>;
+}

package/lib/router/routes/post-index-page.tsx

@@ -0,0 +1,58 @@
+import { MetadataResult, RouteProps, TemplateResult } from "../types";
+import { getPageNumber } from "../helpers";
+import { queriedObjectState } from "nextpress/globals/globals";
+import { HomeMetadata, HomeTemplate } from "nextpress/template-heirarchy/home/home";
+
+/**
+ * Resolves the post index page (blog home) route and maps it to the template hierarchy to return Metadata.
+ * * Routing Behavior:
+ * - Unconditionally routes to `HomeMetadata`.
+ *
+ * @param {{ path: string[], metadata: true }} props - Route properties requesting metadata.
+ * @returns {Promise<MetadataResult>} The generated metadata.
+ */
+export function PostIndexPage(props: { path: string[], metadata: true }): Promise<MetadataResult>;
+
+/**
+ * Resolves the post index page (blog home) route and maps it to the template hierarchy to return a Template.
+ * * Routing Behavior:
+ * - Unconditionally routes to `HomeTemplate`.
+ *
+ * @param {{ path: string[], metadata?: false }} props - Route properties requesting a template.
+ * @returns {Promise<TemplateResult>} The rendered template component.
+ */
+export function PostIndexPage(props: { path: string[], metadata?: false }): Promise<TemplateResult>;
+
+/**
+ * Core implementation for the post index page route.
+ * Fetches the paginated list of all published posts and updates the queried object state.
+ *
+ * @param {RouteProps} props - Route properties including the path array and metadata flag.
+ * @returns {Promise<MetadataResult | TemplateResult>} The metadata or template result based on the hierarchy.
+ */
+export async function PostIndexPage({ path, metadata = false }: RouteProps) {
+    const page = getPageNumber(path) || 1;
+    const postsPerPage = Number(await getOption('posts_per_page')) ?? 10;
+
+    const postIds = await postLoader.findAndPrime({
+        noFoundRows: false,
+        noPaging: false,
+        postType: 'post',
+        page: page,
+        postsPerPage: postsPerPage,
+        postStatus: 'publish',
+        orderBy: 'date'
+    });
+
+    const currentQueriedObject = {
+        posts: postIds.ids,
+        page,
+        pageCount: postIds.count / postsPerPage
+    }
+
+    const state = queriedObjectState();
+    state.currentState = currentQueriedObject;
+
+    return metadata ? await HomeMetadata() : <HomeTemplate/>;
+}
+

package/lib/router/routes/singular-page.tsx

@@ -0,0 +1,78 @@
+import { MetadataResult, RouteProps, TemplateResult } from "../types";
+import { PostIndexPage } from "./post-index-page";
+import { getPageNumber } from "../helpers";
+import { notFound } from "next/navigation";
+import { queriedObjectState } from "nextpress/globals/globals";
+import { SingleMetadata, SingleTemplate } from "nextpress/template-heirarchy/page/single";
+import { PageMetadata, PageTemplate } from "nextpress/template-heirarchy/page/page";
+
+/**
+ * Resolves the singular page route and maps it to the template hierarchy to return Metadata.
+ * * Routing Behavior:
+ * - If the post_type is 'post', it routes to `SingleMetadata`.
+ * - If the post ID matches the 'page_for_posts' option, it delegates routing to `PostIndexPage`.
+ * - Otherwise, it defaults to routing to `PageMetadata`.
+ *
+ * @param {{ path: string[], metadata: true }} props - Route properties requesting metadata.
+ * @returns {Promise<MetadataResult>} The generated metadata.
+ */
+export function SingularPage(props: { path: string[], metadata: true }): Promise<MetadataResult>;
+
+/**
+ * Resolves the singular page route and maps it to the template hierarchy to return a Template.
+ * * Routing Behavior:
+ * - If the post_type is 'post', it routes to `SingleTemplate`.
+ * - If the post ID matches the 'page_for_posts' option, it delegates routing to `PostIndexPage`.
+ * - Otherwise, it defaults to routing to `PageTemplate`.
+ *
+ * @param {{ path: string[], metadata?: false }} props - Route properties requesting a template.
+ * @returns {Promise<TemplateResult>} The rendered template component.
+ */
+export function SingularPage(props: { path: string[], metadata?: false }): Promise<TemplateResult>;
+
+/**
+ * Core implementation for the singular page/post route.
+ * Resolves the path to a specific post ID and updates the queried object state.
+ *
+ * @param {RouteProps} props - Route properties including the path array and metadata flag.
+ * @returns {Promise<MetadataResult | TemplateResult>} The metadata or template result based on the hierarchy.
+ * @throws {Error} Throws a Next.js notFound error if the path does not match any post or page.
+ */
+export async function SingularPage({ path, metadata = false }: RouteProps) {
+    let page = getPageNumber(path);
+    if (page) {
+        path = path.slice(0, -2);
+    } else {
+        page = 1;
+    }
+
+    const postId = (await postLoader.findAndPrime({
+        path: `/${path.join('/')}`,
+        multiple: false,
+        noFoundRows: true,
+        noPaging: true,
+        ignoreStickyPosts: true,
+    })).ids[0];
+    if (!postId) notFound();
+
+    const post = await getPost(postId) ?? notFound()
+
+    const postType = post.postType
+
+    const currentQueriedObject = {
+        objectType: 'post',
+        posts: [postId]
+    }
+    const state = queriedObjectState();
+    state.currentState = currentQueriedObject;
+
+    if (postType === 'post') {
+        return metadata ? await SingleMetadata() : <SingleTemplate/>;
+    }
+    if (post.ID !== Number(await getOption('page_for_posts'))) {
+        return metadata ? await PageMetadata() : <PageTemplate/>;
+    } else {
+        return metadata ? await PostIndexPage({path, metadata: true}) : <PostIndexPage path={path}/>
+    }
+}
+