art-bd-ui 1.0.21 → 1.0.23

package/dist/cjs/node_modules/react-pdf/dist/Page/AnnotationLayer.js

@@ -0,0 +1,152 @@
+"use client";
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var clsx = require('../../../clsx/dist/clsx.js');
+var index = require('../../../make-cancellable-promise/dist/index.js');
+var pdf = require('../../../pdfjs-dist/build/pdf.js');
+var tinyInvariant = require('../../../tiny-invariant/dist/esm/tiny-invariant.js');
+var warning = require('../../../../_virtual/warning.js');
+var useDocumentContext = require('../shared/hooks/useDocumentContext.js');
+var usePageContext = require('../shared/hooks/usePageContext.js');
+var useResolver = require('../shared/hooks/useResolver.js');
+var utils = require('../shared/utils.js');
+
+function AnnotationLayer() {
+    const documentContext = useDocumentContext.default();
+    const pageContext = usePageContext.default();
+    tinyInvariant.default(pageContext, 'Unable to find Page context.');
+    const mergedProps = { ...documentContext, ...pageContext };
+    const { filterAnnotations, imageResourcesPath, linkService, onGetAnnotationsError: onGetAnnotationsErrorProps, onGetAnnotationsSuccess: onGetAnnotationsSuccessProps, onRenderAnnotationLayerError: onRenderAnnotationLayerErrorProps, onRenderAnnotationLayerSuccess: onRenderAnnotationLayerSuccessProps, page, pdf: pdf$1, renderForms, rotate, scale = 1, } = mergedProps;
+    tinyInvariant.default(pdf$1, 'Attempted to load page annotations, but no document was specified. Wrap <Page /> in a <Document /> or pass explicit `pdf` prop.');
+    tinyInvariant.default(page, 'Attempted to load page annotations, but no page was specified.');
+    tinyInvariant.default(linkService, 'Attempted to load page annotations, but no linkService was specified.');
+    const [annotationsState, annotationsDispatch] = useResolver.default();
+    const { value: annotations, error: annotationsError } = annotationsState;
+    const layerElement = React.useRef(null);
+    warning.default(Number.parseInt(window.getComputedStyle(document.body).getPropertyValue('--react-pdf-annotation-layer'), 10) === 1, 'AnnotationLayer styles not found. Read more: https://github.com/wojtekmaj/react-pdf#support-for-annotations');
+    function onLoadSuccess() {
+        if (!annotations) {
+            // Impossible, but TypeScript doesn't know that
+            return;
+        }
+        if (onGetAnnotationsSuccessProps) {
+            onGetAnnotationsSuccessProps(annotations);
+        }
+    }
+    function onLoadError() {
+        if (!annotationsError) {
+            // Impossible, but TypeScript doesn't know that
+            return;
+        }
+        warning.default(false, annotationsError.toString());
+        if (onGetAnnotationsErrorProps) {
+            onGetAnnotationsErrorProps(annotationsError);
+        }
+    }
+    // biome-ignore lint/correctness/useExhaustiveDependencies: useEffect intentionally triggered on page change
+    React.useEffect(function resetAnnotations() {
+        annotationsDispatch({ type: 'RESET' });
+    }, [annotationsDispatch, page]);
+    React.useEffect(function loadAnnotations() {
+        if (!page) {
+            return;
+        }
+        const cancellable = index.default(page.getAnnotations());
+        const runningTask = cancellable;
+        cancellable.promise
+            .then((nextAnnotations) => {
+            annotationsDispatch({ type: 'RESOLVE', value: nextAnnotations });
+        })
+            .catch((error) => {
+            annotationsDispatch({ type: 'REJECT', error });
+        });
+        return () => {
+            utils.cancelRunningTask(runningTask);
+        };
+    }, [annotationsDispatch, page]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: Omitted callbacks so they are not called every time they change
+    React.useEffect(() => {
+        if (annotations === undefined) {
+            return;
+        }
+        if (annotations === false) {
+            onLoadError();
+            return;
+        }
+        onLoadSuccess();
+    }, [annotations]);
+    function onRenderSuccess() {
+        if (onRenderAnnotationLayerSuccessProps) {
+            onRenderAnnotationLayerSuccessProps();
+        }
+    }
+    function onRenderError(error) {
+        warning.default(false, `${error}`);
+        if (onRenderAnnotationLayerErrorProps) {
+            onRenderAnnotationLayerErrorProps(error);
+        }
+    }
+    const viewport = React.useMemo(() => page.getViewport({ scale, rotation: rotate }), [page, rotate, scale]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: Omitted callbacks so they are not called every time they change
+    React.useEffect(function renderAnnotationLayer() {
+        if (!pdf$1 || !page || !linkService || !annotations) {
+            return;
+        }
+        const { current: layer } = layerElement;
+        if (!layer) {
+            return;
+        }
+        const clonedViewport = viewport.clone({ dontFlip: true });
+        const annotationLayerParameters = {
+            accessibilityManager: null, // TODO: Implement this
+            annotationCanvasMap: null, // TODO: Implement this
+            annotationEditorUIManager: null, // TODO: Implement this
+            annotationStorage: pdf$1.annotationStorage,
+            commentManager: null, // TODO: Implement this
+            div: layer,
+            l10n: null, // TODO: Implement this
+            linkService,
+            page,
+            structTreeLayer: null, // TODO: Implement this
+            viewport: clonedViewport,
+        };
+        const renderParameters = {
+            annotations: filterAnnotations ? filterAnnotations({ annotations }) : annotations,
+            annotationStorage: pdf$1.annotationStorage,
+            div: layer,
+            imageResourcesPath,
+            linkService,
+            page,
+            renderForms,
+            viewport: clonedViewport,
+        };
+        layer.innerHTML = '';
+        try {
+            new pdf.AnnotationLayer(annotationLayerParameters).render(renderParameters);
+            // Intentional immediate callback
+            onRenderSuccess();
+        }
+        catch (error) {
+            onRenderError(error);
+        }
+        return () => {
+            // TODO: Cancel running task?
+        };
+    }, [
+        annotations,
+        filterAnnotations,
+        imageResourcesPath,
+        linkService,
+        page,
+        pdf$1,
+        renderForms,
+        viewport,
+    ]);
+    return (jsxRuntime.jsx("div", { className: clsx.clsx('react-pdf__Page__annotations', 'annotationLayer'), ref: layerElement }));
+}
+
+exports.default = AnnotationLayer;

package/dist/cjs/node_modules/react-pdf/dist/Page/Canvas.js

@@ -0,0 +1,104 @@
+"use client";
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var index = require('../../../merge-refs/dist/index.js');
+var pdf = require('../../../pdfjs-dist/build/pdf.js');
+var tinyInvariant = require('../../../tiny-invariant/dist/esm/tiny-invariant.js');
+var warning = require('../../../../_virtual/warning.js');
+var StructTree = require('../StructTree.js');
+var usePageContext = require('../shared/hooks/usePageContext.js');
+var utils = require('../shared/utils.js');
+
+const ANNOTATION_MODE = pdf.AnnotationMode;
+function Canvas(props) {
+    const pageContext = usePageContext.default();
+    tinyInvariant.default(pageContext, 'Unable to find Page context.');
+    const mergedProps = { ...pageContext, ...props };
+    const { _className, canvasBackground, devicePixelRatio = utils.getDevicePixelRatio(), onRenderError: onRenderErrorProps, onRenderSuccess: onRenderSuccessProps, page, renderForms, renderTextLayer, rotate, scale, } = mergedProps;
+    const { canvasRef } = props;
+    tinyInvariant.default(page, 'Attempted to render page canvas, but no page was specified.');
+    const canvasElement = React.useRef(null);
+    /**
+     * Called when a page is rendered successfully.
+     */
+    function onRenderSuccess() {
+        if (!page) {
+            // Impossible, but TypeScript doesn't know that
+            return;
+        }
+        if (onRenderSuccessProps) {
+            onRenderSuccessProps(utils.makePageCallback(page, scale));
+        }
+    }
+    /**
+     * Called when a page fails to render.
+     */
+    function onRenderError(error) {
+        if (utils.isAbortException(error)) {
+            return;
+        }
+        warning.default(false, error.toString());
+        if (onRenderErrorProps) {
+            onRenderErrorProps(error);
+        }
+    }
+    const renderViewport = React.useMemo(() => page.getViewport({ scale: scale * devicePixelRatio, rotation: rotate }), [devicePixelRatio, page, rotate, scale]);
+    const viewport = React.useMemo(() => page.getViewport({ scale, rotation: rotate }), [page, rotate, scale]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: Omitted callbacks so they are not called every time they change
+    React.useEffect(function drawPageOnCanvas() {
+        if (!page) {
+            return;
+        }
+        // Ensures the canvas will be re-rendered from scratch. Otherwise all form data will stay.
+        page.cleanup();
+        const { current: canvas } = canvasElement;
+        if (!canvas) {
+            return;
+        }
+        canvas.width = renderViewport.width;
+        canvas.height = renderViewport.height;
+        canvas.style.width = `${Math.floor(viewport.width)}px`;
+        canvas.style.height = `${Math.floor(viewport.height)}px`;
+        canvas.style.visibility = 'hidden';
+        const renderContext = {
+            annotationMode: renderForms ? ANNOTATION_MODE.ENABLE_FORMS : ANNOTATION_MODE.ENABLE,
+            canvas,
+            canvasContext: canvas.getContext('2d', { alpha: false }),
+            viewport: renderViewport,
+        };
+        if (canvasBackground) {
+            renderContext.background = canvasBackground;
+        }
+        const cancellable = page.render(renderContext);
+        const runningTask = cancellable;
+        cancellable.promise
+            .then(() => {
+            canvas.style.visibility = '';
+            onRenderSuccess();
+        })
+            .catch(onRenderError);
+        return () => utils.cancelRunningTask(runningTask);
+    }, [canvasBackground, page, renderForms, renderViewport, viewport]);
+    const cleanup = React.useCallback(() => {
+        const { current: canvas } = canvasElement;
+        /**
+         * Zeroing the width and height cause most browsers to release graphics
+         * resources immediately, which can greatly reduce memory consumption.
+         */
+        if (canvas) {
+            canvas.width = 0;
+            canvas.height = 0;
+        }
+    }, []);
+    React.useEffect(() => cleanup, [cleanup]);
+    return (jsxRuntime.jsx("canvas", { className: `${_className}__canvas`, dir: "ltr", ref: index.default(canvasRef, canvasElement), style: {
+            display: 'block',
+            userSelect: 'none',
+        }, children: renderTextLayer ? jsxRuntime.jsx(StructTree.default, {}) : null }));
+}
+
+exports.default = Canvas;

package/dist/cjs/node_modules/react-pdf/dist/Page/TextLayer.css.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var styleInject_es = require('../../../style-inject/dist/style-inject.es.js');
+
+var css_248z = "/* Copyright 2014 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n:root {\n  --react-pdf-text-layer: 1;\n  --highlight-bg-color: rgba(180, 0, 170, 1);\n  --highlight-selected-bg-color: rgba(0, 100, 0, 1);\n}\n\n@media screen and (forced-colors: active) {\n  :root {\n    --highlight-bg-color: Highlight;\n    --highlight-selected-bg-color: ButtonText;\n  }\n}\n\n[data-main-rotation='90'] {\n  transform: rotate(90deg) translateY(-100%);\n}\n[data-main-rotation='180'] {\n  transform: rotate(180deg) translate(-100%, -100%);\n}\n[data-main-rotation='270'] {\n  transform: rotate(270deg) translateX(-100%);\n}\n\n.textLayer {\n  position: absolute;\n  text-align: initial;\n  inset: 0;\n  overflow: hidden;\n  line-height: 1;\n  text-size-adjust: none;\n  forced-color-adjust: none;\n  transform-origin: 0 0;\n  z-index: 2;\n}\n\n.textLayer :is(span, br) {\n  color: transparent;\n  position: absolute;\n  white-space: pre;\n  cursor: text;\n  margin: 0;\n  transform-origin: 0 0;\n}\n\n/* Only necessary in Google Chrome, see issue 14205, and most unfortunately\n * the problem doesn't show up in \"text\" reference tests. */\n.textLayer span.markedContent {\n  top: 0;\n  height: 0;\n}\n\n.textLayer .highlight {\n  margin: -1px;\n  padding: 1px;\n  background-color: var(--highlight-bg-color);\n  border-radius: 4px;\n}\n\n.textLayer .highlight.appended {\n  position: initial;\n}\n\n.textLayer .highlight.begin {\n  border-radius: 4px 0 0 4px;\n}\n\n.textLayer .highlight.end {\n  border-radius: 0 4px 4px 0;\n}\n\n.textLayer .highlight.middle {\n  border-radius: 0;\n}\n\n.textLayer .highlight.selected {\n  background-color: var(--highlight-selected-bg-color);\n}\n\n/* Avoids https://github.com/mozilla/pdf.js/issues/13840 in Chrome */\n.textLayer br::selection {\n  background: transparent;\n}\n\n.textLayer .endOfContent {\n  display: block;\n  position: absolute;\n  inset: 100% 0 0;\n  z-index: -1;\n  cursor: default;\n  user-select: none;\n}\n\n.textLayer.selecting .endOfContent {\n  top: 0;\n}\n\n.hiddenCanvasElement {\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 0;\n  height: 0;\n  display: none;\n}\n";
+styleInject_es.default(css_248z);
+
+exports.default = css_248z;

package/dist/cjs/node_modules/react-pdf/dist/Page/TextLayer.js

@@ -0,0 +1,183 @@
+"use client";
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var clsx = require('../../../clsx/dist/clsx.js');
+var index = require('../../../make-cancellable-promise/dist/index.js');
+var pdf = require('../../../pdfjs-dist/build/pdf.js');
+var tinyInvariant = require('../../../tiny-invariant/dist/esm/tiny-invariant.js');
+var warning = require('../../../../_virtual/warning.js');
+var usePageContext = require('../shared/hooks/usePageContext.js');
+var useResolver = require('../shared/hooks/useResolver.js');
+var utils = require('../shared/utils.js');
+
+function isTextItem(item) {
+    return 'str' in item;
+}
+function TextLayer() {
+    const pageContext = usePageContext.default();
+    tinyInvariant.default(pageContext, 'Unable to find Page context.');
+    const { customTextRenderer, onGetTextError, onGetTextSuccess, onRenderTextLayerError, onRenderTextLayerSuccess, page, pageIndex, pageNumber, rotate, scale, } = pageContext;
+    tinyInvariant.default(page, 'Attempted to load page text content, but no page was specified.');
+    const [textContentState, textContentDispatch] = useResolver.default();
+    const { value: textContent, error: textContentError } = textContentState;
+    const layerElement = React.useRef(null);
+    warning.default(Number.parseInt(window.getComputedStyle(document.body).getPropertyValue('--react-pdf-text-layer'), 10) === 1, 'TextLayer styles not found. Read more: https://github.com/wojtekmaj/react-pdf#support-for-text-layer');
+    /**
+     * Called when a page text content is read successfully
+     */
+    function onLoadSuccess() {
+        if (!textContent) {
+            // Impossible, but TypeScript doesn't know that
+            return;
+        }
+        if (onGetTextSuccess) {
+            onGetTextSuccess(textContent);
+        }
+    }
+    /**
+     * Called when a page text content failed to read successfully
+     */
+    function onLoadError() {
+        if (!textContentError) {
+            // Impossible, but TypeScript doesn't know that
+            return;
+        }
+        warning.default(false, textContentError.toString());
+        if (onGetTextError) {
+            onGetTextError(textContentError);
+        }
+    }
+    // biome-ignore lint/correctness/useExhaustiveDependencies: useEffect intentionally triggered on page change
+    React.useEffect(function resetTextContent() {
+        textContentDispatch({ type: 'RESET' });
+    }, [page, textContentDispatch]);
+    React.useEffect(function loadTextContent() {
+        if (!page) {
+            return;
+        }
+        const cancellable = index.default(page.getTextContent());
+        const runningTask = cancellable;
+        cancellable.promise
+            .then((nextTextContent) => {
+            textContentDispatch({ type: 'RESOLVE', value: nextTextContent });
+        })
+            .catch((error) => {
+            textContentDispatch({ type: 'REJECT', error });
+        });
+        return () => utils.cancelRunningTask(runningTask);
+    }, [page, textContentDispatch]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: Omitted callbacks so they are not called every time they change
+    React.useEffect(() => {
+        if (textContent === undefined) {
+            return;
+        }
+        if (textContent === false) {
+            onLoadError();
+            return;
+        }
+        onLoadSuccess();
+    }, [textContent]);
+    /**
+     * Called when a text layer is rendered successfully
+     */
+    const onRenderSuccess = React.useCallback(() => {
+        if (onRenderTextLayerSuccess) {
+            onRenderTextLayerSuccess();
+        }
+    }, [onRenderTextLayerSuccess]);
+    /**
+     * Called when a text layer failed to render successfully
+     */
+    const onRenderError = React.useCallback((error) => {
+        if (utils.isAbortException(error)) {
+            return;
+        }
+        warning.default(false, error.toString());
+        if (onRenderTextLayerError) {
+            onRenderTextLayerError(error);
+        }
+    }, [onRenderTextLayerError]);
+    function onMouseDown() {
+        const layer = layerElement.current;
+        if (!layer) {
+            return;
+        }
+        layer.classList.add('selecting');
+    }
+    function onMouseUp() {
+        const layer = layerElement.current;
+        if (!layer) {
+            return;
+        }
+        layer.classList.remove('selecting');
+    }
+    const viewport = React.useMemo(() => page.getViewport({ scale, rotation: rotate }), [page, rotate, scale]);
+    React.useLayoutEffect(function renderTextLayer() {
+        if (!page || !textContent) {
+            return;
+        }
+        const { current: layer } = layerElement;
+        if (!layer) {
+            return;
+        }
+        layer.innerHTML = '';
+        const textContentSource = page.streamTextContent({ includeMarkedContent: true });
+        const parameters = {
+            container: layer,
+            textContentSource,
+            viewport,
+        };
+        const cancellable = new pdf.TextLayer(parameters);
+        const runningTask = cancellable;
+        cancellable
+            .render()
+            .then(() => {
+            const end = document.createElement('div');
+            end.className = 'endOfContent';
+            layer.append(end);
+            const layerChildren = layer.querySelectorAll('[role="presentation"]');
+            if (customTextRenderer) {
+                let index = 0;
+                textContent.items.forEach((item, itemIndex) => {
+                    if (!isTextItem(item)) {
+                        return;
+                    }
+                    const child = layerChildren[index];
+                    if (!child) {
+                        return;
+                    }
+                    const content = customTextRenderer({
+                        pageIndex,
+                        pageNumber,
+                        itemIndex,
+                        ...item,
+                    });
+                    child.innerHTML = content;
+                    index += item.str && item.hasEOL ? 2 : 1;
+                });
+            }
+            // Intentional immediate callback
+            onRenderSuccess();
+        })
+            .catch(onRenderError);
+        return () => utils.cancelRunningTask(runningTask);
+    }, [
+        customTextRenderer,
+        onRenderError,
+        onRenderSuccess,
+        page,
+        pageIndex,
+        pageNumber,
+        textContent,
+        viewport,
+    ]);
+    return (
+    // biome-ignore lint/a11y/noStaticElementInteractions: False positive caused by non interactive wrapper listening for bubbling events
+    jsxRuntime.jsx("div", { className: clsx.clsx('react-pdf__Page__textContent', 'textLayer'), onMouseUp: onMouseUp, onMouseDown: onMouseDown, ref: layerElement }));
+}
+
+exports.default = TextLayer;