nextpress-core 1.0.3 → 2.0.0

package/lib/router/routes/site-front-page.tsx

@@ -0,0 +1,51 @@
+import { queriedObjectState } from "nextpress/globals/globals";
+import { MetadataResult, RouteProps, TemplateResult } from "../types";
+import { PostIndexPage } from "./post-index-page";
+import { PageMetadata, PageTemplate } from "nextpress/template-heirarchy/page/page";
+
+/**
+ * Resolves the site front page route and maps it to the template hierarchy to return Metadata.
+ * * Routing Behavior:
+ * - If a static page is set as the homepage ('page_on_front'), it routes to `PageMetadata`.
+ * - If no static page is set, it delegates routing to `PostIndexPage`.
+ *
+ * @param {{ path: string[], metadata: true }} props - Route properties requesting metadata.
+ * @returns {Promise<MetadataResult>} The generated metadata.
+ */
+export function SiteFrontPage(props: { path: string[], metadata: true }): Promise<MetadataResult>;
+
+/**
+ * Resolves the site front page route and maps it to the template hierarchy to return a Template.
+ * * Routing Behavior:
+ * - If a static page is set as the homepage ('page_on_front'), it routes to `PageTemplate`.
+ * - If no static page is set, it delegates routing to `PostIndexPage`.
+ *
+ * @param {{ path: string[], metadata?: false }} props - Route properties requesting a template.
+ * @returns {Promise<TemplateResult>} The rendered template component.
+ */
+export function SiteFrontPage(props: { path: string[], metadata?: false }): Promise<TemplateResult>;
+
+/**
+ * Core implementation for the site front page (root) route.
+ * Checks for a configured static front page 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 SiteFrontPage({ path, metadata = false }: RouteProps) {
+    const homepageId = Number(await getOption('page_on_front'));
+
+    if (homepageId) {
+        const currentQueriedObject = {
+            objectType: 'post',
+            posts: [homepageId]
+        }
+
+        const state = queriedObjectState();
+        state.currentState = currentQueriedObject;
+
+        return metadata ? await PageMetadata() : <PageTemplate/>;
+    } else {
+        return metadata ? await PostIndexPage({path, metadata: true}) : <PostIndexPage path={path}/>
+    }
+}

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

@@ -0,0 +1,93 @@
+import { MetadataResult, RouteProps, TemplateResult } from "../types";
+import { getPageNumber } from "../helpers";
+import { notFound } from "next/navigation";
+import { queriedObjectState } from "nextpress/globals/globals";
+import { CategoryMetadata, CategoryTemplate } from "nextpress/template-heirarchy/archive/category";
+import { TagMetadata, TagTemplate } from "nextpress/template-heirarchy/archive/tag";
+import { TaxonomyMetadata, TaxonomyTemplate } from "nextpress/template-heirarchy/archive/taxonomy";
+
+/**
+ * Resolves the term archive route and maps it to the template hierarchy to return Metadata.
+ * * Routing Behavior:
+ * - If the taxonomy is 'category', it routes to `CategoryMetadata`.
+ * - If the taxonomy is 'tag', it routes to `TagMetadata`.
+ * - For all other taxonomies, it routes to `TaxonomyMetadata`.
+ *
+ * @param {{ path: string[], metadata: true }} props - Route properties requesting metadata.
+ * @returns {Promise<MetadataResult>} The generated metadata.
+ */
+export function TermArchive(props: { path: string[], metadata: true }): Promise<MetadataResult>;
+
+/**
+ * Resolves the term archive route and maps it to the template hierarchy to return a Template.
+ * * Routing Behavior:
+ * - If the taxonomy is 'category', it routes to `CategoryTemplate`.
+ * - If the taxonomy is 'tag', it routes to `TagTemplate`.
+ * - For all other taxonomies, it routes to `TaxonomyTemplate`.
+ *
+ * @param {{ path: string[], metadata?: false }} props - Route properties requesting a template.
+ * @returns {Promise<TemplateResult>} The rendered template component.
+ */
+export function TermArchive(props: { path: string[], metadata?: false }): Promise<TemplateResult>;
+
+/**
+ * Core implementation for the term archive route.
+ * Retrieves posts for a specific taxonomy term 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 term does not exist.
+ */
+export async function TermArchive({ path, metadata = false }: RouteProps) {
+    const postsPerPage = Number(await getOption('posts_per_page')) ?? 10;
+
+    let page = getPageNumber(path);
+    if (page) {
+        path = path.slice(0, -2);
+    } else {
+        page = 1;
+    }
+
+    const taxonomy = path[0] ?? '';
+    const pathString = path.slice(1).join('/');
+
+    const termQuery = await termLoader.findAndPrime({
+        taxonomy,
+        path: `/${pathString}`
+    });
+    if (!termQuery.ids.length) notFound();
+
+    const postIds = await postLoader.findAndPrime({
+        termIn: termQuery.ids,
+        noFoundRows: false,
+        noPaging: false,
+        postType: 'post',
+        page: page,
+        postsPerPage: postsPerPage,
+        postStatus: 'publish',
+        orderBy: 'date'
+    });
+
+    const terms = await getTerms(termQuery.ids);
+    const mainTerm = terms.find(term => term.slug === path[path.length - 1])!;
+
+    const currentQueriedObject = {
+        objectType: 'term',
+        posts: postIds.ids,
+        page,
+        pageCount: Math.ceil(postIds.count / postsPerPage),
+        mainTerm: mainTerm.termId,
+        terms: termQuery.ids
+    };
+
+    const state = queriedObjectState();
+    state.currentState = currentQueriedObject;
+
+    if (taxonomy === 'category') {
+        return metadata ? await CategoryMetadata() : <CategoryTemplate/>;
+    } else if (taxonomy === 'tag') {
+        return metadata ? await TagMetadata() : <TagTemplate/>;
+    } else {
+        return metadata ? await TaxonomyMetadata() : <TaxonomyTemplate/>;
+    }
+}

package/{dist/router/types.d.ts → lib/router/types.ts}

@@ -1,8 +1,10 @@
 import { Metadata } from "next";
-import { JSX } from "react/jsx-runtime";
+import { JSX } from "react";
+
 export type TemplateResult = JSX.Element;
 export type MetadataResult = Metadata;
+
 export type RouteProps = {
     path: string[];
     metadata?: boolean;
-};
+}

package/{dist/services/get-menu.js → lib/services/get-menu.ts}

@@ -1,80 +1,104 @@
+import { IMenuItem } from "../entities/post/post.interface";
 import { getThemeMods } from "./get-theme-mods";
+
+type Menu = {
+    menuItem: IMenuItem,
+    children: Menu[]
+}
+
 /**
  * Retrieves a menu by its location identifier.
  *
  * @param {string} menuLocation - The location identifier of the menu.
  * @returns {Promise<Menu[] | undefined>} An array of menu items representing the menu tree, or undefined if the menu is not found.
  */
-export async function getMenu(menuLocation) {
-    var _a, _b, _c, _d;
+export async function getMenu(menuLocation: string): Promise<Menu[] | undefined> {
     const navMenuLocations = await getThemeMods('nav_menu_locations');
-    if (!navMenuLocations || typeof navMenuLocations !== 'object')
-        return;
-    const menuTermId = Number(navMenuLocations[menuLocation]) || undefined;
-    if (!menuTermId)
-        return;
+    if (!navMenuLocations || typeof navMenuLocations !== 'object') return;
+
+    const menuTermId = Number((navMenuLocations as Record<string, any>)[menuLocation]) || undefined;
+    if (!menuTermId) return;
+
     const postQuery = await postLoader.findAndPrime({
         termId: menuTermId,
         postStatus: 'publish',
         postType: 'nav_menu_item',
         noFoundRows: true,
         noPaging: true
-    });
-    const menuItems = (await getPosts(postQuery.ids)).sort((a, b) => a.menuOrder - b.menuOrder);
+    })
+
+    const menuItems: IMenuItem[] = (await getPosts(postQuery.ids)).sort((a, b) => a.menuOrder - b.menuOrder);
+
     // Prime cache to get paths in bunch later
     for (const item of menuItems) {
-        if (!item.menuItemAttributes)
-            continue;
+        if (!item.menuItemAttributes) continue;
+
         if (item.menuItemAttributes.type === 'post_type') {
-            postLoader.prime([item.menuItemAttributes.objectId]);
-        }
-        else if (item.menuItemAttributes.type === 'taxonomy') {
-            termLoader.prime([item.menuItemAttributes.objectId]);
+            postLoader.prime([item.menuItemAttributes.objectId])
+        } else if (item.menuItemAttributes.type === 'taxonomy') {
+            termLoader.prime([item.menuItemAttributes.objectId])
         }
     }
-    const map = new Map();
-    const tree = [];
+
+    const map = new Map<number, Menu>();
+    const tree: Menu[] = [];
+
     for (const item of menuItems) {
-        if (!item.menuItemAttributes)
-            continue;
-        const menuItemAttributes = Object.assign({}, item.menuItemAttributes);
+        if (!item.menuItemAttributes) continue;
+
+        const menuItemAttributes = { ...item.menuItemAttributes };
+
         if (item.menuItemAttributes.type === 'post_type') {
             const post = await getPost(menuItemAttributes.objectId);
-            menuItemAttributes.url = (_a = post === null || post === void 0 ? void 0 : post.path) !== null && _a !== void 0 ? _a : '';
+
+            menuItemAttributes.url = post?.path ?? '';
+
             if (!menuItemAttributes.label) {
-                menuItemAttributes.label = (_b = post === null || post === void 0 ? void 0 : post.postTitle) !== null && _b !== void 0 ? _b : '';
+                menuItemAttributes.label = post?.postTitle ?? '';
             }
-        }
-        else if (item.menuItemAttributes.type === 'taxonomy') {
+        } else if (item.menuItemAttributes.type === 'taxonomy') {
             const term = await getTerm(menuItemAttributes.objectId);
-            menuItemAttributes.url = (_c = term === null || term === void 0 ? void 0 : term.path) !== null && _c !== void 0 ? _c : '';
+
+            menuItemAttributes.url = term?.path ?? '';
+
             if (!menuItemAttributes.label) {
-                menuItemAttributes.label = (_d = term === null || term === void 0 ? void 0 : term.name) !== null && _d !== void 0 ? _d : '';
+                menuItemAttributes.label = term?.name ?? '';
             }
         }
-        const safeItem = Object.assign(Object.assign({}, item), { menuItemAttributes });
-        const node = {
+
+        const safeItem: IMenuItem = {
+            ...item,
+            menuItemAttributes
+        };
+
+        const node: Menu = {
             menuItem: safeItem,
             children: []
         };
+
         map.set(item.ID, node);
     }
+
     for (const item of menuItems) {
-        if (!item.menuItemAttributes)
-            continue;
+        if (!item.menuItemAttributes) continue;
+
         const currentNode = map.get(item.ID);
-        if (!currentNode)
-            continue;
+        if (!currentNode) continue;
+
         const parentId = item.menuItemAttributes.parentId;
+
         if (parentId === 0) {
             tree.push(currentNode);
             continue;
         }
+
         const parentNode = map.get(parentId);
+
         if (parentNode) {
             parentNode.children.push(currentNode);
             map.set(parentNode.menuItem.ID, parentNode);
         }
     }
+
     return tree;
 }

package/{dist/services/get-theme-mods.js → lib/services/get-theme-mods.ts}

@@ -1,14 +1,16 @@
 import { unserialize } from "php-serialize";
+
 /**
  * Retrieves a theme modification value by key.
  *
  * @param {string} key - The key of the theme modification to retrieve.
  * @returns {Promise<unknown | undefined>} The theme modification value, or undefined if not found.
  */
-export async function getThemeMods(key) {
+export async function getThemeMods(key: string): Promise<unknown | undefined> {
     const themeModOption = await getOption('theme_mods_nextpress_theme');
-    const themeMods = unserialize(themeModOption !== null && themeModOption !== void 0 ? themeModOption : 'a:0:{}');
-    if (Array.isArray(themeMods))
-        return;
+
+    const themeMods: Record<string, unknown> | unknown[] = unserialize(themeModOption ?? 'a:0:{}');
+    if (Array.isArray(themeMods)) return;
+
     return themeMods[key];
 }

package/{dist/services/metadata/get-blogname.js → lib/services/metadata/get-blogname.ts}

@@ -3,7 +3,7 @@
  *
  * @returns {Promise<string>} The blog name, defaulting to 'My Blog' if not found.
  */
-export async function getBlogname() {
+export async function getBlogname(): Promise<string> {
     const blognameOption = await getOption('blogname');
-    return blognameOption !== null && blognameOption !== void 0 ? blognameOption : 'My Blog';
+    return blognameOption ?? 'My Blog';
 }

package/{dist/services/metadata/get-favicon-url.js → lib/services/metadata/get-favicon-url.ts}

@@ -3,10 +3,11 @@
  *
  * @returns {Promise<string|undefined>} The URL of the favicon, or undefined if not set.
  */
-export async function getFaviconURL() {
+export async function getFaviconURL(): Promise<string|undefined> {
     const iconID = await getOption('site_icon');
-    if (!iconID)
-        return;
+    if (!iconID) return;
+
     const iconMediaPost = await getPost(Number(iconID));
-    return iconMediaPost === null || iconMediaPost === void 0 ? void 0 : iconMediaPost.guid;
+
+    return iconMediaPost?.guid;
 }

package/{dist/services/metadata/get-language-attribute.js → lib/services/metadata/get-language-attribute.ts}

@@ -3,7 +3,7 @@
  *
  * @returns {Promise<string>} The language attribute, defaulting to 'en_US' if not found.
  */
-export async function getLanguageAttributes() {
+export async function getLanguageAttributes(): Promise<string> {
     const wplang = await getOption('WPLANG');
     return wplang || 'en_US';
 }

package/{dist/services/utilities/capitalise-first-letter.js → lib/services/utilities/capitalise-first-letter.ts}

@@ -4,8 +4,7 @@
  * @param {string} string - The string to process.
  * @returns {string} The string with its first letter capitalized.
  */
-export function capitalizeFirstLetter(string) {
-    if (!string)
-        return string;
+export function capitalizeFirstLetter(string: string): string {
+    if (!string) return string;
     return string.charAt(0).toUpperCase() + string.slice(1);
 }

package/{dist/services/utilities/esc-html.js → lib/services/utilities/esc-html.ts}

@@ -1,10 +1,12 @@
 import DOMPurify from "isomorphic-dompurify";
+
 /**
  * Sanitizes an HTML string.
  *
  * @param {string} string - The string to sanitize.
  * @returns {string} The sanitized string.
  */
-export function escHtml(string) {
+export function escHtml(string: string) {
     return DOMPurify.sanitize(string);
 }
+

package/{dist/services/utilities/get-date-time-formatter.js → lib/services/utilities/get-date-time-formatter.ts}

@@ -1,39 +1,49 @@
 import { getLanguageAttributes } from "../metadata/get-language-attribute";
+
 /**
  * Creates a DateTimeFormat instance based on WordPress settings.
  *
  * @returns {Promise<Intl.DateTimeFormat>} The formatter instance.
  */
-export async function getDateTimeFormatter() {
-    var _a;
-    const dateFormat = (_a = await getOption('date_format')) !== null && _a !== void 0 ? _a : 'F j, Y';
+export async function getDateTimeFormatter(): Promise<Intl.DateTimeFormat> {
+    const dateFormat = await getOption('date_format') ?? 'F j, Y';
     const lang = await getLanguageAttributes();
-    const dateTimeOptionsMap = {
+
+    const dateTimeOptionsMap: Record<string, Intl.DateTimeFormatOptions> = {
         'd': { day: '2-digit' },
         'j': { day: 'numeric' },
+
         'l': { weekday: 'long' },
         'D': { weekday: 'short' },
+
         'm': { month: '2-digit' },
         'n': { month: 'numeric' },
         'F': { month: 'long' },
         'M': { month: 'short' },
+
         'Y': { year: 'numeric' },
         'y': { year: '2-digit' },
+
         'a': { hour12: true },
         'A': { hour12: true },
+
         'g': { hour: 'numeric', hour12: true },
         'h': { hour: '2-digit', hour12: true },
         'G': { hour: 'numeric', hour12: false },
         'H': { hour: '2-digit', hour12: false },
+
         'i': { minute: '2-digit' },
         's': { second: '2-digit' },
+
         'T': { timeZoneName: 'short' }
     };
+
     const dateTimeOptions = dateFormat.split('').reduce((options, char) => {
         if (dateTimeOptionsMap[char]) {
-            return Object.assign(Object.assign({}, options), dateTimeOptionsMap[char]);
+            return { ...options, ...dateTimeOptionsMap[char] };
         }
         return options;
-    }, {});
+    }, {} as Intl.DateTimeFormatOptions);
+
     return new Intl.DateTimeFormat(lang.replace('_', '-'), dateTimeOptions);
 }

package/{dist/services/utilities/kses-post.js → lib/services/utilities/kses-post.ts}

@@ -1,12 +1,13 @@
 import parse from 'html-react-parser';
 import DOMPurify from "isomorphic-dompurify";
+
 /**
  * Sanitizes and parses an HTML string into React elements.
  *
  * @param {string} html - The HTML string to process.
  * @returns {string | JSX.Element | JSX.Element[]} The parsed React elements.
  */
-export function wpKsesPost(html) {
+export function ksesPost(html: string) {
     const cleanHtml = DOMPurify.sanitize(html, { USE_PROFILES: { html: true } });
     return parse(cleanHtml);
 }

package/{dist/services/utilities/process-url.js → lib/services/utilities/process-url.ts}

@@ -4,11 +4,12 @@
  * @param {string} url - The URL to process.
  * @returns {string} The processed URL.
  */
-export function processURL(url) {
-    if (!process.env.WP_SITE_URL)
-        return url;
+export function processURL(url: string): string {
+    if (!process.env.WP_SITE_URL) return url;
+
     if (url.startsWith(process.env.WP_SITE_URL)) {
         url = url.slice(process.env.WP_SITE_URL.length);
     }
+
     return url || '/';
 }

package/{dist/template-heirarchy/_autoloader/template-autoloader.js → lib/template-heirarchy/_autoloader/template-autoloader.ts}

@@ -1,5 +1,7 @@
 import fs from 'fs';
+import { Metadata } from 'next';
 import path from 'path';
+
 /**
  * Loads a specified export suffix from a given template file.
  *
@@ -7,39 +9,46 @@ import path from 'path';
  * @param {'Metadata' | 'Template'} exportSuffix - The suffix of the export to retrieve from the file.
  * @returns {Promise<any | undefined>} The requested export, or undefined if not found or an error occurs.
  */
-async function loadFile(template, exportSuffix) {
+async function loadFile(template: string, exportSuffix: 'Metadata' | 'Template'): Promise<any | undefined> {
     const absolutePath = path.join(process.cwd(), 'src', 'app', '_templates');
     const files = fs.readdirSync(absolutePath);
-    const imports = [];
+
+    const imports: any[] = [];
+
     for (const file of files) {
-        if (file !== (`${template.toLowerCase()}.tsx`))
-            continue;
+        if (file !== (`${template.toLowerCase()}.tsx`)) continue;
+
         try {
             const imported = await import(`@/app/_templates/${file}`);
+
             const exported = imported[`${template}${exportSuffix}`];
+
             imports.push(exported);
-        }
-        catch (_error) {
+        } catch (_error) {
             return undefined;
         }
     }
+
     return imports[0];
 }
+
 /**
  * Loads the exported metadata configuration for a given template.
  *
  * @param {string} template - The name of the template file to load metadata from.
  * @returns {Promise<Metadata | undefined>} The metadata object, or undefined if the metadata does not exist.
  */
-export async function loadMetadata(template) {
+export async function loadMetadata(template: string): Promise<Metadata | undefined> {
     const metadataFn = await loadFile(template, 'Metadata');
     if (metadataFn) {
         return typeof metadataFn === 'function' ? metadataFn() : metadataFn;
     }
 }
-export async function loadTemplate(template) {
+
+export async function loadTemplate(template: string): Promise<React.ComponentType<any> | undefined> {
     const element = await loadFile(template, 'Template');
     if (element) {
-        return element;
+        return element as React.ComponentType<any>;
     }
 }
+

package/{dist/template-heirarchy/archive/archive.js → lib/template-heirarchy/archive/archive.tsx}

@@ -1,25 +1,28 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { Metadata } from "next";
+import { JSX } from "react";
 import { loadMetadata, loadTemplate } from "../_autoloader/template-autoloader";
 import { IndexMetadata, IndexTemplate } from "..";
+
 /**
  * Loads the metadata for the Archive template.
  * Fallback: Index
  *
  * @returns {Promise<Metadata>} The merged metadata object.
  */
-export async function ArchiveMetadata() {
+export async function ArchiveMetadata(): Promise<Metadata> {
     const metadata = await loadMetadata('Archive');
-    return Object.assign(Object.assign({}, (await IndexMetadata())), metadata);
+    return {...(await IndexMetadata()), ...metadata};
 }
+
 /**
  * Renders the Archive template. Falls back to the Index template if not found.
  * Fallback: Index
  *
  * @returns {Promise<JSX.Element>} The rendered template component.
  */
-export async function ArchiveTemplate() {
+export async function ArchiveTemplate(): Promise<JSX.Element> {
     const Archive = await loadTemplate('Archive');
-    if (!Archive)
-        return _jsx(IndexTemplate, {});
-    return _jsx(Archive, {});
+    if (!Archive) return <IndexTemplate/>
+
+    return <Archive/>;
 }

package/{dist/template-heirarchy/archive/author.js → lib/template-heirarchy/archive/author.tsx}

@@ -1,25 +1,28 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { Metadata } from "next";
+import { JSX } from "react";
 import { loadMetadata, loadTemplate } from "../_autoloader/template-autoloader";
 import { ArchiveMetadata, ArchiveTemplate } from "./archive";
+
 /**
  * Loads the metadata for the Author template.
  * Fallback: Archive
  *
  * @returns {Promise<Metadata>} The merged metadata object.
  */
-export async function AuthorMetadata() {
+export async function AuthorMetadata(): Promise<Metadata> {
     const metadata = await loadMetadata('Author');
-    return Object.assign(Object.assign({}, (await ArchiveMetadata())), metadata);
+    return {...(await ArchiveMetadata()), ...metadata};
 }
+
 /**
  * Renders the Author template. Falls back to the Archive template if not found.
  * Fallback: Archive
  *
  * @returns {Promise<JSX.Element>} The rendered template component.
  */
-export async function AuthorTemplate() {
+export async function AuthorTemplate(): Promise<JSX.Element> {
     const Author = await loadTemplate('Author');
-    if (!Author)
-        return _jsx(ArchiveTemplate, {});
-    return _jsx(Author, {});
+    if (!Author) return <ArchiveTemplate/>
+
+    return <Author/>;
 }

package/{dist/template-heirarchy/archive/category.js → lib/template-heirarchy/archive/category.tsx}

@@ -1,25 +1,29 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { Metadata } from "next";
+import { JSX } from "react";
 import { loadMetadata, loadTemplate } from "../_autoloader/template-autoloader";
 import { ArchiveMetadata, ArchiveTemplate } from "./archive";
+
 /**
  * Loads the metadata for the Category template.
  * Fallback: Archive
  *
  * @returns {Promise<Metadata>} The merged metadata object.
  */
-export async function CategoryMetadata() {
+export async function CategoryMetadata(): Promise<Metadata> {
     const metadata = await loadMetadata('Category');
-    return Object.assign(Object.assign({}, (await ArchiveMetadata())), metadata);
+    return {...(await ArchiveMetadata()), ...metadata};
 }
+
 /**
  * Renders the Category template. Falls back to the Archive template if not found.
  * Fallback: Archive
  *
  * @returns {Promise<JSX.Element>} The rendered template component.
  */
-export async function CategoryTemplate() {
+export async function CategoryTemplate(): Promise<JSX.Element> {
     const Category = await loadTemplate('Category');
-    if (!Category)
-        return _jsx(ArchiveTemplate, {});
-    return _jsx(Category, {});
+    if (!Category) return <ArchiveTemplate/>
+
+    return <Category/>;
 }
+