nextpress-core 1.0.0 → 1.0.1

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

@@ -1,28 +1,25 @@
-import { Metadata } from "next";
-import { JSX } from "react";
+import { jsx as _jsx } from "react/jsx-runtime";
 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> {
+export async function ArchiveMetadata() {
     const metadata = await loadMetadata('Archive');
-    return {...(await IndexMetadata()), ...metadata};
+    return Object.assign(Object.assign({}, (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> {
+export async function ArchiveTemplate() {
     const Archive = await loadTemplate('Archive');
-    if (!Archive) return <IndexTemplate/>
-
-    return <Archive/>;
+    if (!Archive)
+        return _jsx(IndexTemplate, {});
+    return _jsx(Archive, {});
 }

package/dist/template-heirarchy/archive/author.d.ts

@@ -0,0 +1,16 @@
+import { Metadata } from "next";
+import { JSX } from "react";
+/**
+ * Loads the metadata for the Author template.
+ * Fallback: Archive
+ *
+ * @returns {Promise<Metadata>} The merged metadata object.
+ */
+export declare function AuthorMetadata(): Promise<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 declare function AuthorTemplate(): Promise<JSX.Element>;

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

@@ -1,28 +1,25 @@
-import { Metadata } from "next";
-import { JSX } from "react";
+import { jsx as _jsx } from "react/jsx-runtime";
 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> {
+export async function AuthorMetadata() {
     const metadata = await loadMetadata('Author');
-    return {...(await ArchiveMetadata()), ...metadata};
+    return Object.assign(Object.assign({}, (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> {
+export async function AuthorTemplate() {
     const Author = await loadTemplate('Author');
-    if (!Author) return <ArchiveTemplate/>
-
-    return <Author/>;
+    if (!Author)
+        return _jsx(ArchiveTemplate, {});
+    return _jsx(Author, {});
 }

package/dist/template-heirarchy/archive/category.d.ts

@@ -0,0 +1,16 @@
+import { Metadata } from "next";
+import { JSX } from "react";
+/**
+ * Loads the metadata for the Category template.
+ * Fallback: Archive
+ *
+ * @returns {Promise<Metadata>} The merged metadata object.
+ */
+export declare function CategoryMetadata(): Promise<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 declare function CategoryTemplate(): Promise<JSX.Element>;

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

@@ -1,29 +1,25 @@
-import { Metadata } from "next";
-import { JSX } from "react";
+import { jsx as _jsx } from "react/jsx-runtime";
 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> {
+export async function CategoryMetadata() {
     const metadata = await loadMetadata('Category');
-    return {...(await ArchiveMetadata()), ...metadata};
+    return Object.assign(Object.assign({}, (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> {
+export async function CategoryTemplate() {
     const Category = await loadTemplate('Category');
-    if (!Category) return <ArchiveTemplate/>
-
-    return <Category/>;
+    if (!Category)
+        return _jsx(ArchiveTemplate, {});
+    return _jsx(Category, {});
 }
-

package/dist/template-heirarchy/archive/posttypearchive.d.ts

@@ -0,0 +1,24 @@
+import { Metadata } from "next";
+import { JSX } from "react";
+/**
+ * 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 declare function PostTypeArchiveMetadata({ postType }: {
+    postType: string;
+}): Promise<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 declare function PostTypeArchiveTemplate({ postType }: {
+    postType: string;
+}): Promise<JSX.Element>;

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

@@ -1,9 +1,7 @@
-import { Metadata } from "next";
-import { JSX } from "react";
+import { jsx as _jsx } from "react/jsx-runtime";
 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
@@ -12,11 +10,10 @@ import { capitalizeFirstLetter } from "@/services/utilities/capitalise-first-let
  * @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> {
+export async function PostTypeArchiveMetadata({ postType }) {
     const metadata = await loadMetadata(capitalizeFirstLetter(postType));
-    return {...(await ArchiveMetadata()), ...metadata};
+    return Object.assign(Object.assign({}, (await ArchiveMetadata())), metadata);
 }
-
 /**
  * Renders a Post Type Archive template. Falls back to the Archive template if not found.
  * Fallback: Archive
@@ -25,9 +22,9 @@ export async function PostTypeArchiveMetadata({postType}: {postType: string}): P
  * @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> {
+export async function PostTypeArchiveTemplate({ postType }) {
     const PostTypeArchive = await loadTemplate(capitalizeFirstLetter(postType));
-    if (!PostTypeArchive) return <ArchiveTemplate/>
-
-    return <PostTypeArchive/>;
+    if (!PostTypeArchive)
+        return _jsx(ArchiveTemplate, {});
+    return _jsx(PostTypeArchive, {});
 }

package/dist/template-heirarchy/archive/tag.d.ts

@@ -0,0 +1,16 @@
+import { Metadata } from "next";
+import { JSX } from "react";
+/**
+ * Loads the metadata for the Tag template.
+ * Fallback: Archive
+ *
+ * @returns {Promise<Metadata>} The merged metadata object.
+ */
+export declare function TagMetadata(): Promise<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 declare function TagTemplate(): Promise<JSX.Element>;

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

@@ -1,30 +1,25 @@
-import { Metadata } from "next";
-import { JSX } from "react";
+import { jsx as _jsx } from "react/jsx-runtime";
 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> {
+export async function TagMetadata() {
     const metadata = await loadMetadata('Tag');
-    return {...(await ArchiveMetadata()), ...metadata};
+    return Object.assign(Object.assign({}, (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> {
+export async function TagTemplate() {
     const Category = await loadTemplate('Tag');
-    if (!Category) return <ArchiveTemplate/>
-
-    return <Category/>;
+    if (!Category)
+        return _jsx(ArchiveTemplate, {});
+    return _jsx(Category, {});
 }
-
-

package/dist/template-heirarchy/archive/taxonomy.d.ts

@@ -0,0 +1,16 @@
+import { Metadata } from "next";
+import { JSX } from "react";
+/**
+ * Loads the metadata for the Taxonomy template.
+ * Fallback: Archive
+ *
+ * @returns {Promise<Metadata>} The merged metadata object.
+ */
+export declare function TaxonomyMetadata(): Promise<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 declare function TaxonomyTemplate(): Promise<JSX.Element>;

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

@@ -1,28 +1,25 @@
-import { Metadata } from "next";
-import { JSX } from "react";
+import { jsx as _jsx } from "react/jsx-runtime";
 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> {
+export async function TaxonomyMetadata() {
     const metadata = await loadMetadata('Taxonomy');
-    return {...(await ArchiveMetadata()), ...metadata};
+    return Object.assign(Object.assign({}, (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> {
+export async function TaxonomyTemplate() {
     const Taxonomy = await loadTemplate('Taxonomy');
-    if (!Taxonomy) return <ArchiveTemplate/>
-
-    return <Taxonomy/>;
+    if (!Taxonomy)
+        return _jsx(ArchiveTemplate, {});
+    return _jsx(Taxonomy, {});
 }

package/dist/template-heirarchy/home/home.d.ts

@@ -0,0 +1,16 @@
+import { Metadata } from "next";
+import { JSX } from "react";
+/**
+ * Loads the metadata for the Home template.
+ * Fallback: Index
+ *
+ * @returns {Promise<Metadata>} The merged metadata object.
+ */
+export declare function HomeMetadata(): Promise<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 declare function HomeTemplate(): Promise<JSX.Element>;

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

@@ -1,28 +1,25 @@
-import { Metadata } from "next";
-import { JSX } from "react";
+import { jsx as _jsx } from "react/jsx-runtime";
 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> {
+export async function HomeMetadata() {
     const metadata = await loadMetadata('Home');
-    return {...(await IndexMetadata()), ...metadata};
+    return Object.assign(Object.assign({}, (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> {
+export async function HomeTemplate() {
     const Home = await loadTemplate('Home');
-    if (!Home) return <IndexTemplate/>
-
-    return <Home/>;
+    if (!Home)
+        return _jsx(IndexTemplate, {});
+    return _jsx(Home, {});
 }

package/dist/template-heirarchy/index.d.ts

@@ -0,0 +1,17 @@
+import { Metadata } from "next";
+import { JSX } from "react";
+/**
+ * Loads the metadata for the Index template.
+ * Fallback: None
+ *
+ * @returns {Promise<Metadata>} The loaded metadata object.
+ */
+export declare function IndexMetadata(): Promise<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 declare function IndexTemplate(): Promise<JSX.Element>;

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

@@ -1,18 +1,15 @@
-import { Metadata } from "next";
-import { JSX } from "react";
+import { jsx as _jsx } from "react/jsx-runtime";
 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> {
+export async function IndexMetadata() {
     const metadata = await loadMetadata('Index');
-    return metadata ?? {};
+    return metadata !== null && metadata !== void 0 ? metadata : {};
 }
-
 /**
  * Renders the Index template.
  * Fallback: None
@@ -20,11 +17,10 @@ export async function IndexMetadata(): Promise<Metadata> {
  * @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> {
+export async function IndexTemplate() {
     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/>;
+    return _jsx(Index, {});
 }

package/dist/template-heirarchy/not-found.tsx/not-found.d.ts

@@ -0,0 +1,16 @@
+import { Metadata } from "next";
+import { JSX } from "react";
+/**
+ * Loads the metadata for the NotFound template.
+ * Fallback: Index
+ *
+ * @returns {Promise<Metadata>} The merged metadata object.
+ */
+export declare function NotFoundMetadata(): Promise<Metadata>;
+/**
+ * Renders the NotFound template. Falls back to the Index template if not found.
+ * Fallback: Index
+ *
+ * @returns {Promise<JSX.Element>} The rendered template component.
+ */
+export declare function NotFoundTemplate(): Promise<JSX.Element>;

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

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

package/dist/template-heirarchy/page/page.d.ts

@@ -0,0 +1,16 @@
+import { Metadata } from "next";
+import { JSX } from "react";
+/**
+ * Loads the metadata for the Page template.
+ * Fallback: Singular
+ *
+ * @returns {Promise<Metadata>} The merged metadata object.
+ */
+export declare function PageMetadata(): Promise<Metadata>;
+/**
+ * Renders the Page template. Falls back to the Singular template if not found.
+ * Fallback: Singular
+ *
+ * @returns {Promise<JSX.Element>} The rendered template component.
+ */
+export declare function PageTemplate(): Promise<JSX.Element>;

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

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

package/dist/template-heirarchy/page/posttype.d.ts

@@ -0,0 +1,24 @@
+import { Metadata } from "next";
+import { JSX } from "react";
+/**
+ * Loads the metadata for a Post Type template based on the provided post type string.
+ * Fallback: Singular
+ *
+ * @param {object} props - The properties for loading metadata.
+ * @param {string} props.postType - The post type to load metadata for.
+ * @returns {Promise<Metadata>} The merged metadata object.
+ */
+export declare function PostTypeMetadata({ postType }: {
+    postType: string;
+}): Promise<Metadata>;
+/**
+ * Renders a Post Type template based on the provided post type string. Falls back to Singular template if not found.
+ * Fallback: Singular
+ *
+ * @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 declare function PostTypeTemplate({ postType }: {
+    postType: string;
+}): Promise<JSX.Element>;

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

@@ -1,9 +1,7 @@
-import { Metadata } from "next";
-import { JSX } from "react";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { loadMetadata, loadTemplate } from "../_autoloader/template-autoloader";
 import { SingularMetadata, SingularTemplate } from "./singular";
 import { capitalizeFirstLetter } from "@/services/utilities/capitalise-first-letter";
-
 /**
  * Loads the metadata for a Post Type template based on the provided post type string.
  * Fallback: Singular
@@ -12,11 +10,10 @@ import { capitalizeFirstLetter } from "@/services/utilities/capitalise-first-let
  * @param {string} props.postType - The post type to load metadata for.
  * @returns {Promise<Metadata>} The merged metadata object.
  */
-export async function PostTypeMetadata({postType}: {postType: string}): Promise<Metadata> {
+export async function PostTypeMetadata({ postType }) {
     const metadata = await loadMetadata(capitalizeFirstLetter(postType));
-    return {...(await SingularMetadata()), ...metadata};
+    return Object.assign(Object.assign({}, (await SingularMetadata())), metadata);
 }
-
 /**
  * Renders a Post Type template based on the provided post type string. Falls back to Singular template if not found.
  * Fallback: Singular
@@ -25,10 +22,9 @@ export async function PostTypeMetadata({postType}: {postType: string}): Promise<
  * @param {string} props.postType - The post type to load the template for.
  * @returns {Promise<JSX.Element>} The rendered template component.
  */
-export async function PostTypeTemplate({postType}: {postType: string}): Promise<JSX.Element> {
+export async function PostTypeTemplate({ postType }) {
     const PostType = await loadTemplate(capitalizeFirstLetter(postType));
-    if (!PostType) return <SingularTemplate/>
-
-    return <PostType/>;
+    if (!PostType)
+        return _jsx(SingularTemplate, {});
+    return _jsx(PostType, {});
 }
-

package/dist/template-heirarchy/page/single.d.ts

@@ -0,0 +1,16 @@
+import { Metadata } from "next";
+import { JSX } from "react";
+/**
+ * Loads the metadata for the Single template.
+ * Fallback: Singular
+ *
+ * @returns {Promise<Metadata>} The merged metadata object.
+ */
+export declare function SingleMetadata(): Promise<Metadata>;
+/**
+ * Renders the Single template. Falls back to the Singular template if not found.
+ * Fallback: Singular
+ *
+ * @returns {Promise<JSX.Element>} The rendered template component.
+ */
+export declare function SingleTemplate(): Promise<JSX.Element>;