@rnaga/wp-node 1.1.0

package/core/utils/comment.util.js

@@ -0,0 +1,312 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommentUtil = void 0;
+const common_1 = require("../../common");
+const config_1 = require("../../config");
+const component_1 = require("../../decorators/component");
+const val = __importStar(require("../../validators"));
+const comment_1 = require("../comment");
+const components_1 = require("../components");
+const options_1 = require("../options");
+const post_util_1 = require("./post.util");
+const query_util_1 = require("./query.util");
+const user_util_1 = require("./user.util");
+let CommentUtil = class CommentUtil {
+    components;
+    config;
+    constructor(components, config) {
+        this.components = components;
+        this.config = config;
+    }
+    async get(id) {
+        return await this.components.asyncGet(comment_1.Comment, [id]);
+    }
+    toComment(comment) {
+        return this.components.get(comment_1.Comment, [comment.comment_ID, comment]);
+    }
+    toComments(comments) {
+        return comments.map((comment) => this.toComment(comment));
+    }
+    async getDefaultStatus(postType, commentType) {
+        postType = postType ?? "post";
+        commentType = commentType ?? "comment";
+        const options = this.components.get(options_1.Options);
+        const postTypeObjects = this.components
+            .get(post_util_1.PostUtil)
+            .getTypeObject(postType);
+        let supports, option, status;
+        switch (commentType) {
+            case "pingback":
+            case "trackback":
+                supports = "trackbacks";
+                option = "ping";
+                break;
+            default:
+                supports = "comments";
+                option = "comment";
+                break;
+        }
+        // Set the status.
+        if ("page" === postType) {
+            status = "closed";
+        }
+        else if (postTypeObjects && postTypeObjects.supports.includes(supports)) {
+            const defaultStatus = await options.get(`default_${option}_status`);
+            status =
+                defaultStatus === "open" || defaultStatus === "closed"
+                    ? defaultStatus
+                    : "closed";
+        }
+        else {
+            status = "closed";
+        }
+        return status;
+    }
+    // wp_get_comment_status
+    async getStatusAsString(commentId) {
+        const comment = await this.get(commentId);
+        if (!comment.props) {
+            return "";
+        }
+        const approved = comment.props.comment_approved;
+        if (!approved) {
+            return "";
+        }
+        if ("1" === approved) {
+            return "approved";
+        }
+        if ("0" === approved) {
+            return "unapproved";
+        }
+        if ("spam" == approved || "trash" == approved) {
+            return approved;
+        }
+        return "";
+    }
+    // comments_open
+    isOpen(post) {
+        return post.props && "open" == post.props.comment_status;
+    }
+    // wp_check_comment_disallowed_list
+    async containsNGWord(args) {
+        const { comment_author: author = "", comment_author_email: email = "", comment_author_url: url = "", comment_content: content = "", comment_author_IP: authorIp = "", comment_agent: userAgent = "", } = args;
+        const options = this.components.get(options_1.Options);
+        const moderationKeys = await options.get("disallowed_keys");
+        if (!moderationKeys || 0 >= moderationKeys.length) {
+            return false;
+        }
+        // Ensure HTML tags are not being used to bypass the list of disallowed characters and words.
+        const commentWithoutHtml = common_1.formatting.stripTags(content);
+        const escapeRegExp = (key) => {
+            // Escape special characters for use in a regular expression
+            return key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        };
+        for (const key of moderationKeys.split("\n").map((key) => key.trim())) {
+            // Skip empty lines.
+            if (0 >= key.length) {
+                continue;
+            }
+            // Do some escaping magic so that '#' chars in the spam words don't break things
+            const pattern = new RegExp(escapeRegExp(key), "iu");
+            if (pattern.test(author) ||
+                pattern.test(email) ||
+                pattern.test(url) ||
+                pattern.test(content) ||
+                pattern.test(commentWithoutHtml) ||
+                pattern.test(authorIp) ||
+                pattern.test(userAgent)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // check_comment
+    async isValid(args) {
+        const { comment_author: author = "", comment_author_email: email = "", comment_author_url: url = "", comment_content: content = "", comment_author_IP: authorIp = "", comment_agent: userAgent = "", comment_type: commentType = "comment", } = args;
+        const options = this.components.get(options_1.Options);
+        // If manual moderation is enabled, skip all checks and return false.
+        if (1 === (await options.get("comment_moderation"))) {
+            return false;
+        }
+        // Check for the number of external links if a max allowed number is set.
+        const maxLinks = await options.get("comment_max_links");
+        if (maxLinks) {
+            const regex = /<a [^>]*href/gi;
+            const numLinks = content.match(regex);
+            if (numLinks && numLinks.length >= maxLinks) {
+                return false;
+            }
+        }
+        const moderationKeys = (await options.get("moderation_keys"))?.trim();
+        // If moderation 'keys' (keywords) are set, process them.
+        if (moderationKeys) {
+            const escapeRegExp = (key) => {
+                // Escape special characters for use in a regular expression
+                return key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            };
+            for (const key of moderationKeys.split("\n").map((key) => key.trim())) {
+                // Skip empty lines.
+                if (0 >= key.length) {
+                    continue;
+                }
+                // - Escape the word to be used in the regex
+                // - Create the regex pattern
+                const pattern = new RegExp(escapeRegExp(key), "iu");
+                for (const field of [
+                    author,
+                    email,
+                    url,
+                    content,
+                    authorIp,
+                    userAgent,
+                ]) {
+                    if (pattern.test(field)) {
+                        return false;
+                    }
+                }
+            }
+            /*
+             * Check if the option to approve comments by previously-approved authors is enabled.
+             *
+             * If it is enabled, check whether the comment author has a previously-approved comment,
+             * as well as whether there are any moderation keywords (if set) present in the author
+             * email address. If both checks pass, return true. Otherwise, return false.
+             */
+            if (1 === (await options.get("comment_previously_approved"))) {
+                if (commentType === "trackback" ||
+                    commentType === "pingback" ||
+                    0 >= author.length ||
+                    0 >= email.length) {
+                    return false;
+                }
+                const queryUtil = this.components.get(query_util_1.QueryUtil);
+                const user = await queryUtil.users((query) => {
+                    query.where("user_email", common_1.formatting.unslash(email)).builder.first();
+                }, val.database.wpUsers);
+                let okToComment = false;
+                if (user && user.ID) {
+                    okToComment = (await queryUtil.comments((query) => {
+                        query.where("user_id", user.ID).where("approved", "1");
+                    }))
+                        ? true
+                        : false;
+                }
+                else {
+                    okToComment = (await queryUtil.comments((query) => {
+                        query
+                            .where("author", author)
+                            .where("author_email", email)
+                            .where("approved", "1");
+                    }))
+                        ? true
+                        : false;
+                }
+                return (okToComment && (!moderationKeys || !email.includes(moderationKeys)));
+            }
+        }
+        return true;
+    }
+    // wp_allow_comment
+    async getStatus(comment) {
+        const parsed = val.database.wpComments.safeParse({
+            comment_ID: 0,
+            ...comment,
+        });
+        if (!parsed.success) {
+            return "0";
+        }
+        const data = parsed.data;
+        /*
+         * Simple duplicate check.
+         * expected_slashed ($comment_post_ID, $comment_author, $comment_author_email, $comment_content)
+         */
+        const queryUtil = this.components.get(query_util_1.QueryUtil);
+        const duplicate = await queryUtil.comments((query) => {
+            query
+                .where("post_ID", common_1.formatting.unslash(data.comment_post_ID))
+                .where("parent", common_1.formatting.unslash(data.comment_parent));
+            if (data.comment_author) {
+                query.where("author", common_1.formatting.unslash(data.comment_author));
+            }
+            if (data.comment_author_email) {
+                query.where("author_email", common_1.formatting.unslash(data.comment_author_email));
+            }
+            query.builder.first();
+        }, val.database.wpComments);
+        if (duplicate) {
+            throw new Error("comment_duplicate");
+        }
+        let user = undefined;
+        let post = undefined;
+        if (data.user_id && data.comment_post_ID) {
+            const userUtil = this.components.get(user_util_1.UserUtil);
+            user = await userUtil.get(data.user_id);
+            post = await queryUtil.posts((query) => {
+                query.where("ID", data.comment_post_ID).builder.first();
+            }, val.database.wpPosts);
+        }
+        if (user &&
+            user.props &&
+            (data.user_id == post?.post_author ||
+                (await user.can("moderate_comments")))) {
+            return "1";
+        }
+        let approved = "0";
+        if (await this.isValid(comment)) {
+            approved = "1";
+        }
+        if (await this.containsNGWord(comment)) {
+            approved = this.config.config.constants.EMPTY_TRASH_DAYS
+                ? "trash"
+                : "spam";
+        }
+        return approved;
+    }
+};
+exports.CommentUtil = CommentUtil;
+exports.CommentUtil = CommentUtil = __decorate([
+    (0, component_1.component)(),
+    __metadata("design:paramtypes", [components_1.Components, config_1.Config])
+], CommentUtil);

package/core/utils/crud.util.d.ts

@@ -0,0 +1,40 @@
+import { BlogCrud } from "../../crud/blog.crud";
+import { CommentCrud } from "../../crud/comment.crud";
+import { CrudError, StatusMessage } from "../../crud/error";
+import { MetaCrud } from "../../crud/meta.crud";
+import { OptionsCrud } from "../../crud/options.crud";
+import { PostCrud } from "../../crud/post.crud";
+import { RevisionCrud } from "../../crud/revision.crud";
+import { RolesCrud } from "../../crud/roles.crud";
+import { SettingsCrud } from "../../crud/settings.crud";
+import { SiteCrud } from "../../crud/site.crud";
+import { SitemetaCrud } from "../../crud/sitemeta.crud";
+import { TermCrud } from "../../crud/term.crud";
+import { UserSelfRegistrationCrud } from "../../crud/user-self-registration.crud";
+import { UserCrud } from "../../crud/user.crud";
+import { Components } from "../components";
+export declare class CrudUtil {
+    private components;
+    constructor(components: Components);
+    parseError<T extends Error & CrudError>(e: T): {
+        status: {
+            code: import("../../crud/error").StatusCode;
+            message: StatusMessage;
+        };
+        message: string;
+    };
+    get blog(): BlogCrud;
+    get comment(): CommentCrud;
+    get meta(): MetaCrud;
+    get options(): OptionsCrud;
+    get post(): PostCrud;
+    get revision(): RevisionCrud;
+    get roles(): RolesCrud;
+    get settings(): SettingsCrud;
+    get site(): SiteCrud;
+    get sitemeta(): SitemetaCrud;
+    get term(): TermCrud;
+    get user(): UserCrud;
+    get userSelfRegistration(): UserSelfRegistrationCrud;
+}
+//# sourceMappingURL=crud.util.d.ts.map

package/core/utils/crud.util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud.util.d.ts","sourceRoot":"","sources":["../../../src/core/utils/crud.util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,SAAS,EAAoB,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC9E,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AAClF,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,qBACa,QAAQ;IACP,OAAO,CAAC,UAAU;gBAAV,UAAU,EAAE,UAAU;IAE1C,UAAU,CAAC,CAAC,SAAS,KAAK,GAAG,SAAS,EAAE,CAAC,EAAE,CAAC;;;;;;;IAqB5C,IAAI,IAAI,aAEP;IAED,IAAI,OAAO,gBAEV;IAED,IAAI,IAAI,aAEP;IAED,IAAI,OAAO,gBAEV;IAED,IAAI,IAAI,aAEP;IAED,IAAI,QAAQ,iBAEX;IAED,IAAI,KAAK,cAER;IAED,IAAI,QAAQ,iBAEX;IAED,IAAI,IAAI,aAEP;IAED,IAAI,QAAQ,iBAEX;IAED,IAAI,IAAI,aAEP;IAED,IAAI,IAAI,aAEP;IAED,IAAI,oBAAoB,6BAEvB;CACF"}

package/core/utils/crud.util.js

@@ -0,0 +1,97 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudUtil = void 0;
+const blog_crud_1 = require("../../crud/blog.crud");
+const comment_crud_1 = require("../../crud/comment.crud");
+const error_1 = require("../../crud/error");
+const meta_crud_1 = require("../../crud/meta.crud");
+const options_crud_1 = require("../../crud/options.crud");
+const post_crud_1 = require("../../crud/post.crud");
+const revision_crud_1 = require("../../crud/revision.crud");
+const roles_crud_1 = require("../../crud/roles.crud");
+const settings_crud_1 = require("../../crud/settings.crud");
+const site_crud_1 = require("../../crud/site.crud");
+const sitemeta_crud_1 = require("../../crud/sitemeta.crud");
+const term_crud_1 = require("../../crud/term.crud");
+const user_self_registration_crud_1 = require("../../crud/user-self-registration.crud");
+const user_crud_1 = require("../../crud/user.crud");
+const component_1 = require("../../decorators/component");
+const components_1 = require("../components");
+let CrudUtil = class CrudUtil {
+    components;
+    constructor(components) {
+        this.components = components;
+    }
+    parseError(e) {
+        if (e?.statusCode) {
+            return {
+                status: {
+                    code: e.statusCode,
+                    message: error_1.StatusCodeMapper.getMessage(e.statusCode),
+                },
+                message: e.message,
+            };
+        }
+        const statusMessage = error_1.StatusMessage.INTERNAL_SERVER_ERROR;
+        return {
+            status: {
+                code: error_1.StatusCodeMapper.getCode(statusMessage),
+                message: statusMessage,
+            },
+            message: e.message,
+        };
+    }
+    get blog() {
+        return this.components.get(blog_crud_1.BlogCrud);
+    }
+    get comment() {
+        return this.components.get(comment_crud_1.CommentCrud);
+    }
+    get meta() {
+        return this.components.get(meta_crud_1.MetaCrud);
+    }
+    get options() {
+        return this.components.get(options_crud_1.OptionsCrud);
+    }
+    get post() {
+        return this.components.get(post_crud_1.PostCrud);
+    }
+    get revision() {
+        return this.components.get(revision_crud_1.RevisionCrud);
+    }
+    get roles() {
+        return this.components.get(roles_crud_1.RolesCrud);
+    }
+    get settings() {
+        return this.components.get(settings_crud_1.SettingsCrud);
+    }
+    get site() {
+        return this.components.get(site_crud_1.SiteCrud);
+    }
+    get sitemeta() {
+        return this.components.get(sitemeta_crud_1.SitemetaCrud);
+    }
+    get term() {
+        return this.components.get(term_crud_1.TermCrud);
+    }
+    get user() {
+        return this.components.get(user_crud_1.UserCrud);
+    }
+    get userSelfRegistration() {
+        return this.components.get(user_self_registration_crud_1.UserSelfRegistrationCrud);
+    }
+};
+exports.CrudUtil = CrudUtil;
+exports.CrudUtil = CrudUtil = __decorate([
+    (0, component_1.component)(),
+    __metadata("design:paramtypes", [components_1.Components])
+], CrudUtil);

package/core/utils/date-time.util.d.ts

@@ -0,0 +1,9 @@
+import { Components } from "../components";
+import { DateTime } from "../date-time";
+import type { MomentInput } from "moment";
+export declare class DateTimeUtil {
+    private components;
+    constructor(components: Components);
+    get(date?: MomentInput): DateTime;
+}
+//# sourceMappingURL=date-time.util.d.ts.map

package/core/utils/date-time.util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-time.util.d.ts","sourceRoot":"","sources":["../../../src/core/utils/date-time.util.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE1C,qBACa,YAAY;IACX,OAAO,CAAC,UAAU;gBAAV,UAAU,EAAE,UAAU;IAE1C,GAAG,CAAC,IAAI,CAAC,EAAE,WAAW;CAGvB"}

package/core/utils/date-time.util.js

@@ -0,0 +1,29 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateTimeUtil = void 0;
+const component_1 = require("../../decorators/component");
+const components_1 = require("../components");
+const date_time_1 = require("../date-time");
+let DateTimeUtil = class DateTimeUtil {
+    components;
+    constructor(components) {
+        this.components = components;
+    }
+    get(date) {
+        return this.components.get(date_time_1.DateTime, [date]);
+    }
+};
+exports.DateTimeUtil = DateTimeUtil;
+exports.DateTimeUtil = DateTimeUtil = __decorate([
+    (0, component_1.component)(),
+    __metadata("design:paramtypes", [components_1.Components])
+], DateTimeUtil);

package/core/utils/link.util.d.ts

@@ -0,0 +1,23 @@
+import { Config } from "../../config";
+import { Components } from "../components";
+import { Post } from "../post";
+import { Vars } from "../vars";
+import { PostUtil } from "./post.util";
+export declare class LinkUtil {
+    private components;
+    private postUtil;
+    private vars;
+    private config;
+    constructor(components: Components, postUtil: PostUtil, vars: Vars, config: Config);
+    getPermalink(post: Post): Promise<string>;
+    getAttachmentLink(post?: Post): Promise<string>;
+    getPageLink(post?: Post, leavename?: boolean, sample?: boolean): Promise<string>;
+    private forcePlainPostPermalink;
+    getHomeUrl(args?: {
+        blogId?: number;
+        path?: string;
+        scheme?: "http" | "https" | "relative" | "rest";
+    }): Promise<string>;
+    setUrlScheme(url: string, scheme?: string | null): string;
+}
+//# sourceMappingURL=link.util.d.ts.map

package/core/utils/link.util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.util.d.ts","sourceRoot":"","sources":["../../../src/core/utils/link.util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,qBACa,QAAQ;IAEjB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,MAAM;gBAHN,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,MAAM;IAIlB,YAAY,CAAC,IAAI,EAAE,IAAI;IAmBvB,iBAAiB,CAAC,IAAI,CAAC,EAAE,IAAI;IAO7B,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,UAAQ,EAAE,MAAM,UAAQ;IAiBhE,OAAO,CAAC,uBAAuB;IAgCzB,UAAU,CAAC,IAAI,CAAC,EAAE;QACtB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,UAAU,GAAG,MAAM,CAAC;KACjD;IAgCD,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,GAAG,IAAW,GAAG,MAAM;CA2BhE"}

package/core/utils/link.util.js

@@ -0,0 +1,148 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkUtil = void 0;
+const config_1 = require("../../config");
+const component_1 = require("../../decorators/component");
+const components_1 = require("../components");
+const current_1 = require("../current");
+const options_1 = require("../options");
+const vars_1 = require("../vars");
+const post_util_1 = require("./post.util");
+let LinkUtil = class LinkUtil {
+    components;
+    postUtil;
+    vars;
+    config;
+    constructor(components, postUtil, vars, config) {
+        this.components = components;
+        this.postUtil = postUtil;
+        this.vars = vars;
+        this.config = config;
+    }
+    // get_permalink
+    async getPermalink(post) {
+        if (!post.props?.ID) {
+            return this.getHomeUrl();
+        }
+        if ("page" === post.props.post_type) {
+            return await this.getPageLink(post);
+        }
+        if ("attachment" === post.props.post_type) {
+            return await this.getAttachmentLink(post);
+        }
+        return this.getHomeUrl({
+            path: `?p=${post.props.ID}`,
+        });
+    }
+    // get_attachment_link
+    async getAttachmentLink(post) {
+        return !post
+            ? await this.getHomeUrl()
+            : await this.getHomeUrl({ path: `/?attachment_id=${post.props?.ID}` });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async getPageLink(post, leavename = false, sample = false) {
+        if (!post || !post.props?.ID) {
+            return await this.getHomeUrl();
+        }
+        const options = this.components.get(options_1.Options);
+        if ("page" === (await options.get("show_on_from")) &&
+            (await options.get("page_on_from")) === post.props.ID) {
+            return await this.getHomeUrl();
+        }
+        return await this.getHomeUrl({ path: `?page_id=${post.props.ID}` });
+    }
+    forcePlainPostPermalink(post) {
+        const postUtil = this.components.get(post_util_1.PostUtil);
+        const current = this.components.get(current_1.Current);
+        const sample = post.filter == "sample";
+        if (!post.props?.ID && post.props && 0 >= post.props.ID) {
+            return true;
+        }
+        const statusObject = postUtil.getStatusObject(post.props?.post_status);
+        const typeObject = postUtil.getTypeObject(post.props?.post_type);
+        if (!statusObject || !typeObject) {
+            return true;
+        }
+        if (
+        // Publicly viewable links never have plain permalinks.
+        postUtil.isStatusViewable(statusObject) ||
+            // Private posts don't have plain permalinks if the user can read them.
+            (true == statusObject.private &&
+                post.props?.ID &&
+                current.user?.can("read_post", post.props.ID)) ||
+            // Protected posts don't have plain links if getting a sample URL.
+            (true == statusObject.protected && sample)) {
+            return false;
+        }
+        return true;
+    }
+    async getHomeUrl(args) {
+        let { scheme = undefined } = args ?? {};
+        const { blogId = undefined, path = "" } = args ?? {};
+        const options = this.components.get(options_1.Options);
+        if (blogId && this.config.isMultiSite()) {
+            options.usingBlog(blogId);
+        }
+        let url = (await options.get("home")) ?? "";
+        options.resetBlog();
+        if (!["http", "https", "relative"].includes(scheme ?? "")) {
+            scheme = this.config.isSsl() ? "https" : "http";
+        }
+        else {
+            try {
+                const protocol = new URL(url).protocol.replace(/:$/, "");
+                scheme = ["http", "https", "relative", "rest"].includes(protocol)
+                    ? protocol
+                    : (scheme = this.config.isSsl() ? "https" : "http");
+            }
+            catch (e) {
+                scheme = this.config.isSsl() ? "https" : "http";
+            }
+        }
+        url = this.setUrlScheme(url, scheme);
+        if (typeof path === "string") {
+            url = `${url}/${path.replace(/^\//, "")}`;
+        }
+        return url;
+    }
+    setUrlScheme(url, scheme = null) {
+        if (!scheme ||
+            ["admin", "login", "login_post", "rpc"].includes(scheme) ||
+            !["http", "https", "relative"].includes(scheme)) {
+            scheme = this.config.isSsl() ? "https" : "http";
+        }
+        url = url.trim();
+        if (url.startsWith("//")) {
+            url = "https:" + url;
+        }
+        if (scheme === "relative") {
+            url = url.replace(/^\w+:\/\//, ""); // Remove the scheme
+            if (url !== "" && url[0] === "/") {
+                // eslint-disable-next-line no-control-regex
+                url = "/" + url.replace(/^[/ \t\n\r\0\x0B]+/, "");
+            }
+        }
+        else {
+            url = url.replace(/^\w+:\/\//, scheme + "://");
+        }
+        return url;
+    }
+};
+exports.LinkUtil = LinkUtil;
+exports.LinkUtil = LinkUtil = __decorate([
+    (0, component_1.component)(),
+    __metadata("design:paramtypes", [components_1.Components,
+        post_util_1.PostUtil,
+        vars_1.Vars,
+        config_1.Config])
+], LinkUtil);