art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,256 @@
+"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 index$1 = require('../../make-event-props/dist/index.js');
+var index$2 = require('../../merge-refs/dist/index.js');
+var tinyInvariant = require('../../tiny-invariant/dist/esm/tiny-invariant.js');
+var warning = require('../../../_virtual/warning.js');
+var Message = require('./Message.js');
+var AnnotationLayer = require('./Page/AnnotationLayer.js');
+var Canvas = require('./Page/Canvas.js');
+var TextLayer = require('./Page/TextLayer.js');
+var PageContext = require('./PageContext.js');
+var useDocumentContext = require('./shared/hooks/useDocumentContext.js');
+var useResolver = require('./shared/hooks/useResolver.js');
+var utils = require('./shared/utils.js');
+
+const defaultScale = 1;
+/**
+ * Displays a page.
+ *
+ * Should be placed inside `<Document />`. Alternatively, it can have `pdf` prop passed, which can be obtained from `<Document />`'s `onLoadSuccess` callback function, however some advanced functions like linking between pages inside a document may not be working correctly.
+ */
+function Page(props) {
+    const documentContext = useDocumentContext.default();
+    const mergedProps = { ...documentContext, ...props };
+    const { _className = 'react-pdf__Page', _enableRegisterUnregisterPage = true, canvasBackground, canvasRef, children, className, customRenderer: CustomRenderer, customTextRenderer, devicePixelRatio, error = 'Failed to load the page.', filterAnnotations, height, inputRef, loading = 'Loading page…', noData = 'No page specified.', onGetAnnotationsError: onGetAnnotationsErrorProps, onGetAnnotationsSuccess: onGetAnnotationsSuccessProps, onGetStructTreeError: onGetStructTreeErrorProps, onGetStructTreeSuccess: onGetStructTreeSuccessProps, onGetTextError: onGetTextErrorProps, onGetTextSuccess: onGetTextSuccessProps, onLoadError: onLoadErrorProps, onLoadSuccess: onLoadSuccessProps, onRenderAnnotationLayerError: onRenderAnnotationLayerErrorProps, onRenderAnnotationLayerSuccess: onRenderAnnotationLayerSuccessProps, onRenderError: onRenderErrorProps, onRenderSuccess: onRenderSuccessProps, onRenderTextLayerError: onRenderTextLayerErrorProps, onRenderTextLayerSuccess: onRenderTextLayerSuccessProps, pageIndex: pageIndexProps, pageNumber: pageNumberProps, pdf, registerPage, renderAnnotationLayer: renderAnnotationLayerProps = true, renderForms = false, renderMode = 'canvas', renderTextLayer: renderTextLayerProps = true, rotate: rotateProps, scale: scaleProps = defaultScale, unregisterPage, width, ...otherProps } = mergedProps;
+    const [pageState, pageDispatch] = useResolver.default();
+    const { value: page, error: pageError } = pageState;
+    const pageElement = React.useRef(null);
+    tinyInvariant.default(pdf, 'Attempted to load a page, but no document was specified. Wrap <Page /> in a <Document /> or pass explicit `pdf` prop.');
+    const pageIndex = utils.isProvided(pageNumberProps) ? pageNumberProps - 1 : (pageIndexProps !== null && pageIndexProps !== void 0 ? pageIndexProps : null);
+    const pageNumber = pageNumberProps !== null && pageNumberProps !== void 0 ? pageNumberProps : (utils.isProvided(pageIndexProps) ? pageIndexProps + 1 : null);
+    const rotate = rotateProps !== null && rotateProps !== void 0 ? rotateProps : (page ? page.rotate : null);
+    const scale = React.useMemo(() => {
+        if (!page) {
+            return null;
+        }
+        // Be default, we'll render page at 100% * scale width.
+        let pageScale = 1;
+        // Passing scale explicitly null would cause the page not to render
+        const scaleWithDefault = scaleProps !== null && scaleProps !== void 0 ? scaleProps : defaultScale;
+        // If width/height is defined, calculate the scale of the page so it could be of desired width.
+        if (width || height) {
+            const viewport = page.getViewport({ scale: 1, rotation: rotate });
+            if (width) {
+                pageScale = width / viewport.width;
+            }
+            else if (height) {
+                pageScale = height / viewport.height;
+            }
+        }
+        return scaleWithDefault * pageScale;
+    }, [height, page, rotate, scaleProps, width]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: useEffect intentionally triggered on pdf change
+    React.useEffect(function hook() {
+        return () => {
+            if (!utils.isProvided(pageIndex)) {
+                // Impossible, but TypeScript doesn't know that
+                return;
+            }
+            if (_enableRegisterUnregisterPage && unregisterPage) {
+                unregisterPage(pageIndex);
+            }
+        };
+    }, [_enableRegisterUnregisterPage, pdf, pageIndex, unregisterPage]);
+    /**
+     * Called when a page is loaded successfully
+     */
+    function onLoadSuccess() {
+        if (onLoadSuccessProps) {
+            if (!page || !scale) {
+                // Impossible, but TypeScript doesn't know that
+                return;
+            }
+            onLoadSuccessProps(utils.makePageCallback(page, scale));
+        }
+        if (_enableRegisterUnregisterPage && registerPage) {
+            if (!utils.isProvided(pageIndex) || !pageElement.current) {
+                // Impossible, but TypeScript doesn't know that
+                return;
+            }
+            registerPage(pageIndex, pageElement.current);
+        }
+    }
+    /**
+     * Called when a page failed to load
+     */
+    function onLoadError() {
+        if (!pageError) {
+            // Impossible, but TypeScript doesn't know that
+            return;
+        }
+        warning.default(false, pageError.toString());
+        if (onLoadErrorProps) {
+            onLoadErrorProps(pageError);
+        }
+    }
+    // biome-ignore lint/correctness/useExhaustiveDependencies: useEffect intentionally triggered on pdf and pageIndex change
+    React.useEffect(function resetPage() {
+        pageDispatch({ type: 'RESET' });
+    }, [pageDispatch, pdf, pageIndex]);
+    React.useEffect(function loadPage() {
+        if (!pdf || !pageNumber) {
+            return;
+        }
+        const cancellable = index.default(pdf.getPage(pageNumber));
+        const runningTask = cancellable;
+        cancellable.promise
+            .then((nextPage) => {
+            pageDispatch({ type: 'RESOLVE', value: nextPage });
+        })
+            .catch((error) => {
+            pageDispatch({ type: 'REJECT', error });
+        });
+        return () => utils.cancelRunningTask(runningTask);
+    }, [pageDispatch, pdf, pageNumber]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: Omitted callbacks so they are not called every time they change
+    React.useEffect(() => {
+        if (page === undefined) {
+            return;
+        }
+        if (page === false) {
+            onLoadError();
+            return;
+        }
+        onLoadSuccess();
+    }, [page, scale]);
+    const childContext = React.useMemo(() => 
+    // Technically there cannot be page without pageIndex, pageNumber, rotate and scale, but TypeScript doesn't know that
+    utils.isProvided(pageIndex) && pageNumber && utils.isProvided(rotate) && utils.isProvided(scale)
+        ? {
+            _className,
+            canvasBackground,
+            customTextRenderer,
+            devicePixelRatio,
+            filterAnnotations,
+            onGetAnnotationsError: onGetAnnotationsErrorProps,
+            onGetAnnotationsSuccess: onGetAnnotationsSuccessProps,
+            onGetStructTreeError: onGetStructTreeErrorProps,
+            onGetStructTreeSuccess: onGetStructTreeSuccessProps,
+            onGetTextError: onGetTextErrorProps,
+            onGetTextSuccess: onGetTextSuccessProps,
+            onRenderAnnotationLayerError: onRenderAnnotationLayerErrorProps,
+            onRenderAnnotationLayerSuccess: onRenderAnnotationLayerSuccessProps,
+            onRenderError: onRenderErrorProps,
+            onRenderSuccess: onRenderSuccessProps,
+            onRenderTextLayerError: onRenderTextLayerErrorProps,
+            onRenderTextLayerSuccess: onRenderTextLayerSuccessProps,
+            page,
+            pageIndex,
+            pageNumber,
+            renderForms,
+            renderTextLayer: renderTextLayerProps,
+            rotate,
+            scale,
+        }
+        : null, [
+        _className,
+        canvasBackground,
+        customTextRenderer,
+        devicePixelRatio,
+        filterAnnotations,
+        onGetAnnotationsErrorProps,
+        onGetAnnotationsSuccessProps,
+        onGetStructTreeErrorProps,
+        onGetStructTreeSuccessProps,
+        onGetTextErrorProps,
+        onGetTextSuccessProps,
+        onRenderAnnotationLayerErrorProps,
+        onRenderAnnotationLayerSuccessProps,
+        onRenderErrorProps,
+        onRenderSuccessProps,
+        onRenderTextLayerErrorProps,
+        onRenderTextLayerSuccessProps,
+        page,
+        pageIndex,
+        pageNumber,
+        renderForms,
+        renderTextLayerProps,
+        rotate,
+        scale,
+    ]);
+    const eventProps = React.useMemo(() => index$1.default(otherProps, () => page ? (scale ? utils.makePageCallback(page, scale) : undefined) : page), 
+    // biome-ignore lint/correctness/useExhaustiveDependencies: FIXME
+    [otherProps, page, scale]);
+    const pageKey = `${pageIndex}@${scale}/${rotate}`;
+    function renderMainLayer() {
+        switch (renderMode) {
+            case 'custom': {
+                tinyInvariant.default(CustomRenderer, `renderMode was set to "custom", but no customRenderer was passed.`);
+                return jsxRuntime.jsx(CustomRenderer, {}, `${pageKey}_custom`);
+            }
+            case 'none':
+                return null;
+            case 'canvas':
+            default:
+                return jsxRuntime.jsx(Canvas.default, { canvasRef: canvasRef }, `${pageKey}_canvas`);
+        }
+    }
+    function renderTextLayer() {
+        if (!renderTextLayerProps) {
+            return null;
+        }
+        return jsxRuntime.jsx(TextLayer.default, {}, `${pageKey}_text`);
+    }
+    function renderAnnotationLayer() {
+        if (!renderAnnotationLayerProps) {
+            return null;
+        }
+        return jsxRuntime.jsx(AnnotationLayer.default, {}, `${pageKey}_annotations`);
+    }
+    function renderChildren() {
+        function isFulfilledContext(context) {
+            return Boolean(context === null || context === void 0 ? void 0 : context.page);
+        }
+        if (!isFulfilledContext(childContext)) {
+            // Impossible, but TypeScript doesn't know that
+            throw new Error('page is undefined');
+        }
+        const resolvedChildren = typeof children === 'function' ? children(childContext) : children;
+        return (jsxRuntime.jsxs(PageContext.default.Provider, { value: childContext, children: [renderMainLayer(), renderTextLayer(), renderAnnotationLayer(), resolvedChildren] }));
+    }
+    function renderContent() {
+        if (!pageNumber) {
+            return jsxRuntime.jsx(Message.default, { type: "no-data", children: typeof noData === 'function' ? noData() : noData });
+        }
+        if (pdf === null || page === undefined || page === null) {
+            return (jsxRuntime.jsx(Message.default, { type: "loading", children: typeof loading === 'function' ? loading() : loading }));
+        }
+        if (pdf === false || page === false) {
+            return jsxRuntime.jsx(Message.default, { type: "error", children: typeof error === 'function' ? error() : error });
+        }
+        return renderChildren();
+    }
+    return (jsxRuntime.jsx("div", { className: clsx.clsx(_className, className), "data-page-number": pageNumber, 
+        // Assertion is needed for React 18 compatibility
+        ref: index$2.default(inputRef, pageElement), style: {
+            '--scale-round-x': '1px',
+            '--scale-round-y': '1px',
+            '--scale-factor': '1',
+            '--user-unit': `${scale}`,
+            '--total-scale-factor': 'calc(var(--scale-factor) * var(--user-unit))',
+            backgroundColor: canvasBackground || 'white',
+            position: 'relative',
+            minWidth: 'min-content',
+            minHeight: 'min-content',
+        }, ...eventProps, children: renderContent() }));
+}
+
+exports.default = Page;

package/dist/cjs/node_modules/react-pdf/dist/PageContext.js

@@ -0,0 +1,10 @@
+"use client";
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+const pageContext = React.createContext(null);
+
+exports.default = pageContext;

package/dist/cjs/node_modules/react-pdf/dist/PasswordResponses.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// As defined in https://github.com/mozilla/pdf.js/blob/d9fac3459609a807be6506fb3441b5da4b154d14/src/shared/util.js#L371-L374
+const PasswordResponses = {
+    NEED_PASSWORD: 1,
+    INCORRECT_PASSWORD: 2,
+};
+
+exports.default = PasswordResponses;

package/dist/cjs/node_modules/react-pdf/dist/StructTree.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var index = require('../../make-cancellable-promise/dist/index.js');
+var tinyInvariant = require('../../tiny-invariant/dist/esm/tiny-invariant.js');
+var warning = require('../../../_virtual/warning.js');
+var StructTreeItem = require('./StructTreeItem.js');
+var usePageContext = require('./shared/hooks/usePageContext.js');
+var useResolver = require('./shared/hooks/useResolver.js');
+var utils = require('./shared/utils.js');
+
+function StructTree() {
+    const pageContext = usePageContext.default();
+    tinyInvariant.default(pageContext, 'Unable to find Page context.');
+    const { onGetStructTreeError: onGetStructTreeErrorProps, onGetStructTreeSuccess: onGetStructTreeSuccessProps, } = pageContext;
+    const [structTreeState, structTreeDispatch] = useResolver.default();
+    const { value: structTree, error: structTreeError } = structTreeState;
+    const { customTextRenderer, page } = pageContext;
+    function onLoadSuccess() {
+        if (!structTree) {
+            // Impossible, but TypeScript doesn't know that
+            return;
+        }
+        if (onGetStructTreeSuccessProps) {
+            onGetStructTreeSuccessProps(structTree);
+        }
+    }
+    function onLoadError() {
+        if (!structTreeError) {
+            // Impossible, but TypeScript doesn't know that
+            return;
+        }
+        warning.default(false, structTreeError.toString());
+        if (onGetStructTreeErrorProps) {
+            onGetStructTreeErrorProps(structTreeError);
+        }
+    }
+    // biome-ignore lint/correctness/useExhaustiveDependencies: useEffect intentionally triggered on page change
+    React.useEffect(function resetStructTree() {
+        structTreeDispatch({ type: 'RESET' });
+    }, [structTreeDispatch, page]);
+    React.useEffect(function loadStructTree() {
+        if (customTextRenderer) {
+            // TODO: Document why this is necessary
+            return;
+        }
+        if (!page) {
+            return;
+        }
+        const cancellable = index.default(page.getStructTree());
+        const runningTask = cancellable;
+        cancellable.promise
+            .then((nextStructTree) => {
+            structTreeDispatch({ type: 'RESOLVE', value: nextStructTree });
+        })
+            .catch((error) => {
+            structTreeDispatch({ type: 'REJECT', error });
+        });
+        return () => utils.cancelRunningTask(runningTask);
+    }, [customTextRenderer, page, structTreeDispatch]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: Omitted callbacks so they are not called every time they change
+    React.useEffect(() => {
+        if (structTree === undefined) {
+            return;
+        }
+        if (structTree === false) {
+            onLoadError();
+            return;
+        }
+        onLoadSuccess();
+    }, [structTree]);
+    if (!structTree) {
+        return null;
+    }
+    return jsxRuntime.jsx(StructTreeItem.default, { className: "react-pdf__Page__structTree structTree", node: structTree });
+}
+
+exports.default = StructTree;

package/dist/cjs/node_modules/react-pdf/dist/StructTreeItem.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var structTreeUtils = require('./shared/structTreeUtils.js');
+
+function StructTreeItem({ className, node, }) {
+    const attributes = React.useMemo(() => structTreeUtils.getAttributes(node), [node]);
+    const children = React.useMemo(() => {
+        if (!structTreeUtils.isStructTreeNode(node)) {
+            return null;
+        }
+        if (structTreeUtils.isStructTreeNodeWithOnlyContentChild(node)) {
+            return null;
+        }
+        return node.children.map((child, index) => {
+            return (
+            // biome-ignore lint/suspicious/noArrayIndexKey: index is stable here
+            jsxRuntime.jsx(StructTreeItem, { node: child }, index));
+        });
+    }, [node]);
+    return (jsxRuntime.jsx("span", { className: className, ...attributes, children: children }));
+}
+
+exports.default = StructTreeItem;

package/dist/cjs/node_modules/react-pdf/dist/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var pdf = require('../../pdfjs-dist/build/pdf.js');
+var utils = require('./shared/utils.js');
+
+utils.displayWorkerWarning();
+pdf.GlobalWorkerOptions.workerSrc = 'pdf.worker.mjs';
+
+exports.pdfjs = pdf;

package/dist/cjs/node_modules/react-pdf/dist/shared/constants.js

@@ -0,0 +1,62 @@
+'use strict';
+
+// From pdfjs-dist/lib/web/struct_tree_layer_builder.js
+const PDF_ROLE_TO_HTML_ROLE = {
+    // Document level structure types
+    Document: null, // There's a "document" role, but it doesn't make sense here.
+    DocumentFragment: null,
+    // Grouping level structure types
+    Part: 'group',
+    Sect: 'group', // XXX: There's a "section" role, but it's abstract.
+    Div: 'group',
+    Aside: 'note',
+    NonStruct: 'none',
+    // Block level structure types
+    P: null,
+    // H<n>,
+    H: 'heading',
+    Title: null,
+    FENote: 'note',
+    // Sub-block level structure type
+    Sub: 'group',
+    // General inline level structure types
+    Lbl: null,
+    Span: null,
+    Em: null,
+    Strong: null,
+    Link: 'link',
+    Annot: 'note',
+    Form: 'form',
+    // Ruby and Warichu structure types
+    Ruby: null,
+    RB: null,
+    RT: null,
+    RP: null,
+    Warichu: null,
+    WT: null,
+    WP: null,
+    // List standard structure types
+    L: 'list',
+    LI: 'listitem',
+    LBody: null,
+    // Table standard structure types
+    Table: 'table',
+    TR: 'row',
+    TH: 'columnheader',
+    TD: 'cell',
+    THead: 'columnheader',
+    TBody: null,
+    TFoot: null,
+    // Standard structure type Caption
+    Caption: null,
+    // Standard structure type Figure
+    Figure: 'figure',
+    // Standard structure type Formula
+    Formula: null,
+    // standard structure type Artifact
+    Artifact: null,
+};
+const HEADING_PATTERN = /^H(\d+)$/;
+
+exports.HEADING_PATTERN = HEADING_PATTERN;
+exports.PDF_ROLE_TO_HTML_ROLE = PDF_ROLE_TO_HTML_ROLE;

package/dist/cjs/node_modules/react-pdf/dist/shared/hooks/useDocumentContext.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var DocumentContext = require('../../DocumentContext.js');
+
+function useDocumentContext() {
+    return React.useContext(DocumentContext.default);
+}
+
+exports.default = useDocumentContext;

package/dist/cjs/node_modules/react-pdf/dist/shared/hooks/usePageContext.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var PageContext = require('../../PageContext.js');
+
+function usePageContext() {
+    return React.useContext(PageContext.default);
+}
+
+exports.default = usePageContext;

package/dist/cjs/node_modules/react-pdf/dist/shared/hooks/useResolver.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+function reducer(state, action) {
+    switch (action.type) {
+        case 'RESOLVE':
+            return { value: action.value, error: undefined };
+        case 'REJECT':
+            return { value: false, error: action.error };
+        case 'RESET':
+            return { value: undefined, error: undefined };
+        default:
+            return state;
+    }
+}
+function useResolver() {
+    return React.useReducer((reducer), { value: undefined, error: undefined });
+}
+
+exports.default = useResolver;

package/dist/cjs/node_modules/react-pdf/dist/shared/structTreeUtils.js

@@ -0,0 +1,75 @@
+'use strict';
+
+var constants = require('./constants.js');
+
+function isPdfRole(role) {
+    return role in constants.PDF_ROLE_TO_HTML_ROLE;
+}
+function isStructTreeNode(node) {
+    return 'children' in node;
+}
+function isStructTreeNodeWithOnlyContentChild(node) {
+    if (!isStructTreeNode(node)) {
+        return false;
+    }
+    return node.children.length === 1 && 0 in node.children && 'id' in node.children[0];
+}
+function getRoleAttributes(node) {
+    const attributes = {};
+    if (isStructTreeNode(node)) {
+        const { role } = node;
+        const matches = role.match(constants.HEADING_PATTERN);
+        if (matches) {
+            attributes.role = 'heading';
+            attributes['aria-level'] = Number(matches[1]);
+        }
+        else if (isPdfRole(role)) {
+            const htmlRole = constants.PDF_ROLE_TO_HTML_ROLE[role];
+            if (htmlRole) {
+                attributes.role = htmlRole;
+            }
+        }
+    }
+    return attributes;
+}
+function getBaseAttributes(node) {
+    const attributes = {};
+    if (isStructTreeNode(node)) {
+        if (node.alt !== undefined) {
+            attributes['aria-label'] = node.alt;
+        }
+        if (node.lang !== undefined) {
+            attributes.lang = node.lang;
+        }
+        if (isStructTreeNodeWithOnlyContentChild(node)) {
+            const [child] = node.children;
+            if (child) {
+                const childAttributes = getBaseAttributes(child);
+                return {
+                    ...attributes,
+                    ...childAttributes,
+                };
+            }
+        }
+    }
+    else if ('id' in node) {
+        attributes['aria-owns'] = node.id;
+    }
+    return attributes;
+}
+function getAttributes(node) {
+    if (!node) {
+        return null;
+    }
+    return {
+        ...getRoleAttributes(node),
+        ...getBaseAttributes(node),
+    };
+}
+
+exports.getAttributes = getAttributes;
+exports.getBaseAttributes = getBaseAttributes;
+exports.getRoleAttributes = getRoleAttributes;
+exports.isPdfRole = isPdfRole;
+exports.isStructTreeNode = isStructTreeNode;
+exports.isStructTreeNodeWithOnlyContentChild = isStructTreeNodeWithOnlyContentChild;