nextpress-core 1.0.0

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 { CategoryMetadata, CategoryTemplate } from "@/template-heirarchy/archive/category";
+import { TagMetadata, TagTemplate } from "@/template-heirarchy/archive/tag";
+import { TaxonomyMetadata, TaxonomyTemplate } from "@/template-heirarchy/archive/taxonomy";
+import { queriedObjectState } from "@/globals/globals";
+
+/**
+ * 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/lib/router/types.d.ts

@@ -0,0 +1,9 @@
+import { Metadata } from "next";
+
+type TemplateResult = JSX.Element;
+type MetadataResult = Metadata;
+
+type RouteProps = {
+    path: string[];
+    metadata?: boolean;
+}

package/lib/services/get-menu.ts

@@ -0,0 +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: string): Promise<Menu[] | undefined> {
+    const navMenuLocations = await getThemeMods('nav_menu_locations');
+    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: 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.type === 'post_type') {
+            postLoader.prime([item.menuItemAttributes.objectId])
+        } else if (item.menuItemAttributes.type === 'taxonomy') {
+            termLoader.prime([item.menuItemAttributes.objectId])
+        }
+    }
+
+    const map = new Map<number, Menu>();
+    const tree: Menu[] = [];
+
+    for (const item of menuItems) {
+        if (!item.menuItemAttributes) continue;
+
+        const menuItemAttributes = { ...item.menuItemAttributes };
+
+        if (item.menuItemAttributes.type === 'post_type') {
+            const post = await getPost(menuItemAttributes.objectId);
+
+            menuItemAttributes.url = post?.path ?? '';
+
+            if (!menuItemAttributes.label) {
+                menuItemAttributes.label = post?.postTitle ?? '';
+            }
+        } else if (item.menuItemAttributes.type === 'taxonomy') {
+            const term = await getTerm(menuItemAttributes.objectId);
+
+            menuItemAttributes.url = term?.path ?? '';
+
+            if (!menuItemAttributes.label) {
+                menuItemAttributes.label = term?.name ?? '';
+            }
+        }
+
+        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;
+
+        const currentNode = map.get(item.ID);
+        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/lib/services/get-theme-mods.ts

@@ -0,0 +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: string): Promise<unknown | undefined> {
+    const themeModOption = await getOption('theme_mods_nextpress_theme');
+
+    const themeMods: Record<string, unknown> | unknown[] = unserialize(themeModOption ?? 'a:0:{}');
+    if (Array.isArray(themeMods)) return;
+
+    return themeMods[key];
+}

package/lib/services/metadata/get-blogname.ts

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

package/lib/services/metadata/get-favicon-url.ts

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

package/lib/services/metadata/get-language-attribute.ts

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

package/lib/services/services.ts

@@ -0,0 +1,7 @@
+import { getMenu } from "./get-menu";
+import { getThemeMods } from "./get-theme-mods";
+
+export {
+    getMenu,
+    getThemeMods
+}

package/lib/services/utilities/capitalise-first-letter.ts

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

package/lib/services/utilities/esc-html.ts

@@ -0,0 +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: string) {
+    return DOMPurify.sanitize(string);
+}
+

package/lib/services/utilities/get-date-time-formatter.ts

@@ -0,0 +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(): Promise<Intl.DateTimeFormat> {
+    const dateFormat = await getOption('date_format') ?? 'F j, Y';
+    const lang = await getLanguageAttributes();
+
+    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 { ...options, ...dateTimeOptionsMap[char] };
+        }
+        return options;
+    }, {} as Intl.DateTimeFormatOptions);
+
+    return new Intl.DateTimeFormat(lang.replace('_', '-'), dateTimeOptions);
+}

package/lib/services/utilities/kses-post.ts

@@ -0,0 +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: string) {
+    const cleanHtml = DOMPurify.sanitize(html, { USE_PROFILES: { html: true } });
+    return parse(cleanHtml);
+}

package/lib/services/utilities/process-url.ts

@@ -0,0 +1,15 @@
+/**
+ * Processes a URL by stripping the site URL prefix if it is present.
+ *
+ * @param {string} url - The URL to process.
+ * @returns {string} The processed 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/lib/template-heirarchy/_autoloader/template-autoloader.ts

@@ -0,0 +1,54 @@
+import fs from 'fs';
+import { Metadata } from 'next';
+import path from 'path';
+
+/**
+ * Loads a specified export suffix from a given template file.
+ *
+ * @param {string} template - The base name of the template to load.
+ * @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: string, exportSuffix: 'Metadata' | 'Template'): Promise<any | undefined> {
+    const absolutePath = path.join(process.cwd(), 'src', 'app', '_templates');
+    const files = fs.readdirSync(absolutePath);
+
+    const imports: any[] = [];
+
+    for (const file of files) {
+        if (file !== (`${template.toLowerCase()}.tsx`)) continue;
+
+        try {
+            const imported = await import(`@/app/_templates/${file}`);
+
+            const exported = imported[`${template}${exportSuffix}`];
+
+            imports.push(exported);
+        } 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: string): Promise<Metadata | undefined> {
+    const metadataFn = await loadFile(template, 'Metadata');
+    if (metadataFn) {
+        return typeof metadataFn === 'function' ? metadataFn() : metadataFn;
+    }
+}
+
+export async function loadTemplate(template: string): Promise<React.ComponentType<any> | undefined> {
+    const element = await loadFile(template, 'Template');
+    if (element) {
+        return element as React.ComponentType<any>;
+    }
+}
+

package/lib/template-heirarchy/archive/archive.tsx

@@ -0,0 +1,28 @@
+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(): Promise<Metadata> {
+    const metadata = await loadMetadata('Archive');
+    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(): Promise<JSX.Element> {
+    const Archive = await loadTemplate('Archive');
+    if (!Archive) return <IndexTemplate/>
+
+    return <Archive/>;
+}

package/lib/template-heirarchy/archive/author.tsx

@@ -0,0 +1,28 @@
+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(): Promise<Metadata> {
+    const metadata = await loadMetadata('Author');
+    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(): Promise<JSX.Element> {
+    const Author = await loadTemplate('Author');
+    if (!Author) return <ArchiveTemplate/>
+
+    return <Author/>;
+}

package/lib/template-heirarchy/archive/category.tsx

@@ -0,0 +1,29 @@
+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(): Promise<Metadata> {
+    const metadata = await loadMetadata('Category');
+    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(): Promise<JSX.Element> {
+    const Category = await loadTemplate('Category');
+    if (!Category) return <ArchiveTemplate/>
+
+    return <Category/>;
+}
+

package/lib/template-heirarchy/archive/posttypearchive.tsx

@@ -0,0 +1,33 @@
+import { Metadata } from "next";
+import { JSX } from "react";
+import { loadMetadata, loadTemplate } from "../_autoloader/template-autoloader";
+import { ArchiveMetadata, ArchiveTemplate } from "./archive";
+import { capitalizeFirstLetter } from "@/services/utilities/capitalise-first-letter";
+
+/**
+ * Loads the metadata for a Post Type Archive template based on the given post type.
+ * Fallback: Archive
+ *
+ * @param {object} props - The properties for loading metadata.
+ * @param {string} props.postType - The post type to load the metadata for.
+ * @returns {Promise<Metadata>} The merged metadata object.
+ */
+export async function PostTypeArchiveMetadata({postType}: {postType: string}): Promise<Metadata> {
+    const metadata = await loadMetadata(capitalizeFirstLetter(postType));
+    return {...(await ArchiveMetadata()), ...metadata};
+}
+
+/**
+ * Renders a Post Type Archive template. Falls back to the Archive template if not found.
+ * Fallback: Archive
+ *
+ * @param {object} props - The properties for rendering the template.
+ * @param {string} props.postType - The post type to load the template for.
+ * @returns {Promise<JSX.Element>} The rendered template component.
+ */
+export async function PostTypeArchiveTemplate({postType}: {postType: string}): Promise<JSX.Element> {
+    const PostTypeArchive = await loadTemplate(capitalizeFirstLetter(postType));
+    if (!PostTypeArchive) return <ArchiveTemplate/>
+
+    return <PostTypeArchive/>;
+}

package/lib/template-heirarchy/archive/tag.tsx

@@ -0,0 +1,30 @@
+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 Tag template.
+ * Fallback: Archive
+ *
+ * @returns {Promise<Metadata>} The merged metadata object.
+ */
+export async function TagMetadata(): Promise<Metadata> {
+    const metadata = await loadMetadata('Tag');
+    return {...(await ArchiveMetadata()), ...metadata};
+}
+
+/**
+ * Renders the Tag template. Falls back to the Archive template if not found.
+ * Fallback: Archive
+ *
+ * @returns {Promise<JSX.Element>} The rendered template component.
+ */
+export async function TagTemplate(): Promise<JSX.Element> {
+    const Category = await loadTemplate('Tag');
+    if (!Category) return <ArchiveTemplate/>
+
+    return <Category/>;
+}
+
+

package/lib/template-heirarchy/archive/taxonomy.tsx

@@ -0,0 +1,28 @@
+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 Taxonomy template.
+ * Fallback: Archive
+ *
+ * @returns {Promise<Metadata>} The merged metadata object.
+ */
+export async function TaxonomyMetadata(): Promise<Metadata> {
+    const metadata = await loadMetadata('Taxonomy');
+    return {...(await ArchiveMetadata()), ...metadata};
+}
+
+/**
+ * Renders the Taxonomy template. Falls back to the Archive template if not found.
+ * Fallback: Archive
+ *
+ * @returns {Promise<JSX.Element>} The rendered template component.
+ */
+export async function TaxonomyTemplate(): Promise<JSX.Element> {
+    const Taxonomy = await loadTemplate('Taxonomy');
+    if (!Taxonomy) return <ArchiveTemplate/>
+
+    return <Taxonomy/>;
+}

package/lib/template-heirarchy/home/home.tsx

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

package/lib/template-heirarchy/index.tsx

@@ -0,0 +1,30 @@
+import { Metadata } from "next";
+import { JSX } from "react";
+import { loadMetadata, loadTemplate } from "./_autoloader/template-autoloader";
+
+/**
+ * Loads the metadata for the Index template.
+ * Fallback: None
+ *
+ * @returns {Promise<Metadata>} The loaded metadata object.
+ */
+export async function IndexMetadata(): Promise<Metadata> {
+    const metadata = await loadMetadata('Index');
+    return metadata ?? {};
+}
+
+/**
+ * Renders the Index template.
+ * Fallback: None
+ *
+ * @throws {Error} Throws if the Index template cannot be found in the _templates directory.
+ * @returns {Promise<JSX.Element>} The rendered template component.
+ */
+export async function IndexTemplate(): Promise<JSX.Element> {
+    const Index = await loadTemplate('Index');
+    if (!Index) {
+        throw new Error('Nextpress needs an index.tsx file in the template heirarchy in the _templates directory to function');
+    }
+
+    return <Index/>;
+}