nextpress-core 1.0.0 → 1.0.1

package/{lib/repository/userquery/user-query.ts → dist/repository/userquery/user-query.js}

@@ -1,194 +1,178 @@
 import { wpdb } from "@/wpdb/wpdb";
-import { IUser } from "../../entities/user/user.interface";
-import { EntityQuery } from "../../globals/entity-loader/entity-loader";
 import { sql } from "kysely";
-
 /**
  * Executes database queries to retrieve user IDs and counts based on provided arguments.
  */
-export class UserQuery implements EntityQuery<IUser>
-{
-    private userCount?: number;
-
-    constructor(
-        private args: UserQueryArgs
-    ) {}
-
-    public getCount(): number | undefined {
+export class UserQuery {
+    constructor(args) {
+        this.args = args;
+    }
+    getCount() {
         return this.userCount;
     }
-
-    public async getIds(): Promise<number[]> {
+    async getIds() {
+        var _a, _b, _c;
         let query = wpdb.selectFrom('wpUsers');
-
         // --- ID Filters ---
         if (this.args.userId) {
             const types = Array.isArray(this.args.userId) ? this.args.userId : [this.args.userId];
             query = query.where('wpUsers.ID', 'in', types);
         }
-        if (this.args.userIdsNotIn) query = query.where('wpUsers.ID', 'not in', this.args.userIdsNotIn);
-
+        if (this.args.userIdsNotIn)
+            query = query.where('wpUsers.ID', 'not in', this.args.userIdsNotIn);
         // --- Nicename Filters ---
-        if (this.args.nicename)         query = query.where('wpUsers.userNicename', '=', this.args.nicename);
-        if (this.args.nicenameIn)       query = query.where('wpUsers.userNicename', 'in', this.args.nicenameIn);
-        if (this.args.nicenameNotIn)    query = query.where('wpUsers.userNicename', 'not in', this.args.nicenameNotIn);
-
+        if (this.args.nicename)
+            query = query.where('wpUsers.userNicename', '=', this.args.nicename);
+        if (this.args.nicenameIn)
+            query = query.where('wpUsers.userNicename', 'in', this.args.nicenameIn);
+        if (this.args.nicenameNotIn)
+            query = query.where('wpUsers.userNicename', 'not in', this.args.nicenameNotIn);
         // --- Display name Filters ---
-        if (this.args.displayName)      query = query.where('wpUsers.displayName', '=', this.args.displayName);
-        if (this.args.displayNameIn)    query = query.where('wpUsers.displayName', 'in', this.args.displayNameIn);
-        if (this.args.displayNameNotIn) query = query.where('wpUsers.displayName', 'not in', this.args.displayNameNotIn);
-
+        if (this.args.displayName)
+            query = query.where('wpUsers.displayName', '=', this.args.displayName);
+        if (this.args.displayNameIn)
+            query = query.where('wpUsers.displayName', 'in', this.args.displayNameIn);
+        if (this.args.displayNameNotIn)
+            query = query.where('wpUsers.displayName', 'not in', this.args.displayNameNotIn);
         // --- Login Filters ---
-        if (this.args.login)        query = query.where('wpUsers.userLogin', '=', this.args.login);
-        if (this.args.loginIn)      query = query.where('wpUsers.userLogin', 'in', this.args.loginIn);
-        if (this.args.loginNotIn)   query = query.where('wpUsers.userLogin', 'not in', this.args.loginNotIn);
-
+        if (this.args.login)
+            query = query.where('wpUsers.userLogin', '=', this.args.login);
+        if (this.args.loginIn)
+            query = query.where('wpUsers.userLogin', 'in', this.args.loginIn);
+        if (this.args.loginNotIn)
+            query = query.where('wpUsers.userLogin', 'not in', this.args.loginNotIn);
         // --- Role Filters ---
         if (this.args.roleIn) {
             query = query
                 .innerJoin('wpUsermeta as um_role_in', 'wpUsers.ID', 'um_role_in.userId')
                 .where('um_role_in.metaKey', '=', 'wp_capabilities')
                 .where((eb) => {
-                    const orClauses = this.args.roleIn!.map(role =>
-                        eb('um_role_in.metaValue', 'like', `%"${role}"%`)
-                    );
-                    return eb.or(orClauses);
-                });
+                const orClauses = this.args.roleIn.map(role => eb('um_role_in.metaValue', 'like', `%"${role}"%`));
+                return eb.or(orClauses);
+            });
         }
-
         if (this.args.roleAnd) {
             this.args.roleAnd.forEach((role, index) => {
-                const alias = `um_role_and_${index}` as const;
-
+                const alias = `um_role_and_${index}`;
                 query = query
                     .innerJoin(`wpUsermeta as ${alias}`, 'wpUsers.ID', `${alias}.userId`)
                     .where(`${alias}.metaKey`, '=', 'wp_capabilities')
                     .where(`${alias}.metaValue`, 'like', `%"${role}"%`);
             });
         }
-
         if (this.args.roleNotIn) {
             this.args.roleNotIn.forEach((role, index) => {
-                const alias = `um_role_not_${index}` as const;
-
+                const alias = `um_role_not_${index}`;
                 query = query
                     .innerJoin(`wpUsermeta as ${alias}`, 'wpUsers.ID', `${alias}.userId`)
                     .where(`${alias}.metaKey`, '=', 'wp_capabilities')
                     .where(`${alias}.metaValue`, 'not like', `%"${role}"%`);
             });
         }
-
         // --- Search Filters ---
         if (this.args.search) {
             const searchTerm = `%${this.args.search}%`;
             const searchCols = this.args.search_columns || ['ID', 'userLogin', 'userEmail', 'userUrl', 'userNicename', 'displayName'];
-
             query = query.where((eb) => {
                 const orClauses = searchCols.map(col => eb(col, 'like', searchTerm));
                 return eb.or(orClauses);
             });
         }
-
         // --- Published Posts Filter ---
         if (this.args.hasPublishedPosts) {
-            query = query.where((eb) => eb(
-                eb.selectFrom('wpPosts')
-                    .select(eb.fn.count<number>('ID').as('count'))
-                    .whereRef('wpPosts.postAuthor', '=', 'wpUsers.ID')
-                    .where('wpPosts.postStatus', '=', 'publish'),
-                '>', 0
-            ));
+            query = query.where((eb) => eb(eb.selectFrom('wpPosts')
+                .select(eb.fn.count('ID').as('count'))
+                .whereRef('wpPosts.postAuthor', '=', 'wpUsers.ID')
+                .where('wpPosts.postStatus', '=', 'publish'), '>', 0));
         }
-
         // 3. Calculate Total Count (Before Limits/Offsets)
         if (!this.args.noFoundRows) {
             try {
                 const countQueryBase = query.clearSelect().select('wpUsers.ID').distinct();
                 const countResult = await wpdb.selectFrom(countQueryBase.as('sub'))
-                    .select(sql<number>`count(*)`.as('count'))
+                    .select(sql `count(*)`.as('count'))
                     .executeTakeFirst();
-
                 this.userCount = countResult ? Number(countResult.count) : undefined;
-            } catch (error: any) {
+            }
+            catch (error) {
                 console.error('WPUserQuery: Cannot get row count: ', error.message);
                 this.userCount = undefined;
             }
-        } else {
+        }
+        else {
             this.userCount = undefined;
         }
-
         // 4. Apply ORDER BY
         const orderDirection = this.args.order === 'DESC' ? 'desc' : 'asc';
         const orderBy = this.args.orderBy || 'none';
-
-        switch(orderBy) {
-            case 'ID':         query = query.orderBy('wpUsers.ID', orderDirection).orderBy('wpUsers.ID', orderDirection); break;
-            case 'name':       query = query.orderBy('wpUsers.displayName', orderDirection).orderBy('wpUsers.ID', orderDirection); break;
-            case 'login':      query = query.orderBy('wpUsers.userLogin', orderDirection).orderBy('wpUsers.ID', orderDirection); break;
-            case 'nicename':   query = query.orderBy('wpUsers.userNicename', orderDirection).orderBy('wpUsers.ID', orderDirection); break;
-            case 'email':      query = query.orderBy('wpUsers.userEmail', orderDirection).orderBy('wpUsers.ID', orderDirection); break;
-            case 'registered': query = query.orderBy('wpUsers.userRegistered', orderDirection).orderBy('wpUsers.ID', orderDirection); break;
+        switch (orderBy) {
+            case 'ID':
+                query = query.orderBy('wpUsers.ID', orderDirection).orderBy('wpUsers.ID', orderDirection);
+                break;
+            case 'name':
+                query = query.orderBy('wpUsers.displayName', orderDirection).orderBy('wpUsers.ID', orderDirection);
+                break;
+            case 'login':
+                query = query.orderBy('wpUsers.userLogin', orderDirection).orderBy('wpUsers.ID', orderDirection);
+                break;
+            case 'nicename':
+                query = query.orderBy('wpUsers.userNicename', orderDirection).orderBy('wpUsers.ID', orderDirection);
+                break;
+            case 'email':
+                query = query.orderBy('wpUsers.userEmail', orderDirection).orderBy('wpUsers.ID', orderDirection);
+                break;
+            case 'registered':
+                query = query.orderBy('wpUsers.userRegistered', orderDirection).orderBy('wpUsers.ID', orderDirection);
+                break;
             case 'post_count':
-                query = query.orderBy(
-                    (eb) => eb.selectFrom('wpPosts')
-                            .select(eb.fn.count('ID').as('count'))
-                            .whereRef('wpPosts.postAuthor', '=', 'wpUsers.ID')
-                            .where('wpPosts.postStatus', '=', 'publish'),
-                    orderDirection
-                ).orderBy('wpUsers.ID', orderDirection);
+                query = query.orderBy((eb) => eb.selectFrom('wpPosts')
+                    .select(eb.fn.count('ID').as('count'))
+                    .whereRef('wpPosts.postAuthor', '=', 'wpUsers.ID')
+                    .where('wpPosts.postStatus', '=', 'publish'), orderDirection).orderBy('wpUsers.ID', orderDirection);
                 break;
             case 'none': break;
             default:
                 query = query.orderBy('wpUsers.userLogin', orderDirection).orderBy('wpUsers.ID', orderDirection);
                 break;
         }
-
         // 5. Apply LIMIT & OFFSET
         if (!this.args.noPaging) {
-            const perPage = this.args.usersPerPage ?? -1;
-
+            const perPage = (_a = this.args.usersPerPage) !== null && _a !== void 0 ? _a : -1;
             if (perPage > -1) {
                 query = query.limit(perPage);
-
-                const page = this.args.page ?? 1;
-                const baseOffset = this.args.offset ?? 0;
+                const page = (_b = this.args.page) !== null && _b !== void 0 ? _b : 1;
+                const baseOffset = (_c = this.args.offset) !== null && _c !== void 0 ? _c : 0;
                 const offsetAmount = ((page - 1) * perPage) + baseOffset;
-
                 if (offsetAmount > 0) {
                     query = query.offset(offsetAmount);
                 }
             }
         }
-
         if (this.args.metaQuery) {
-            let dynamicQuery: any = query;
-
+            let dynamicQuery = query;
             for (let metaQuery of this.args.metaQuery) {
                 const uniqueAlias = `meta_${metaQuery.as}`;
-
-                dynamicQuery = dynamicQuery.leftJoin(`wpUsermeta as ${uniqueAlias}`, (join: any) =>
-                    join
-                        .onRef(`${uniqueAlias}.userId`, '=', 'wpUsers.ID')
-                        .on(`${uniqueAlias}.metaKey`, '=', metaQuery.metaKey)
-                    )
+                dynamicQuery = dynamicQuery.leftJoin(`wpUsermeta as ${uniqueAlias}`, (join) => join
+                    .onRef(`${uniqueAlias}.userId`, '=', 'wpUsers.ID')
+                    .on(`${uniqueAlias}.metaKey`, '=', metaQuery.metaKey))
                     .select(`${uniqueAlias}.metaValue as ${metaQuery.as}`);
             }
-
             query = dynamicQuery;
         }
-
         try {
             if (this.args.multiple !== false) {
                 return (await query
                     .select('wpUsers.ID as id')
                     .groupBy('wpUsers.ID')
                     .execute()).map(res => res.id);
-            } else {
+            }
+            else {
                 return (await query
                     .select('wpUsers.ID as id')
                     .execute()).map(res => res.id);
             }
-        } catch (error: any) {
+        }
+        catch (error) {
             throw new Error(`WPUserQuery: Cannot get users: ${error.message}`, { cause: error });
         }
     }

package/dist/router/helpers.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Retrieves page number from path array.
+ *
+ * @param {string[]} path - Array of path segments.
+ * @returns {number | undefined} Page number or undefined.
+ */
+export declare function getPageNumber(path: string[]): number | undefined;
+/**
+ * Splits path string into array of segments.
+ *
+ * @param {string} path - Path string.
+ * @returns {string[]} Array of path segments.
+ */
+export declare function splitPath(path: string): string[];

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

@@ -4,17 +4,17 @@
  * @param {string[]} path - Array of path segments.
  * @returns {number | undefined} Page number or undefined.
  */
-export function getPageNumber(path: string[]): number|undefined {
+export function getPageNumber(path) {
     return path[path.length - 2] === 'page' ? Number(path[path.length - 1]) || undefined : undefined;
 }
-
 /**
  * Splits path string into array of segments.
  *
  * @param {string} path - Path string.
  * @returns {string[]} Array of path segments.
  */
-export function splitPath(path: string): string[] {
-    if (!path) return [];
+export function splitPath(path) {
+    if (!path)
+        return [];
     return path.split('/').filter(Boolean);
 }

package/dist/router/nextpress-layout.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The layout for the application.
+ * Defines the main HTML shell, handles Draft Mode validation, primes necessary global WordPress options,
+ * and routes directly to the `LayoutTemplate` within the Nextpress template hierarchy.
+ *
+ * @param {Readonly<{children: React.ReactNode;}>} props - Component properties, wrapping the children pages.
+ * @returns {Promise<JSX.Element>} The root layout of the entire app.
+ */
+export declare function NextpressLayout({ children }: Readonly<{
+    children: React.ReactNode;
+}>): Promise<import("react").JSX.Element>;

package/{lib/router/nextpress-layout.tsx → dist/router/nextpress-layout.js}

@@ -1,11 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import fonts from "@/fonts";
 import { LayoutTemplate } from "@/app/_templates/layout";
 import { cookies, draftMode } from "next/headers";
 import { getLanguageAttributes } from "@/services/metadata/get-language-attribute";
 import { RenderTheAdminBar } from "@/ui/render-the-admin-bar";
-
 const fontClasses = fonts.map(font => font.className).join(' ');
-
 /**
  * The layout for the application.
  * Defines the main HTML shell, handles Draft Mode validation, primes necessary global WordPress options,
@@ -14,35 +13,19 @@ const fontClasses = fonts.map(font => font.className).join(' ');
  * @param {Readonly<{children: React.ReactNode;}>} props - Component properties, wrapping the children pages.
  * @returns {Promise<JSX.Element>} The root layout of the entire app.
  */
-export async function NextpressLayout({ children }: Readonly<{children: React.ReactNode;}>) {
+export async function NextpressLayout({ children }) {
+    var _a, _b;
     const draftModeEnabled = (await draftMode()).isEnabled;
     let loggedInUserId = 0;
     if (draftModeEnabled) {
         const cookieStore = await cookies();
-        loggedInUserId = Number(cookieStore.get('nextpress_logged_in_user_id')?.value) || 0;
+        loggedInUserId = Number((_a = cookieStore.get('nextpress_logged_in_user_id')) === null || _a === void 0 ? void 0 : _a.value) || 0;
     }
-
     optionLoader.findAndPrime({
         column: 'optionName',
         operand: 'in',
         value: nextpressConfig.preLoadOptions || ''
-    })
-
+    });
     const languageAttributes = await getLanguageAttributes();
-
-    return (
-        <html
-            lang={languageAttributes}
-            className={fontClasses}
-        >
-            <body className="">
-                {(draftModeEnabled && (await getUser(loggedInUserId))?.showAdminBar) && <RenderTheAdminBar loggedInUserId={loggedInUserId}/>}
-                <LayoutTemplate>
-                    {children}
-                </LayoutTemplate>
-            </body>
-        </html>
-    );
+    return (_jsx("html", { lang: languageAttributes, className: fontClasses, children: _jsxs("body", { className: "", children: [(draftModeEnabled && ((_b = (await getUser(loggedInUserId))) === null || _b === void 0 ? void 0 : _b.showAdminBar)) && _jsx(RenderTheAdminBar, { loggedInUserId: loggedInUserId }), _jsx(LayoutTemplate, { children: children })] }) }));
 }
-
-

package/dist/router/nextpress-proxy.d.ts

@@ -0,0 +1,8 @@
+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 declare function nextpressProxy(request: NextRequest): NextResponse;

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

@@ -1,22 +1,18 @@
-import { NextRequest, NextResponse } from "next/server";
-
+import { 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: NextRequest): NextResponse {
+export function nextpressProxy(request) {
     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;
@@ -24,22 +20,14 @@ export function nextpressProxy(request: NextRequest): NextResponse {
     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.d.ts

@@ -0,0 +1,9 @@
+import { NextpressRouterProps } from "./router";
+export type NextpressStaticParams = Awaited<NextpressRouterProps['params']>[];
+/**
+ * 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 declare function nextpressStaticParams(): Promise<NextpressStaticParams>;

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

@@ -1,17 +1,13 @@
 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(): Promise<NextpressStaticParams> {
+export async function nextpressStaticParams() {
+    var _a;
     const { ids: authorIds } = await userLoader.findAndPrime({
         hasPublishedPosts: true,
         noFoundRows: false,
@@ -19,35 +15,28 @@ export async function nextpressStaticParams(): Promise<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: archivedPostTypes?.filter(p => !publicPostTypes?.includes(p)) ?? 'post',
+        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',
         ignoreStickyPosts: true,
         noFoundRows: true,
         noPaging: true,
     });
     const { ids: postIds } = await postLoader.findAndPrime({
         postStatus: 'publish',
-        postType: archivedPostTypes ?? 'post',
+        postType: archivedPostTypes !== null && archivedPostTypes !== void 0 ? 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 ?? []).map(type => [type]);
-
+    const archivedPostArchivePaths = (archivedPostTypes !== null && archivedPostTypes !== void 0 ? archivedPostTypes : []).map(type => [type]);
     const postPaths = posts.map(post => splitPath(post.path));
-
     const allPaths = [
         ...authorPaths,
         ...termPaths,
@@ -55,7 +44,6 @@ export async function nextpressStaticParams(): Promise<NextpressStaticParams> {
         ...archivedPostArchivePaths,
         ...postPaths
     ];
-
     return allPaths.map(segments => ({
         path: segments.filter(Boolean)
     }));

package/dist/router/router.d.ts

@@ -0,0 +1,23 @@
+import "../globals/globals";
+import { Metadata } from "next";
+export type NextpressRouterProps = {
+    params: Promise<{
+        path: string[] | undefined;
+    }>;
+};
+/**
+ * Generates metadata dynamically for a given request path.
+ * Routes the path to the correct Nextpress routing function based on the configuration logic.
+ *
+ * @param {NextpressRouterProps} props - The dynamic properties for this page route.
+ * @returns {Promise<Metadata>} The Metadata object for the matched route.
+ */
+export declare function generateNextpressMetadata({ params }: NextpressRouterProps): Promise<Metadata>;
+/**
+ * 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.
+ *
+ * @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 function NextPressPage({ params }: NextpressRouterProps): Promise<import("react").JSX.Element>;

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

@@ -1,18 +1,10 @@
+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.
@@ -20,22 +12,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 }: NextpressRouterProps): Promise<Metadata> {
-    const path = (await params).path ?? [];
-
+export async function generateNextpressMetadata({ params }) {
+    var _a;
+    const path = (_a = (await params).path) !== null && _a !== void 0 ? _a : [];
     if (!path.length) {
-        return await SiteFrontPage({path, metadata: true});
+        return await SiteFrontPage({ path, metadata: true });
     }
-    if (publicTaxonomies?.includes(path[0]!)) {
-        return await TermArchive({path, metadata: true});
+    if (publicTaxonomies === null || publicTaxonomies === void 0 ? void 0 : 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.
@@ -43,19 +35,19 @@ export async function generateNextpressMetadata({ params }: NextpressRouterProps
  * @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 }: NextpressRouterProps) {
-    const path = (await params).path ?? [];
-
+export default async function NextPressPage({ params }) {
+    var _a;
+    const path = (_a = (await params).path) !== null && _a !== void 0 ? _a : [];
     if (!path.length) {
-        return <SiteFrontPage path={path}/>
+        return _jsx(SiteFrontPage, { path: path });
     }
-    if (publicTaxonomies?.includes(path[0]!)) {
-        return <TermArchive path={path}/>
+    if (publicTaxonomies === null || publicTaxonomies === void 0 ? void 0 : publicTaxonomies.includes(path[0])) {
+        return _jsx(TermArchive, { path: path });
     }
     if (path[0] === 'author') {
-        return <AuthorArchive path={path}/>
-    } else {
-        return <SingularPage path={path}/>
+        return _jsx(AuthorArchive, { path: path });
+    }
+    else {
+        return _jsx(SingularPage, { path: path });
     }
 }
-

package/dist/router/routes/api/api-get-admin-bar.d.ts

@@ -0,0 +1,8 @@
+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 declare function apiGetAdminBar(request: NextRequest): Promise<NextResponse>;