art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,59 @@
+// 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+)$/;
+
+export { HEADING_PATTERN, PDF_ROLE_TO_HTML_ROLE };

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

@@ -0,0 +1,8 @@
+import { useContext } from 'react';
+import documentContext from '../../DocumentContext.js';
+
+function useDocumentContext() {
+    return useContext(documentContext);
+}
+
+export { useDocumentContext as default };

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

@@ -0,0 +1,8 @@
+import { useContext } from 'react';
+import pageContext from '../../PageContext.js';
+
+function usePageContext() {
+    return useContext(pageContext);
+}
+
+export { usePageContext as default };

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

@@ -0,0 +1,19 @@
+import { useReducer } from '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 useReducer((reducer), { value: undefined, error: undefined });
+}
+
+export { useResolver as default };

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

@@ -0,0 +1,68 @@
+import { HEADING_PATTERN, PDF_ROLE_TO_HTML_ROLE } from './constants.js';
+
+function isPdfRole(role) {
+    return role in 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(HEADING_PATTERN);
+        if (matches) {
+            attributes.role = 'heading';
+            attributes['aria-level'] = Number(matches[1]);
+        }
+        else if (isPdfRole(role)) {
+            const htmlRole = 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),
+    };
+}
+
+export { getAttributes, getBaseAttributes, getRoleAttributes, isPdfRole, isStructTreeNode, isStructTreeNodeWithOnlyContentChild };

package/dist/esm/node_modules/react-pdf/dist/shared/utils.js

@@ -0,0 +1,146 @@
+import invariant from '../../../tiny-invariant/dist/esm/tiny-invariant.js';
+import warning from '../../../../_virtual/warning.js';
+
+/**
+ * Checks if we're running in a browser environment.
+ */
+const isBrowser = typeof window !== 'undefined';
+/**
+ * Checks whether we're running from a local file system.
+ */
+const isLocalFileSystem = isBrowser && window.location.protocol === 'file:';
+/**
+ * Checks whether a variable is defined.
+ *
+ * @param {*} variable Variable to check
+ */
+function isDefined(variable) {
+    return typeof variable !== 'undefined';
+}
+/**
+ * Checks whether a variable is defined and not null.
+ *
+ * @param {*} variable Variable to check
+ */
+function isProvided(variable) {
+    return isDefined(variable) && variable !== null;
+}
+/**
+ * Checks whether a variable provided is a string.
+ *
+ * @param {*} variable Variable to check
+ */
+function isString(variable) {
+    return typeof variable === 'string';
+}
+/**
+ * Checks whether a variable provided is an ArrayBuffer.
+ *
+ * @param {*} variable Variable to check
+ */
+function isArrayBuffer(variable) {
+    return variable instanceof ArrayBuffer;
+}
+/**
+ * Checks whether a variable provided is a Blob.
+ *
+ * @param {*} variable Variable to check
+ */
+function isBlob(variable) {
+    invariant(isBrowser, 'isBlob can only be used in a browser environment');
+    return variable instanceof Blob;
+}
+/**
+ * Checks whether a variable provided is a data URI.
+ *
+ * @param {*} variable String to check
+ */
+function isDataURI(variable) {
+    return isString(variable) && /^data:/.test(variable);
+}
+function dataURItoByteString(dataURI) {
+    invariant(isDataURI(dataURI), 'Invalid data URI.');
+    const [headersString = '', dataString = ''] = dataURI.split(',');
+    const headers = headersString.split(';');
+    if (headers.indexOf('base64') !== -1) {
+        return atob(dataString);
+    }
+    return unescape(dataString);
+}
+function getDevicePixelRatio() {
+    return (isBrowser && window.devicePixelRatio) || 1;
+}
+const allowFileAccessFromFilesTip = 'On Chromium based browsers, you can use --allow-file-access-from-files flag for debugging purposes.';
+function displayCORSWarning() {
+    warning(!isLocalFileSystem, `Loading PDF as base64 strings/URLs may not work on protocols other than HTTP/HTTPS. ${allowFileAccessFromFilesTip}`);
+}
+function displayWorkerWarning() {
+    warning(!isLocalFileSystem, `Loading PDF.js worker may not work on protocols other than HTTP/HTTPS. ${allowFileAccessFromFilesTip}`);
+}
+function cancelRunningTask(runningTask) {
+    if (runningTask === null || runningTask === void 0 ? void 0 : runningTask.cancel)
+        runningTask.cancel();
+}
+function makePageCallback(page, scale) {
+    Object.defineProperty(page, 'width', {
+        get() {
+            return this.getViewport({ scale }).width;
+        },
+        configurable: true,
+    });
+    Object.defineProperty(page, 'height', {
+        get() {
+            return this.getViewport({ scale }).height;
+        },
+        configurable: true,
+    });
+    Object.defineProperty(page, 'originalWidth', {
+        get() {
+            return this.getViewport({ scale: 1 }).width;
+        },
+        configurable: true,
+    });
+    Object.defineProperty(page, 'originalHeight', {
+        get() {
+            return this.getViewport({ scale: 1 }).height;
+        },
+        configurable: true,
+    });
+    return page;
+}
+function isAbortException(error) {
+    return error.name === 'AbortException' || error.name === 'RenderingCancelledException';
+}
+function loadFromFile(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            if (!reader.result) {
+                return reject(new Error('Error while reading a file.'));
+            }
+            resolve(reader.result);
+        };
+        reader.onerror = (event) => {
+            if (!event.target) {
+                return reject(new Error('Error while reading a file.'));
+            }
+            const { error } = event.target;
+            if (!error) {
+                return reject(new Error('Error while reading a file.'));
+            }
+            switch (error.code) {
+                case error.NOT_FOUND_ERR:
+                    return reject(new Error('Error while reading a file: File not found.'));
+                case error.SECURITY_ERR:
+                    return reject(new Error('Error while reading a file: Security error.'));
+                case error.ABORT_ERR:
+                    return reject(new Error('Error while reading a file: Aborted.'));
+                default:
+                    return reject(new Error('Error while reading a file.'));
+            }
+        };
+        reader.readAsArrayBuffer(file);
+    });
+}
+
+export { cancelRunningTask, dataURItoByteString, displayCORSWarning, displayWorkerWarning, getDevicePixelRatio, isAbortException, isArrayBuffer, isBlob, isBrowser, isDataURI, isDefined, isLocalFileSystem, isProvided, isString, loadFromFile, makePageCallback };

package/dist/esm/node_modules/tiny-invariant/dist/esm/tiny-invariant.js

@@ -0,0 +1,15 @@
+var isProduction = process.env.NODE_ENV === 'production';
+var prefix = 'Invariant failed';
+function invariant(condition, message) {
+    if (condition) {
+        return;
+    }
+    if (isProduction) {
+        throw new Error(prefix);
+    }
+    var provided = typeof message === 'function' ? message() : message;
+    var value = provided ? "".concat(prefix, ": ").concat(provided) : prefix;
+    throw new Error(value);
+}
+
+export { invariant as default };

package/dist/esm/node_modules/tslib/tslib.es6.js

@@ -14,6 +14,20 @@ PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
 /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
 
 var __assign = function() {
     __assign = Object.assign || function __assign(t) {
@@ -48,6 +62,43 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+/** @deprecated */
+function __spreadArrays() {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+}
+
 function __spreadArray(to, from, pack) {
     if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
         if (ar || !(i in from)) {
@@ -63,4 +114,4 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-export { __assign, __awaiter, __rest, __spreadArray };
+export { __assign, __awaiter, __extends, __generator, __rest, __spreadArray, __spreadArrays };

package/dist/esm/node_modules/warning/warning.js

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var warning_1;
+var hasRequiredWarning;
+
+function requireWarning () {
+	if (hasRequiredWarning) return warning_1;
+	hasRequiredWarning = 1;
+
+	/**
+	 * Similar to invariant but only logs a warning if the condition is not met.
+	 * This can be used to log issues in development environments in critical
+	 * paths. Removing the logging code for production environments will keep the
+	 * same logic and follow the same code paths.
+	 */
+
+	var __DEV__ = process.env.NODE_ENV !== 'production';
+
+	var warning = function() {};
+
+	if (__DEV__) {
+	  var printWarning = function printWarning(format, args) {
+	    var len = arguments.length;
+	    args = new Array(len > 1 ? len - 1 : 0);
+	    for (var key = 1; key < len; key++) {
+	      args[key - 1] = arguments[key];
+	    }
+	    var argIndex = 0;
+	    var message = 'Warning: ' +
+	      format.replace(/%s/g, function() {
+	        return args[argIndex++];
+	      });
+	    if (typeof console !== 'undefined') {
+	      console.error(message);
+	    }
+	    try {
+	      // --- Welcome to debugging React ---
+	      // This error was thrown as a convenience so that you can use this stack
+	      // to find the callsite that caused this warning to fire.
+	      throw new Error(message);
+	    } catch (x) {}
+	  };
+
+	  warning = function(condition, format, args) {
+	    var len = arguments.length;
+	    args = new Array(len > 2 ? len - 2 : 0);
+	    for (var key = 2; key < len; key++) {
+	      args[key - 2] = arguments[key];
+	    }
+	    if (format === undefined) {
+	      throw new Error(
+	          '`warning(condition, format, ...args)` requires a warning ' +
+	          'message argument'
+	      );
+	    }
+	    if (!condition) {
+	      printWarning.apply(null, [format].concat(args));
+	    }
+	  };
+	}
+
+	warning_1 = warning;
+	return warning_1;
+}
+
+export { requireWarning as __require };

package/dist/esm/utils/file.js

@@ -0,0 +1,66 @@
+/**
+ * Prompts the user to select a file (via a hidden <input type="file"/>).
+ * Returns a Promise<File | undefined>:
+ *  - File: if the user selected a file
+ *  - undefined: if the user canceled or timed out
+ */
+/**
+ * Saves a file to the user's device by creating a temporary link element
+ * and simulating a click to trigger a download.
+ */
+function saveFile(filename, blob) {
+    // Create a blob URL for the file
+    const blobUrl = URL.createObjectURL(blob);
+    // Create a temporary <a> element to download
+    let link = document.createElement("a");
+    link.download = filename;
+    link.href = blobUrl;
+    // Trigger the download by appending and clicking
+    document.body.appendChild(link);
+    link.click();
+    // Cleanup
+    setTimeout(() => {
+        link.remove();
+        window.URL.revokeObjectURL(blobUrl);
+        link = null;
+    }, 0);
+}
+const CLEANUP_TIMEOUT = 60000;
+/**
+ * Prints a Blob by loading it into an offscreen iframe and triggering
+ * the browser's print dialog. Falls back to opening a new tab if the
+ * iframe approach is blocked (e.g. cross-origin restrictions).
+ */
+function printBlob(blob) {
+    const url = URL.createObjectURL(blob);
+    const iframe = document.createElement("iframe");
+    iframe.style.position = "fixed";
+    iframe.style.width = "0";
+    iframe.style.height = "0";
+    iframe.style.border = "0";
+    iframe.style.left = "-9999px";
+    iframe.src = url;
+    let cleaned = false;
+    const cleanup = () => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        URL.revokeObjectURL(url);
+        iframe.remove();
+    };
+    iframe.onload = () => {
+        var _a, _b, _c;
+        try {
+            (_a = iframe.contentWindow) === null || _a === void 0 ? void 0 : _a.focus();
+            (_b = iframe.contentWindow) === null || _b === void 0 ? void 0 : _b.print();
+        }
+        catch (_d) {
+            window.open(url);
+        }
+        (_c = iframe.contentWindow) === null || _c === void 0 ? void 0 : _c.addEventListener("afterprint", cleanup);
+        setTimeout(cleanup, CLEANUP_TIMEOUT);
+    };
+    document.body.appendChild(iframe);
+}
+
+export { printBlob, saveFile };

package/dist/styles.css

@@ -1843,18 +1843,30 @@
   .w-2\.5 {
     width: calc(var(--spacing) * 2.5);
   }
+  .w-2\/3 {
+    width: calc(2/3 * 100%);
+  }
   .w-3 {
     width: calc(var(--spacing) * 3);
   }
   .w-3\.5 {
     width: calc(var(--spacing) * 3.5);
   }
+  .w-3\/4 {
+    width: calc(3/4 * 100%);
+  }
   .w-4 {
     width: calc(var(--spacing) * 4);
   }
+  .w-4\/5 {
+    width: calc(4/5 * 100%);
+  }
   .w-5 {
     width: calc(var(--spacing) * 5);
   }
+  .w-5\/6 {
+    width: calc(5/6 * 100%);
+  }
   .w-6 {
     width: calc(var(--spacing) * 6);
   }
@@ -1918,6 +1930,9 @@
   .w-\[64px\] {
     width: 64px;
   }
+  .w-\[72px\] {
+    width: 72px;
+  }
   .w-\[84px\] {
     width: 84px;
   }
@@ -2098,6 +2113,9 @@
   .min-w-\[12rem\] {
     min-width: 12rem;
   }
+  .min-w-\[64px\] {
+    min-width: 64px;
+  }
   .min-w-\[80px\] {
     min-width: 80px;
   }
@@ -4629,6 +4647,9 @@
     --tw-ease: linear;
     transition-timing-function: linear;
   }
+  .will-change-transform {
+    will-change: transform;
+  }
   .outline-none {
     --tw-outline-style: none;
     outline-style: none;