@hmlr/govuk-react-components-library 1.0.1 → 1.0.3

package/dist/index.esm.js

@@ -2,7 +2,7 @@ import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { Accordion as Accordion$1, createAll, Button as Button$1, Checkboxes as Checkboxes$1, ErrorSummary as ErrorSummary$1, Header as Header$1, Radios as Radios$1, SkipLink as SkipLink$1, Tabs as Tabs$1 } from 'govuk-frontend';
 import { Link, useLocation } from 'react-router-dom';
 import * as React from 'react';
-import React__default, { useContext, useMemo, createElement, Component, useState, useEffect } from 'react';
+import React__default, { useContext, useMemo, createElement, Component, useState, useRef, useEffect } from 'react';
 
 function ConfigureOverallAccordion($scope, config) {
     if (JSON.stringify(config) === JSON.stringify({})) {
@@ -484,7 +484,10 @@ const CardLink = /*#__PURE__*/React.forwardRef(({
 });
 CardLink.displayName = 'CardLink';
 
-var divWithClassName = (className => /*#__PURE__*/React.forwardRef((p, ref) => /*#__PURE__*/jsx("div", {
+var divWithClassName = (className =>
+/*#__PURE__*/
+// eslint-disable-next-line react/display-name
+React.forwardRef((p, ref) => /*#__PURE__*/jsx("div", {
   ...p,
   ref: ref,
   className: classNames(p.className, className)
@@ -1008,28 +1011,281 @@ function Slugify(str) {
     return str;
 }
 
+/**
+ * Convert a base64 string to an ArrayBuffer
+ */
+const _base64ToArrayBuffer = (base64) => {
+    const binaryString = window.atob(base64);
+    const len = binaryString.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes.buffer;
+};
+/**
+ * Very small heuristic to detect a plain base64 string
+ */
+const isBase64 = (value) => /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{4})$/.test(value);
+/**
+ * ResolvePDFSource
+ *
+ * Accepts a source that may be:
+ *  - a plain base64 string (PDF binary encoded as base64)
+ *  - a data: URL containing base64 (data:application/pdf;base64,...)
+ *  - an existing blob: URL (blob:...)
+ *  - a Blob/File object
+ *  - a regular URL string (http(s) or same-origin path)
+ *
+ * Returns a SourceDeterminer:
+ *  - { isBase64Source: true, source: string } when an object URL was created
+ *  - { isBase64Source: false, source: string } when source can be used directly
+ *
+ * If an object URL is created, callers should revoke it when no longer needed:
+ *  `URL.revokeObjectURL(source)`
+ */
+const ResolvePDFSource = (source) => {
+    // Nothing provided
+    if (source === undefined || source === null || source === "") {
+        return { isBase64Source: false, source: "" };
+    }
+    // If source is already a Blob (File), create an object URL
+    if (typeof source.arrayBuffer === "function" ||
+        source instanceof Blob) {
+        const blob = source;
+        const objectUrl = URL.createObjectURL(blob);
+        return { isBase64Source: true, source: objectUrl };
+    }
+    // If source is a string:
+    if (typeof source === "string") {
+        // If it's already a blob URL, return as-is
+        if (source.startsWith("blob:")) {
+            return { isBase64Source: false, source };
+        }
+        // If it's a data URL (data:application/pdf;base64,....)
+        if (source.startsWith("data:")) {
+            // data:[<mediatype>][;base64],<data>
+            const commaIndex = source.indexOf(",");
+            if (commaIndex > -1) {
+                const meta = source.substring(0, commaIndex);
+                const dataPart = source.substring(commaIndex + 1);
+                // If it contains base64 marker, decode accordingly
+                if (meta.indexOf(";base64") !== -1) {
+                    try {
+                        const arrayBuffer = _base64ToArrayBuffer(dataPart);
+                        const blob = new Blob([arrayBuffer], { type: "application/pdf" });
+                        const objectUrl = URL.createObjectURL(blob);
+                        return { isBase64Source: true, source: objectUrl };
+                    }
+                    catch (err) {
+                        console.error("ResolvePDFSource: failed to convert data: URL to blob", err);
+                        // fallback to returning original data URL
+                        return { isBase64Source: false, source };
+                    }
+                }
+                else {
+                    // Not base64-encoded data URL — return as is
+                    return { isBase64Source: false, source };
+                }
+            }
+        }
+        // If it's a plain base64 string (no data: prefix), convert
+        if (isBase64(source)) {
+            try {
+                const arrayBuffer = _base64ToArrayBuffer(source);
+                const blob = new Blob([arrayBuffer], { type: "application/pdf" });
+                const objectUrl = URL.createObjectURL(blob);
+                return { isBase64Source: true, source: objectUrl };
+            }
+            catch (err) {
+                console.error("ResolvePDFSource: failed to convert base64 to blob", err);
+                return { isBase64Source: false, source };
+            }
+        }
+        // Otherwise treat as a normal URL (http(s) or same-origin path)
+        return { isBase64Source: false, source };
+    }
+    // Fallback: convert to string
+    try {
+        const asString = String(source);
+        return { isBase64Source: false, source: asString };
+    }
+    catch (err) {
+        console.error("ResolvePDFSource: failed to convert source to string", err);
+        return { isBase64Source: false, source: "" };
+    }
+};
+
 const PDFViewer = (props) => {
     const viewerRef = React__default.useRef(null);
-    const { iframeId, src, viewerLocation, documentName, documentNameColour, backend, toolbar = "minimal", additionalBackendAttributes, ...attributes } = props;
+    const { iframeId, src, viewerLocation, documentName, documentNameColour, backend, toolbar = "minimal", additionalBackendAttributes, 
+    // optional: lets callers skip client-side fetch for remote resources
+    disableClientFetch = false, ...attributes } = props;
     const [loading, setLoading] = useState(false);
+    // ref for object URL (either created by ResolvePDFSource or by us after fetching)
+    const objectUrlRef = useRef(null);
+    // did ResolvePDFSource create the object URL? (helps understanding where to revoke)
+    const createdByResolveRef = useRef(false);
+    // fetch abort controller for cross-origin remote fetches
+    const fetchControllerRef = useRef(null);
+    const isRemoteUrl = (url) => {
+        if (!url)
+            return false;
+        // Check if it's an HTTP(S) URL
+        return /^https?:\/\//i.test(url);
+    };
     useEffect(() => {
+        let mounted = true;
         setLoading(true);
         const element = viewerRef.current;
-        if (!element)
-            return; // Guard against null
-        const jsProps = {
-            iframeId,
-            source: src,
-            viewerLocation,
-            documentName,
-            documentNameColour,
-            element,
-            toolbar,
-            ...additionalBackendAttributes,
+        if (!element) {
+            setLoading(false);
+            return;
+        }
+        // cleanup previous URL/fetch if any
+        if (fetchControllerRef.current) {
+            try {
+                fetchControllerRef.current.abort();
+            }
+            catch (err) {
+                console.error("PDFViewer: fetch abort error:", err);
+                /* ignore */
+            }
+            fetchControllerRef.current = null;
+        }
+        if (objectUrlRef.current) {
+            try {
+                URL.revokeObjectURL(objectUrlRef.current);
+            }
+            catch (err) {
+                console.error("PDFViewer: revokeObjectURL error:", err);
+            }
+            objectUrlRef.current = null;
+            createdByResolveRef.current = false;
+        }
+        const init = async () => {
+            let sourceToUse = src;
+            // 1) Let ResolvePDFSource handle base64/data/blob inputs synchronously.
+            try {
+                const resolved = ResolvePDFSource(src);
+                if (resolved && resolved.source) {
+                    sourceToUse = resolved.source;
+                    if (resolved.isBase64Source) {
+                        // ResolvePDFSource created an object URL for us (data/blob/base64)
+                        objectUrlRef.current = resolved.source;
+                        createdByResolveRef.current = true;
+                    }
+                }
+            }
+            catch (err) {
+                // If ResolvePDFSource throws, just ignore and fall back to src
+                console.error("PDFViewer: ResolvePDFSource error:", err);
+            }
+            // 2) If ResolvePDFSource didn't create an object URL and the src is cross-origin HTTP(S),
+            //    attempt a client-side fetch to create an object URL (so viewer can load it safely).
+            if (!objectUrlRef.current &&
+                !disableClientFetch &&
+                typeof src === "string" &&
+                /^https?:\/\//i.test(src) &&
+                isRemoteUrl(src)) {
+                const controller = new AbortController();
+                fetchControllerRef.current = controller;
+                try {
+                    const resp = await fetch(src, {
+                        signal: controller.signal,
+                        credentials: "omit",
+                    });
+                    if (!resp.ok) {
+                        console.warn(`PDFViewer: fetch returned ${resp.status} ${resp.statusText} for ${src}`);
+                        // fallback: keep using original src
+                    }
+                    else {
+                        const blob = await resp.blob();
+                        if (blob && blob.size > 0) {
+                            const obj = URL.createObjectURL(blob);
+                            objectUrlRef.current = obj;
+                            createdByResolveRef.current = false; // we created it via fetch
+                            sourceToUse = obj;
+                        }
+                        else {
+                            console.warn("PDFViewer: fetched blob is empty - falling back to original src");
+                        }
+                    }
+                }
+                catch (err) {
+                    if (err?.name === "AbortError") {
+                        // aborted, nothing to do
+                        if (!mounted)
+                            return;
+                    }
+                    else {
+                        console.error("PDFViewer: error fetching cross-origin PDF:", err);
+                    }
+                    // fallback to source as-is (original remote URL)
+                }
+            }
+            // 3) Prepare and call backend
+            if (!mounted)
+                return;
+            const jsProps = {
+                iframeId,
+                source: sourceToUse,
+                viewerLocation,
+                documentName,
+                documentNameColour,
+                element,
+                toolbar,
+                ...additionalBackendAttributes,
+            };
+            try {
+                backend(jsProps);
+            }
+            catch (err) {
+                console.error("PDFViewer: backend threw an error:", err);
+            }
+            finally {
+                if (mounted)
+                    setLoading(false);
+            }
+        }; // end init
+        init();
+        return () => {
+            mounted = false;
+            // cancel any ongoing fetch
+            if (fetchControllerRef.current) {
+                try {
+                    fetchControllerRef.current.abort();
+                }
+                catch (err) {
+                    console.error("PDFViewer: fetch abort error during cleanup:", err);
+                }
+                fetchControllerRef.current = null;
+            }
+            // revoke any object URL we created
+            if (objectUrlRef.current) {
+                try {
+                    URL.revokeObjectURL(objectUrlRef.current);
+                }
+                catch (err) {
+                    console.error("PDFViewer: fetch abort error during cleanup:", err);
+                }
+                objectUrlRef.current = null;
+                createdByResolveRef.current = false;
+            }
+            // Note: PDFViewerBackend also attaches an iframe to the element. If backend does not
+            // remove previous iframes, you might want to clear element.children here.
         };
-        backend(jsProps);
-        setLoading(false);
-    }, []);
+        // re-run when these inputs change
+    }, [
+        src,
+        iframeId,
+        viewerLocation,
+        documentName,
+        documentNameColour,
+        toolbar,
+        backend,
+        disableClientFetch,
+    ]);
     return (jsxs(Fragment, { children: [loading && jsx(Loading, { message: "Loading PDF Document" }), jsx("div", { ref: viewerRef, id: `viewer ${documentName ? Slugify(documentName) : ""}`, "data-testid": `viewer ${documentName ? Slugify(documentName) : ""}`, style: { width: "100%", height: "100%" }, ...attributes })] }));
 };
 
@@ -1043,27 +1299,6 @@ const ObjectToQueryString = (queryParameters) => {
         : "";
 };
 
-const _base64ToArrayBuffer = (base64) => {
-    const binaryString = window.atob(base64);
-    const len = binaryString.length;
-    const bytes = new Uint8Array(len);
-    for (let i = 0; i < len; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-    }
-    return bytes.buffer;
-};
-const isBase64 = (value) => /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{4})$/.test(value);
-const ResolvePDFSource = (source) => {
-    const isBase64Source = isBase64(source);
-    if (!isBase64Source) {
-        return { isBase64Source, source };
-    }
-    const blob = new Blob([_base64ToArrayBuffer(source)], {
-        type: "application/pdf",
-    });
-    return { isBase64Source, source: URL.createObjectURL(blob) };
-};
-
 const PDFViewerBackend = ({ iframeId, source, viewerLocation = "/pdfjs-4.4.168-dist/web/viewer.html", documentName, documentNameColour = "black", toolbar = "minimal", element, ...remaining }) => {
     const sourceDeterminer = ResolvePDFSource(source);
     const iframe = document.createElement("iframe");
@@ -1080,6 +1315,8 @@ const PDFViewerBackend = ({ iframeId, source, viewerLocation = "/pdfjs-4.4.168-d
     iframe.src = `${viewerLocation}${queryString}`;
     iframe.style.width = "100%";
     iframe.style.height = "94%";
+    iframe.setAttribute("sandbox", "allow-scripts allow-same-origin allow-forms allow-downloads");
+    iframe.setAttribute("allow", "cross-origin-isolated");
     if (sourceDeterminer.isBase64Source) {
         iframe.addEventListener("beforeunload", (event) => {
             event.preventDefault();
@@ -1104,13 +1341,22 @@ const Radios = (props) => {
     const processedItems = items
         ? items.map((item) => {
             if (item) {
-                return {
-                    ...item,
-                    ...(value != null && { checked: item.value === value }),
-                    ...(defaultValue != null && {
+                // Only set checked/defaultChecked - not both
+                if (value != null) {
+                    return {
+                        ...item,
+                        checked: item.value === value,
+                        defaultChecked: undefined, // Remove defaultChecked if value is provided
+                    };
+                }
+                else if (defaultValue != null) {
+                    return {
+                        ...item,
                         defaultChecked: item.value === defaultValue,
-                    }),
-                };
+                        checked: undefined, // Remove checked if defaultValue is provided
+                    };
+                }
+                return item;
             }
             return item;
         })