questionnaire defect 67, enf 16,reps 42

2025-01-28 12:57:52 +00:00
parent 8c6d3d84d2
commit 3ad21d2c82
4 changed files with 66 additions and 58 deletions
@@ -551,66 +551,72 @@ export const getDocumentTypeFromFilename = (filename) => {
    return doctypeCode;
 };

-export const updateLinks = (jsonObject) => {
-    const wrapPlainUrlsInAnchorTags = (htmlString) => {
-        return htmlString
-            .replace(
-                /(?<=^|>|\s)(?=\S)(?:https?:\/\/)?(?:www\.)?[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(?:\/[^\s]*)?(?=\s|<|$)/g,
-                (match) => {
-                    // If the match is already wrapped in <a> tag, return it as is
-                    if (match.includes('<a href="') || match.includes("<a ")) {
-                        return match;
+export const updateLinks = (jsonObj) => {
+    const parser = new DOMParser();
+
+    // Function to process the HTML string and replace URLs with <a> tags
+    const processHtmlString = (htmlString) => {
+        const doc = parser.parseFromString(htmlString, "text/html");
+
+        // Find all text nodes in the document
+        const walk = (node) => {
+            if (node.nodeType === Node.TEXT_NODE) {
+                // Check if the text node contains a URL (simple check for a URL pattern)
+                const urlRegex =
+                    /(?:https?:\/\/)?(?:www\.)?([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})(\/[^\s]*)?/g;
+                let match;
+
+                // Process the text node if it contains a URL
+                while ((match = urlRegex.exec(node.textContent)) !== null) {
+                    // Construct the full URL by adding the protocol if missing, and the domain and path
+                    let fullUrl = match[0];
+                    if (
+                        !fullUrl.startsWith("http://") &&
+                        !fullUrl.startsWith("https://")
+                    ) {
+                        fullUrl = `https://${match[1]}${match[2] || ""}`; // Default to https
                    }
-                    // Check if the URL starts with http:// or https://, else prepend http://
-                    const url =
-                        match.startsWith("http://") ||
-                        match.startsWith("https://")
-                            ? match
-                            : "https://" + match;

-                    // Return the URL wrapped in <a> tag
-                    return `<a href="${url}" rel="noopener noreferrer" target="_blank">${match}</a>`;
+                    // Check if the match is already inside an <a> tag, if so, skip it
+                    if (node.parentNode.tagName !== "A") {
+                        const anchor = document.createElement("a");
+                        anchor.href = fullUrl;
+                        anchor.textContent = match[0];
+
+                        // Add rel="noopener noreferrer" for security
+                        anchor.setAttribute("rel", "noopener noreferrer");
+
+                        // Replace the URL with the anchor element in the text node
+                        const range = document.createRange();
+                        range.selectNodeContents(node);
+                        range.deleteContents();
+                        range.insertNode(anchor);
+                    }
                }
-            )
-            .replace(
-                /<a [^>]*><a [^>]*>(.*?)<\/a><\/a>/g,
-                (match, innerContent) => {
-                    return `<a href="${innerContent}" rel="noopener noreferrer" target="_blank">${innerContent}</a>`;
-                }
-            );
-    };
-    // Helper function to ensure that any href attributes in <a> tags have https/http
-    const ensureHttpsInLinks = (inputString) => {
-        // Match <a> tags with href attributes and check if they lack a scheme (http:// or https://)
-        return inputString.replace(
-            /<a [^>]*href=["']([^"']*)["'][^>]*>/g,
-            (match, url) => {
-                // If the URL doesn't already have a scheme (http:// or https://), add https://
-                if (!/^https?:\/\//.test(url)) {
-                    const newUrl = `https://${url}`;
-                    return match.replace(url, newUrl);
-                }
-                return match; // Return the unchanged anchor tag if it already has a scheme
            }
-        );
+
+            // Traverse child nodes
+            for (let i = 0; i < node.childNodes.length; i++) {
+                walk(node.childNodes[i]);
+            }
+        };
+
+        walk(doc.body);
+
+        return doc.body.innerHTML;
    };

-    // Iterate through all properties of the JSON object
-    Object.keys(jsonObject).forEach((key) => {
-        const value = jsonObject[key];
+    // Iterate over the JSON object and process values that are strings (HTML content)
+    for (const key in jsonObj) {
+        if (jsonObj.hasOwnProperty(key)) {
+            const value = jsonObj[key];

-        // If the value is a string and contains plain URLs that are not wrapped
-        if (typeof value === "string") {
-            // Step 1: Wrap plain URLs in anchor tags if not already wrapped
-            let updatedValue = wrapPlainUrlsInAnchorTags(value);
-
-            // Step 2: Ensure that hrefs in anchor tags have https:// or http://
-            updatedValue = ensureHttpsInLinks(updatedValue);
-
-            // Assign the updated value back to the key
-            jsonObject[key] = updatedValue;
+            // If the value is a string and contains HTML, process it
+            if (typeof value === "string" && /<[^>]*>/g.test(value)) {
+                jsonObj[key] = processHtmlString(value);
+            }
        }
-    });
+    }

-    return jsonObject;
+    return jsonObj;
 };