nextpress-core 1.0.0 → 1.0.1

package/dist/globals/entity-loader/post-loader.js

@@ -0,0 +1,28 @@
+import { Post } from "@/entities/post/post";
+import { EntityLoaderBase } from "./entity-loader-base";
+import { PostQuery } from "@/repository/postquery/post-query";
+class PostLoader extends EntityLoaderBase {
+    constructor() {
+        super();
+        this.queryClass = PostQuery;
+    }
+    static instance() {
+        if (!this._instance) {
+            this._instance = new PostLoader();
+        }
+        return this._instance;
+    }
+    async fetchFromDatabase(ids) {
+        return await Post.get(ids);
+    }
+    getEntityId(post) {
+        return post.ID;
+    }
+}
+globalThis.postLoader = PostLoader.instance();
+globalThis.getPosts = async (ids) => {
+    return await postLoader.get(ids);
+};
+globalThis.getPost = async (id) => {
+    return (await postLoader.get([id]))[0];
+};

package/dist/globals/entity-loader/term-loader.d.ts

@@ -0,0 +1,21 @@
+import { ITerm } from "../../entities/term/term.interface";
+import { EntityLoader } from "./entity-loader";
+declare global {
+    /** Global instance of the TermLoader. */
+    var termLoader: EntityLoader<ITerm, TermQueryArgs>;
+    /**
+     * Retrieves terms by their IDs.
+     *
+     * @param {number[]} ids Array of term IDs.
+     * @returns {Promise<ITerm[]>} Array of terms.
+     */
+    var getTerms: (ids: number[]) => Promise<ITerm[]>;
+    /**
+     * Retrieves a single term by ID.
+     *
+     * @param {number} id The term ID.
+     * @returns {Promise<ITerm | undefined>} The term or undefined.
+     */
+    var getTerm: (id: number) => Promise<ITerm | undefined>;
+}
+export {};

package/dist/globals/entity-loader/term-loader.js

@@ -0,0 +1,28 @@
+import { Term } from "@/entities/term/term";
+import { EntityLoaderBase } from "./entity-loader-base";
+import { TermQuery } from "@/repository/termquery/term-query";
+class TermLoader extends EntityLoaderBase {
+    constructor() {
+        super();
+        this.queryClass = TermQuery;
+    }
+    static instance() {
+        if (!this._instance) {
+            this._instance = new TermLoader();
+        }
+        return this._instance;
+    }
+    async fetchFromDatabase(ids) {
+        return await Term.get(ids);
+    }
+    getEntityId(term) {
+        return term.termId;
+    }
+}
+globalThis.termLoader = TermLoader.instance();
+globalThis.getTerms = async (ids) => {
+    return await termLoader.get(ids);
+};
+globalThis.getTerm = async (id) => {
+    return (await termLoader.get([id]))[0];
+};

package/dist/globals/entity-loader/user-loader.d.ts

@@ -0,0 +1,21 @@
+import { IUser } from "../../entities/user/user.interface";
+import { EntityLoader } from "./entity-loader";
+declare global {
+    /** Global instance of the UserLoader. */
+    var userLoader: EntityLoader<IUser, UserQueryArgs>;
+    /**
+     * Retrieves users by their IDs.
+     *
+     * @param {number[]} ids Array of user IDs.
+     * @returns {Promise<IUser[]>} Array of users.
+     */
+    var getUsers: (ids: number[]) => Promise<IUser[]>;
+    /**
+     * Retrieves a single user by ID.
+     *
+     * @param {number} id The user ID.
+     * @returns {Promise<IUser | undefined>} The user or undefined.
+     */
+    var getUser: (id: number) => Promise<IUser | undefined>;
+}
+export {};

package/dist/globals/entity-loader/user-loader.js

@@ -0,0 +1,28 @@
+import { User } from "@/entities/user/user";
+import { EntityLoaderBase } from "./entity-loader-base";
+import { UserQuery } from "@/repository/userquery/user-query";
+class UserLoader extends EntityLoaderBase {
+    constructor() {
+        super();
+        this.queryClass = UserQuery;
+    }
+    static instance() {
+        if (!this._instance) {
+            this._instance = new UserLoader();
+        }
+        return this._instance;
+    }
+    async fetchFromDatabase(ids) {
+        return await User.get(ids);
+    }
+    getEntityId(user) {
+        return user.ID;
+    }
+}
+globalThis.userLoader = UserLoader.instance();
+globalThis.getUsers = async (ids) => {
+    return await userLoader.get(ids);
+};
+globalThis.getUser = async (id) => {
+    return (await userLoader.get([id]))[0];
+};

package/dist/globals/get-field/get-field.d.ts

@@ -0,0 +1,17 @@
+import { IFieldLocation } from "../../entities/common";
+import { FieldProps } from "../../acf-functions/types/components/field-props";
+/** Specifies location to retrieve fields from. */
+type Location = IFieldLocation | 'options';
+declare global {
+    /**
+     * Retrieves, parses, and maps an Advanced Custom Fields (ACF) value to its corresponding component properties.
+     *
+     * @param {T} fieldGroup The configuration object defining the ACF field group and its schema.
+     * @param {K} selector The key name of the field to retrieve.
+     * @param {Location} [location] The database entity or context from which to load the field data. Accepts an `IFieldLocation` object or the string `'options'`. Defaults to the current queried object if omitted.
+     *
+     * @returns {Promise<FieldProps<T>[K]>} A promise resolving to the mapped field properties.
+     */
+    var getField: <T extends NextpressFieldGroup, K extends keyof FieldProps<T> & string>(fieldGroup: T, selector: K, location?: Location) => Promise<FieldProps<T>[K]>;
+}
+export {};

package/dist/globals/get-field/get-field.js

@@ -0,0 +1,44 @@
+import { mapField } from "../../acf-functions/services/map-fields/map-fields";
+globalThis.getField = async (fieldGroup, selector, location) => {
+    var _a;
+    if (!location) {
+        switch (queriedObject.objectType) {
+            case 'post':
+                location = await getThePost();
+                break;
+            // TODO: Add support for Term and User
+            // case 'term':
+            //     location = await getTheTerm();
+            //     break;
+            // case 'user':
+            //     location = await getTheUser();
+            //     break;
+        }
+    }
+    if (!location)
+        return [];
+    const values = (_a = await (async () => {
+        if (location === 'options') {
+            const prefix = 'options_';
+            const foundOptions = await optionLoader.findAndPrime({
+                column: 'optionName',
+                operand: 'like',
+                value: `${prefix}%`
+            });
+            const options = await optionLoader.get(foundOptions.ids);
+            return options.map(option => ({
+                key: option.optionName.slice(prefix.length),
+                value: option.optionValue
+            }));
+        }
+        return await location.getFields(selector);
+    })()) !== null && _a !== void 0 ? _a : [];
+    const valueMap = values.reduce((map, value) => {
+        map.set(value.key, value.value);
+        return map;
+    }, new Map());
+    const field = fieldGroup.fields.find(field => field.name === selector);
+    if (!field)
+        return;
+    return mapField(field, valueMap);
+};

package/dist/globals/globals.d.ts

@@ -0,0 +1,18 @@
+import './nextpress-config/nextpress-config';
+import './entity-loader/post-loader';
+import './entity-loader/term-loader';
+import './entity-loader/user-loader';
+import './entity-loader/option-loader';
+import './get-field/get-field';
+/**
+ * Initializes and returns request-scoped storage for the application state.
+ * Uses React cache to prevent state bleeding across requests.
+ *
+ * @returns {{ currentState: any, loaderStates: Record<string, any> }} Object containing current queried object state and loader states.
+ */
+export declare const queriedObjectState: () => {
+    currentState: any;
+    loaderStates: Record<string, any>;
+};
+import './queried-object/queried-object';
+export {};

package/{lib/globals/globals.ts → dist/globals/globals.js}

@@ -1,12 +1,10 @@
 import { cache } from 'react';
-
-import './nextpress-config/nextpress-config'
+import './nextpress-config/nextpress-config';
 import './entity-loader/post-loader';
 import './entity-loader/term-loader';
 import './entity-loader/user-loader';
 import './entity-loader/option-loader';
 import './get-field/get-field';
-
 /**
  * Initializes and returns request-scoped storage for the application state.
  * Uses React cache to prevent state bleeding across requests.
@@ -15,11 +13,8 @@ import './get-field/get-field';
  */
 export const queriedObjectState = cache(() => {
     return {
-        currentState: null as any,
-        loaderStates: {} as Record<string, any>
+        currentState: null,
+        loaderStates: {}
     };
 });
-
 import './queried-object/queried-object';
-
-export {};

package/dist/globals/nextpress-config/nextpress-config.d.ts

@@ -0,0 +1,4 @@
+declare global {
+    var nextpressConfig: NextpressConfig;
+}
+export {};

package/{lib/globals/nextpress-config/nextpress-config.ts → dist/globals/nextpress-config/nextpress-config.js}

@@ -1,7 +1,2 @@
 import nextpressConfig from "../../../../../nextpress.config";
-
-declare global {
-    var nextpressConfig: NextpressConfig
-}
-
 globalThis.nextpressConfig = nextpressConfig;

package/dist/globals/queried-object/queried-object.d.ts

@@ -0,0 +1,62 @@
+import { IPost } from "../../entities/post/post.interface";
+import { ITerm } from "../../entities/term/term.interface";
+import { IUser } from "../../entities/user/user.interface";
+/**
+ * Represents the state of the queried object.
+ */
+interface IQueriedObject {
+    /** Type of the queried object. */
+    objectType: 'post' | 'term' | 'user' | null;
+    /** Array of post IDs associated with the query. */
+    posts: number[];
+    /** Current page number. */
+    page: number;
+    /** Total page count. */
+    pageCount: number;
+    /** ID of the main queried term. */
+    mainTerm?: number;
+    /** Array of term IDs associated with the query. */
+    terms: number[];
+    /** ID of the queried user. */
+    user?: number;
+}
+declare global {
+    /** The current queried object. */
+    var queriedObject: IQueriedObject;
+    /**
+     * Retrieves the first post from the queried object.
+     * @returns {Promise<IPost | undefined>} The post.
+     */
+    var getThePost: () => Promise<IPost | undefined>;
+    /**
+     * Retrieves all posts from the queried object.
+     * @returns {Promise<IPost[]>} Array of posts.
+     */
+    var getThePosts: () => Promise<IPost[]>;
+    /**
+     * Retrieves the current page number.
+     * @returns {number} Page number.
+     */
+    var getThePage: () => number;
+    /**
+     * Retrieves the total page count.
+     * @returns {number} Page count.
+     */
+    var getThePageCount: () => number;
+    /**
+     * Retrieves the main term from the queried object.
+     * @returns {Promise<ITerm | undefined>} The term.
+     */
+    var getTheTerm: () => Promise<ITerm | undefined>;
+    /**
+     * Retrieves all terms from the queried object.
+     * @returns {Promise<ITerm[]>} Array of terms.
+     */
+    var getTheTerms: () => Promise<ITerm[]>;
+    /**
+     * Retrieves the user from the queried object.
+     * @returns {Promise<IUser | undefined>} The user.
+     */
+    var getTheUser: () => Promise<IUser | undefined>;
+}
+export {};

package/dist/globals/queried-object/queried-object.js

@@ -0,0 +1,56 @@
+import { queriedObjectState } from "../globals";
+/**
+ * Creates a blank queried object state.
+ *
+ * @returns {IQueriedObject} Blank state object.
+ */
+const createBlankState = () => ({
+    objectType: null,
+    posts: [],
+    page: 1,
+    pageCount: 1,
+    terms: [],
+});
+Object.defineProperty(globalThis, 'queriedObject', {
+    configurable: true,
+    enumerable: true,
+    get() {
+        const state = queriedObjectState();
+        return state.currentState || createBlankState();
+    },
+    set(newData) {
+        const store = queriedObjectState();
+        if (newData.posts)
+            postLoader.prime(newData.posts);
+        if (newData.mainTerm)
+            termLoader.prime([newData.mainTerm]);
+        if (newData.terms)
+            termLoader.prime(newData.terms);
+        if (newData.user)
+            userLoader.prime([newData.user]);
+        if (!store.currentState)
+            store.currentState = {};
+        Object.assign(store.currentState, newData);
+    }
+});
+globalThis.getThePost = async () => {
+    return (await postLoader.get(globalThis.queriedObject.posts))[0];
+};
+globalThis.getThePosts = () => {
+    return postLoader.get(globalThis.queriedObject.posts);
+};
+globalThis.getThePage = () => globalThis.queriedObject.page;
+globalThis.getThePageCount = () => globalThis.queriedObject.pageCount;
+globalThis.getTheTerm = async () => {
+    if (!globalThis.queriedObject.mainTerm)
+        return;
+    return (await termLoader.get([globalThis.queriedObject.mainTerm]))[0];
+};
+globalThis.getTheTerms = () => {
+    return termLoader.get(globalThis.queriedObject.terms);
+};
+globalThis.getTheUser = async () => {
+    if (!globalThis.queriedObject.user)
+        return;
+    return (await userLoader.get([globalThis.queriedObject.user]))[0];
+};

package/dist/repository/optionquery/option-query.d.ts

@@ -0,0 +1,12 @@
+import { EntityQuery } from "../../globals/entity-loader/entity-loader";
+import { OptionQueryArgs } from "./option-query-args";
+import { IOption } from "../../entities/option/option.interface";
+/**
+ * Executes database queries to retrieve option IDs (or keys) based on provided arguments.
+ */
+export declare class OptionQuery implements EntityQuery<IOption> {
+    private args;
+    constructor(args: OptionQueryArgs);
+    getCount(): number | undefined;
+    getIds(): Promise<number[]>;
+}

package/dist/repository/optionquery/option-query.js

@@ -0,0 +1,20 @@
+import { wpdb } from "@/wpdb/wpdb";
+/**
+ * Executes database queries to retrieve option IDs (or keys) based on provided arguments.
+ */
+export class OptionQuery {
+    constructor(args) {
+        this.args = args;
+    }
+    getCount() {
+        return undefined;
+    }
+    async getIds() {
+        const operand = this.args.operand || '=';
+        return (await wpdb
+            .selectFrom('wpOptions')
+            .select('optionId')
+            .where(this.args.column, operand, this.args.value)
+            .execute()).map(option => option.optionId);
+    }
+}

package/dist/repository/postquery/post-query.d.ts

@@ -0,0 +1,12 @@
+import { EntityQuery } from "../../globals/entity-loader/entity-loader";
+import { IPost } from "../../entities/post/post.interface";
+/**
+ * Executes database queries to retrieve post IDs and counts based on provided arguments.
+ */
+export declare class PostQuery implements EntityQuery<IPost> {
+    private args;
+    private postCount?;
+    constructor(args: PostQueryArgs);
+    getCount(): number | undefined;
+    getIds(): Promise<number[]>;
+}